@khorsheed/dsh-library 0.0.0-stage → 0.1.0

package/lib/index.js

@@ -0,0 +1,3318 @@
+import { A as LIBRARY_ID_PATTERN, B as coverTopic, C as normalizeRoadmap, D as LIBRARY_COLORS, E as LEITNER_INTERVAL_DAYS, F as MAX_WEAKNESS, G as parseLocator, H as isLibraryId, I as STATE_ROOT_SEGMENT, L as TEMPLATE_LOOK, M as LIBRARY_RESOURCE_ORIGINS, N as LIBRARY_STATE_VERSION, O as LIBRARY_EVENT_TYPES, P as MAX_BOX, R as acceptanceLines, S as normalizeResource, T as DEFAULT_PASS_RATIO, U as isThickResource, V as formatLocator, W as libraryErrorMessage, _ as normalizeLibraryIndex, a as LibraryStore, b as normalizeProject, c as assertLibraryId, d as normalizeAssessment, f as normalizeAttachmentRef, g as normalizeEvent, h as normalizeCard, i as stationMastery, j as LIBRARY_RESOURCE_KINDS, k as LIBRARY_ICONS, l as emptyLibraryIndex, m as normalizeBindings, n as masteryChanges, o as LibraryStoreError, p as normalizeAttempt, s as acquireLibraryLock, t as profileOf, u as mintLibraryId, v as normalizeNodeCover, w as resolveLibraryStateRoot, y as normalizePage, z as coverKind } from "./profiles-CFrPQdfO.js";
+import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+//#region lib/types/service/core.js
+const PACKAGE_NAME = "@khorsheed/dsh-library";
+/**
+* Thrown by every public verb after {@link LibraryService.dispose} ran (an
+* explicit teardown, or the borrowed Context's own disposal): a coded,
+* package-named refusal, never a silent operation on a dead Context. The
+* disposed instance stays dead — a rebuild over the same state root is a NEW
+* service instance's business (the canvas-novel/sidechat precedent).
+*/
+var LibraryDisposedError = class extends Error {
+	code;
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+		this.name = "LibraryDisposedError";
+	}
+};
+/** A refusal in one line. */
+function refuse(error, message) {
+	return {
+		ok: false,
+		error,
+		message
+	};
+}
+/** Wrap a store failure as a refusal (the service's error channel is values). */
+function storeRefusal(error) {
+	if (error instanceof LibraryStoreError) return refuse(error.kind === "corrupt" ? "corrupt" : error.kind === "unavailable" ? "storage-unavailable" : "io", error.message);
+	return refuse("io", `library: ${libraryErrorMessage(error)}`);
+}
+const DAY_MS = 864e5;
+/** The Leitner due date for a box: box b waits INTERVALS[min(b, 4)] days. */
+function leitnerDueAt(box, from = /* @__PURE__ */ new Date()) {
+	const days = LEITNER_INTERVAL_DAYS[Math.min(Math.max(box, 0), LEITNER_INTERVAL_DAYS.length - 1)];
+	return new Date(from.getTime() + days * DAY_MS).toISOString();
+}
+/** Whitespace-normalize a quote before comparing it with a page's text. */
+function normalizeFragment(value) {
+	return value.normalize("NFKC").replace(/\s+/g, " ").trim().toLowerCase();
+}
+/** Clamp a weakness score into 0..MAX. */
+function clampWeakness(value) {
+	return Math.min(Math.max(value, 0), 3);
+}
+/** Live = not deleted. */
+function live(card) {
+	return card.status !== "deleted";
+}
+/**
+* The library's service core. Constructing it never throws and never touches
+* the disk: the store probes writability lazily, so a read-only deployment
+* boots and answers `storage-unavailable` on writes. Disposal follows the
+* borrowed Context: an instance mounted dynamically (per state root, say)
+* dies with its mounting Context, and a dead instance refuses every verb
+* coded, reads included.
+*/
+var LibraryServiceCore = class {
+	ctx;
+	/** The store; public for the package's own tests and diagnostics. */
+	store;
+	/** Listeners told after every project mutation (the tab's live refresh, the context cache). */
+	listeners = /* @__PURE__ */ new Set();
+	/** When this instance last wrote anything (a project created, an index edit — writes that log no event). */
+	lastChangeAt;
+	/** The newest session-made write (a library tool from a session): the client's cue to reveal the sidebar. */
+	lastSessionWrite;
+	/** Set by {@link dispose} (explicit, or the borrowed Context's teardown); every public verb refuses afterwards. */
+	disposed = false;
+	constructor(ctx, config = {}) {
+		this.ctx = ctx;
+		this.store = new LibraryStore(config);
+		ctx.effect(() => () => {
+			this.dispose();
+		}, "library: dispose on context teardown");
+	}
+	/**
+	* Refuse one public verb after disposal: the instance is dead and nothing
+	* it could still answer is meant to be consumed — reads included, so a
+	* mounting side never keeps consuming a stale instance indefinitely.
+	*/
+	assertAlive(verb) {
+		if (this.disposed) throw new LibraryDisposedError(`${PACKAGE_NAME}: ${verb} after dispose`, "disposed");
+	}
+	/**
+	* Tear the instance down (also wired to the borrowed Context's disposal at
+	* construction). Idempotent and TERMINAL: the listener set is dropped and
+	* afterwards every public verb refuses with {@link LibraryDisposedError};
+	* a write that already passed the write boundary may complete (the store's
+	* lock/temp-write/atomic-rename keeps the disk side safe), one reaching it
+	* after disposal refuses before lock acquisition. A rebuild over the same
+	* state root is a NEW instance's business.
+	*/
+	dispose() {
+		this.disposed = true;
+		this.listeners.clear();
+	}
+	/**
+	* What a client may rely on in this composition: storage availability with
+	* its reason, and the attachment probe's verdict at call time. A read-only
+	* display contract — enforcement stays at the write gates, unchanged.
+	*/
+	async capabilities() {
+		this.assertAlive("capabilities");
+		return {
+			protocolVersion: 1,
+			hasStorage: this.store.available,
+			...this.store.unavailableReason === void 0 ? {} : { storageUnavailableReason: this.store.unavailableReason },
+			hasAttachments: this.ctx.get("attachments") !== void 0
+		};
+	}
+	/** Subscribe to project mutations; returns the unsubscribe. */
+	onChange(listener) {
+		this.assertAlive("onChange");
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	changed(projectId) {
+		this.lastChangeAt = (/* @__PURE__ */ new Date()).toISOString();
+		for (const listener of this.listeners) try {
+			listener(projectId);
+		} catch {}
+	}
+	/** Run a project mutation under its lock, then notify. */
+	async mutate(projectId, fn) {
+		this.assertAlive("mutate");
+		try {
+			const outcome = await this.store.withProjectLock(projectId, fn);
+			if (outcome.ok) this.changed(projectId);
+			return outcome;
+		} catch (error) {
+			return storeRefusal(error);
+		}
+	}
+	/** A library tool from this session just wrote (kit.autoBind calls it after every successful write). */
+	noteSessionWrite(session) {
+		this.lastSessionWrite = {
+			session,
+			at: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+	event(projectId, type, fields = {}) {
+		this.store.appendEvents(projectId, [{
+			at: fields.at ?? (/* @__PURE__ */ new Date()).toISOString(),
+			type,
+			...fields
+		}]);
+	}
+	/** The project, or a not-found refusal that teaches where the list lives. */
+	readProjectOrRefusal(projectId) {
+		let project;
+		try {
+			project = this.store.readProject(projectId);
+		} catch (error) {
+			return storeRefusal(error);
+		}
+		if (project === void 0) return refuse("not-found", `no project ${JSON.stringify(projectId)} — library_read · projects lists every project; create one with library_project`);
+		return { value: project };
+	}
+};
+//#endregion
+//#region lib/types/cards.js
+/** Fold one English word's regular plural (instalments → instalment, theories → theory). */
+function foldPlural(word) {
+	if (!/^[a-z]+$/.test(word) || word.length <= 3) return word;
+	if (word.endsWith("ies") && word.length > 4) return `${word.slice(0, -3)}y`;
+	if (/(?:s|x|z|ch|sh)es$/.test(word)) return word.slice(0, -2);
+	if (word.endsWith("s") && !word.endsWith("ss") && !word.endsWith("us") && !word.endsWith("is")) return word.slice(0, -1);
+	return word;
+}
+/**
+* A term's comparison key: NFKC (full-width → half-width), lower case, inner
+* whitespace collapsed, surrounding punctuation and brackets dropped, each
+* English word's plural folded.
+*/
+function cardKey(term) {
+	return term.normalize("NFKC").toLowerCase().replace(/\s+/g, " ").trim().replace(/^[\p{P}\p{S}\s]+|[\p{P}\p{S}\s]+$/gu, "").split(" ").map(foldPlural).join(" ");
+}
+/** Every key a card answers to: its term and its aliases. */
+function cardKeys(card) {
+	return [...new Set([card.term, ...card.aliases].map(cardKey).filter((key) => key !== ""))];
+}
+/** The comparison units of a key: English words, or single CJK characters. */
+function units(key) {
+	const out = /* @__PURE__ */ new Set();
+	for (const token of key.split(/[\s/／、,，·・-]+/)) {
+		if (token === "") continue;
+		if (/[\p{Script=Han}]/u.test(token)) {
+			for (const char of token) if (/[\p{Script=Han}\p{L}\p{N}]/u.test(char)) out.add(char);
+		} else out.add(token);
+	}
+	return out;
+}
+/** How alike two keys look, 0..1 (1 = one contains the other). */
+function keySimilarity(a, b) {
+	if (a === "" || b === "") return 0;
+	if (a === b) return 1;
+	const shorter = a.length <= b.length ? a : b;
+	const longer = shorter === a ? b : a;
+	const minimum = /[\p{Script=Han}]/u.test(shorter) ? 2 : 4;
+	if (shorter.length >= minimum && longer.includes(shorter)) return 1;
+	const left = units(a);
+	const right = units(b);
+	if (left.size === 0 || right.size === 0) return 0;
+	let shared = 0;
+	for (const unit of left) if (right.has(unit)) shared += 1;
+	return shared / Math.max(left.size, right.size);
+}
+/** The threshold above which two keys are a near-duplicate worth asking about. */
+const NEAR_DUPLICATE = .6;
+/** The live card an input key matches exactly, when one does. */
+function exactMatch(cards, keys) {
+	const wanted = new Set(keys);
+	return cards.find((card) => card.status !== "deleted" && cardKeys(card).some((key) => wanted.has(key)));
+}
+/** Up to `limit` live cards that look like the input, most alike first. */
+function nearMatches(cards, keys, limit = 3) {
+	const scored = [];
+	for (const card of cards) {
+		if (card.status === "deleted") continue;
+		let best = 0;
+		for (const own of cardKeys(card)) for (const key of keys) best = Math.max(best, keySimilarity(own, key));
+		if (best >= .6) scored.push({
+			card,
+			score: best
+		});
+	}
+	scored.sort((x, y) => y.score - x.score);
+	return scored.slice(0, limit).map((entry) => entry.card);
+}
+/**
+* Whether a card answers a free-text query: any key or the gloss / user gloss
+* / a context sentence contains the query's key (the sidebar's ⌕ and the
+* coach's `library_read · cards` share this).
+*/
+function cardMatchesQuery(card, query) {
+	const needle = cardKey(query);
+	if (needle === "") return true;
+	if (cardKeys(card).some((key) => key.includes(needle))) return true;
+	return [
+		card.gloss,
+		card.userGloss ?? "",
+		...card.contexts.map((context) => context.sentence)
+	].join("\n").normalize("NFKC").toLowerCase().includes(query.normalize("NFKC").toLowerCase().trim());
+}
+//#endregion
+//#region lib/types/service/rules.js
+/**
+* The library's pure rules: roadmap shape validation, the unlock pass, the
+* covers' evidence gate, and two small helpers. No store, no context — the
+* service layers and the tools call them.
+*
+* @module @khorsheed/dsh-library/service/rules
+*/
+/** A node's title, for event rows. */
+function titleOf(nodes, nodeId) {
+	return nodes.find((node) => node.id === nodeId)?.title ?? "";
+}
+/**
+* The option an answer key names — a letter in range, a lettered option, the
+* option text, else a one-way containment — or -1. The sidebar's judge
+* (`client/judge.ts`'s choiceIndex) resolves the same spellings; a question
+* this resolves to -1 is judged wrong no matter what the learner picks, so
+* the write gate refuses it.
+*/
+function choiceOptionIndex(options, answer) {
+	const key = normalizeFragment(answer);
+	if (/^[a-z]$/.test(key)) {
+		const at = key.charCodeAt(0) - 97;
+		return at < options.length ? at : -1;
+	}
+	const lettered = /^([a-z])[.、)）:：]\s*/.exec(key);
+	if (lettered !== null) {
+		const at = lettered[1].charCodeAt(0) - 97;
+		return at < options.length ? at : -1;
+	}
+	const exact = options.findIndex((option) => normalizeFragment(option) === key);
+	if (exact >= 0) return exact;
+	return options.findIndex((option) => normalizeFragment(option).includes(key) || key.includes(normalizeFragment(option)));
+}
+/** Move every locked node whose deps are all done to current. */
+function unlockReady(nodes) {
+	const doneIds = new Set(nodes.filter((node) => node.state === "done").map((node) => node.id));
+	const unlocked = [];
+	return {
+		nodes: nodes.map((node) => {
+			if (node.state === "locked" && node.dependsOn.every((dep) => doneIds.has(dep))) {
+				unlocked.push(node.id);
+				return {
+					...node,
+					state: "current"
+				};
+			}
+			return node;
+		}),
+		unlocked
+	};
+}
+/**
+* Structural validation of a roadmap's nodes; returns the teaching error or
+* undefined. `scope.resourceId` marks a resource-level draft: the special case
+* whose every node covers that one resource only. Every per-node problem is
+* collected and reported at once — a draft with five mistakes earns ONE
+* refusal listing all five, not five fail-fast round trips (each retry
+* resends the whole nodes payload).
+*/
+function validateRoadmapShape(nodes, scope) {
+	const errors = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const [index, node] of nodes.entries()) {
+		if (typeof node.id !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(node.id) || seen.has(node.id)) errors.push(`nodes[${index}] needs a unique id made of letters, digits, '.', '_', '-' (n1, n2, … is plenty)`);
+		else seen.add(node.id);
+		if (typeof node.title !== "string" || node.title.trim() === "") errors.push(`nodes[${index}] (${node.id}) needs a title — what the learner masters here`);
+		const gateKnown = node.gate === "quiz" || node.gate === "read" || node.gate === "acceptance";
+		if (!gateKnown) errors.push(`nodes[${index}] (${node.id}) needs gate: "quiz" | "acceptance" | "read" — quiz nodes gate on a quiz; acceptance nodes gate on acceptance (a hands-on deliverable); read nodes are optional side stops (读完 completes them, they never gate)`);
+		else {
+			if (node.gate === "acceptance" && (node.acceptance === void 0 || node.acceptance.length === 0)) errors.push(`nodes[${index}] (${node.id}) is an acceptance station — it needs acceptance: ["...", ...], the lines the coach judges one verdict each at assess time`);
+			if (node.gate !== "acceptance" && node.acceptance !== void 0 && node.acceptance.length > 0) errors.push(`nodes[${index}] (${node.id}) carries acceptance but its gate is "${node.gate}" — if these lines are judged one verdict each at completion, set gate: "acceptance"; if they are descriptive expectations while a quiz gates the station, move them into goals: [...]`);
+		}
+		for (const [lineIndex, entry] of (Array.isArray(node.acceptance) ? node.acceptance : []).entries()) {
+			if (typeof entry === "string") continue;
+			if (entry === null || typeof entry !== "object" || typeof entry.line !== "string" || entry.line.trim() === "") {
+				errors.push(`nodes[${index}] (${node.id}) acceptance line ${lineIndex + 1} needs its line text`);
+				continue;
+			}
+			if (entry.ref !== void 0 && !scope.hasAssessment(entry.ref)) errors.push(`nodes[${index}] (${node.id}) acceptance line ${lineIndex + 1} refs assessment ${JSON.stringify(entry.ref)}, which does not exist — compose it first (library_quiz), then draft`);
+		}
+		const pointCount = Array.isArray(node.points) ? node.points.length : 0;
+		if (node.gate === "quiz" && pointCount > 5) errors.push(`nodes[${index}] (${node.id}) has ${pointCount} points — one station is one lesson of 3–5 points: split it into consecutive stations, simple before hard`);
+		else if (node.gate === "quiz" && pointCount > 0 && pointCount < 3) errors.push(`nodes[${index}] (${node.id}) has ${pointCount} point${pointCount === 1 ? "" : "s"} — a lesson carries 3–5: merge it with a neighbour or name what else it teaches`);
+		if (!Array.isArray(node.covers) || node.covers.length === 0) errors.push(`nodes[${index}] (${node.id}) needs at least one cover — what the station draws on: "r_…#1-5" (a shelf resource + contents rows) | "https://…" (a web text) | "topic: …" (plain coached teaching)`);
+		else for (const cover of node.covers) {
+			if (cover === null || typeof cover !== "object" || typeof cover.ref !== "string" || cover.ref.trim() === "") {
+				errors.push(`nodes[${index}] (${node.id}) has a cover with no ref — "r_…#1-5" | "https://…" | "topic: …"`);
+				continue;
+			}
+			const kind = coverKind(cover);
+			if (kind === "resource") {
+				if (!isLibraryId(cover.ref)) {
+					errors.push(`nodes[${index}] (${node.id}) covers ${JSON.stringify(cover.ref)}, which is neither a shelf resource id (r_…) nor a usable ref — "r_…#1-5" | "https://…" | "topic: …"`);
+					continue;
+				}
+				const covered = scope.resource(cover.ref);
+				if (covered === void 0) {
+					errors.push(`nodes[${index}] (${node.id}) covers resource ${JSON.stringify(cover.ref)}, which is not on the project's shelf — library_read · resources lists them; register it first (library_textbook)`);
+					continue;
+				}
+				if (cover.locator !== void 0) {
+					if (!isThickResource(covered)) {
+						errors.push(`nodes[${index}] (${node.id}) puts a locator on 《${covered.title}》, which is a thin link (no contents) — a thin link is covered whole: drop the locator`);
+						continue;
+					}
+					const ranges = parseLocator(cover.locator);
+					if (ranges.length === 0) {
+						errors.push(`nodes[${index}] (${node.id}) has an unreadable locator ${JSON.stringify(cover.locator)} — locators count contents rows, 1-based and inclusive: "1-5,7"`);
+						continue;
+					}
+					if (covered.id === scope.resourceId && covered.origin === "authored" && ranges.reduce((rows, range) => rows + range.to - range.from + 1, 0) > 1) errors.push(`nodes[${index}] (${node.id}) spans ${cover.locator} of 《${covered.title}》, a textbook you authored — each of its chapters is one lesson and one station: one row per station (too much for one lesson → split the chapter in the contents first)`);
+					for (const range of ranges) if (range.to > (covered.toc?.length ?? 0)) {
+						const rows = covered.toc?.length ?? 0;
+						errors.push(`nodes[${index}] (${node.id}) covers up to row ${range.to}, but 《${covered.title}》's contents has ${rows} rows — library_read · toc lists them${rows < 3 ? `; a book with ${rows} row(s) was registered with its chapters joined — fix the contents first (library_textbook op update, resourceId ${covered.id}, toc one chapter per line), never drop the chapters` : ""}`);
+					}
+				}
+			} else if (kind === "topic") {
+				if ((coverTopic(cover) ?? "").trim() === "") errors.push(`nodes[${index}] (${node.id}) covers a topic with no text — what the coach teaches here`);
+			}
+		}
+		for (const dep of Array.isArray(node.dependsOn) ? node.dependsOn : []) {
+			const depIndex = nodes.findIndex((candidate) => candidate.id === dep);
+			if (depIndex === -1) {
+				errors.push(`nodes[${index}] (${node.id}) depends on ${JSON.stringify(dep)}, which the roadmap does not declare`);
+				continue;
+			}
+			if (gateKnown && node.gate !== "read" && nodes[depIndex]?.gate === "read") {
+				errors.push(`nodes[${index}] (${node.id}) depends on read node ${JSON.stringify(dep)} — a read node is a side stop and never gates a level; depend on the previous quiz or acceptance node instead. How-to-use pages, answer keys, transcripts and appendices are not nodes at all: put them in the resource's extras`);
+				continue;
+			}
+			if (depIndex >= index) errors.push(`nodes[${index}] (${node.id}) depends on ${JSON.stringify(dep)}, which comes AFTER it — list a node after everything it depends on`);
+		}
+	}
+	if (errors.length === 0) return void 0;
+	if (errors.length === 1) return errors[0];
+	return `${errors.length} shape errors — fix them all, then resend:\n${errors.map((error) => `- ${error}`).join("\n")}`;
+}
+/**
+* Why a node's covers forbid a memory-backed content question, or undefined
+* when they allow one: only knowledge books and plain coached teaching (topic)
+* may be quizzed from domain knowledge; a material book, a thin link or a
+* bare url demands a verbatim quote. When the station covers its own
+* textbook (`primaryId`), that cover alone decides — a side reference (a
+* video, an article) never turns a knowledge chapter into a quote-only one.
+* The evidence-gate's node-level half (a resource-scoped quiz without a node
+* keeps the resource rule).
+*/
+function coversVerbatimBlocker(covers, resource, primaryId) {
+	const main = primaryId === void 0 ? [] : covers.filter((cover) => coverKind(cover) === "resource" && cover.ref === primaryId);
+	for (const cover of main.length > 0 ? main : covers) {
+		const kind = coverKind(cover);
+		if (kind === "resource") {
+			const covered = resource(cover.ref);
+			if (covered === void 0) continue;
+			if (isThickResource(covered)) {
+				if (covered.meta?.bookKind === "material") return `《${covered.title}》 is a material book (its exact text is what is tested)`;
+			} else return `the station draws on 《${covered.title}》, a thin link (a linked text you cannot recall reliably)`;
+		} else if (kind === "url") return `the station covers ${cover.ref} (a web text you cannot recall reliably)`;
+	}
+}
+/**
+* What keeps a 讲义 from reading as a lesson, or undefined: change logs and
+* internal words never reach the learner; on a textbook you authored (the 讲义
+* ARE its text) every knowledge point gets its own section — a heading naming
+* the point, then enough to learn it from.
+*/
+function lessonProblems(text, node, authored) {
+	const problems = [];
+	if (/第\s*\d+\s*次更新|修正说明|更新说明|\bacceptance\b/i.test(text)) problems.push("the 讲义 are for the learner — drop change logs (第 N 次更新, 修正说明; the sidebar already counts revisions) and internal words (acceptance)");
+	const points = node.points ?? [];
+	if (authored && points.length > 0) {
+		const squash = (value) => value.replace(/[\s*_`]/g, "").toLowerCase();
+		const headings = [...text.matchAll(/^#{1,4}\s+(.+)$/gm)].map((match) => ({
+			title: squash(match[1] ?? ""),
+			at: match.index ?? 0,
+			end: (match.index ?? 0) + match[0].length
+		}));
+		const pointHeadings = points.map((point) => headings.find((heading) => heading.title.includes(squash(point.title))));
+		const starts = pointHeadings.flatMap((heading) => heading === void 0 ? [] : [heading.at]).sort((a, b) => a - b);
+		const missing = [];
+		const thin = [];
+		for (const [index, point] of points.entries()) {
+			const heading = pointHeadings[index];
+			if (heading === void 0) {
+				missing.push(point.title);
+				continue;
+			}
+			const next = starts.find((start) => start > heading.at) ?? text.length;
+			if (text.slice(heading.end, next).replace(/[\s#>*_`|-]/g, "").length < 120) thin.push(point.title);
+		}
+		if (missing.length > 0) problems.push(`the 讲义 are the lesson itself — the learner learns from them, not from a reading list: give each knowledge point its own section headed by its title (## ${points[0].title}) — missing: ${missing.join("、")}`);
+		if (thin.length > 0) problems.push(`too thin to learn from (each point: explain it plainly → an example or the steps → a common mistake → a 思考题; outside links belong in a final ## 参考): ${thin.join("、")}`);
+	}
+	return problems.length === 0 ? void 0 : problems.join("; ");
+}
+//#endregion
+//#region lib/types/service/shelf.js
+/**
+* Projects and the shelf: create / edit / delete projects, register, place (seq), move and remove resources.
+*
+* One layer of the library service (see `service/core.ts` for the layering):
+* the methods are the service's own, moved here verbatim by domain.
+*
+* @module @khorsheed/dsh-library/service/shelf
+*/
+var LibraryServiceShelf = class extends LibraryServiceCore {
+	/** One resource's progress row (a thick resource's roadmap; a thin link's bare row). */
+	resourceProgress(projectId, resource) {
+		const roadmap = isThickResource(resource) ? this.store.readRoadmap(projectId, resource.id) : void 0;
+		const current = roadmap?.nodes.find((node) => node.state === "current");
+		const draft = isThickResource(resource) ? this.store.readRoadmap(projectId, resource.id, "draft") : void 0;
+		return {
+			id: resource.id,
+			title: resource.title,
+			kind: resource.kind,
+			...resource.seq === void 0 ? {} : { seq: resource.seq },
+			...resource.origin === void 0 ? {} : { origin: resource.origin },
+			...roadmap === void 0 ? {} : { roadmap: {
+				done: roadmap.nodes.filter((node) => node.state === "done").length,
+				total: roadmap.nodes.length
+			} },
+			...current === void 0 ? {} : { current: {
+				id: current.id,
+				title: current.title
+			} },
+			hasDraft: draft !== void 0,
+			...draft === void 0 ? {} : { draftTotal: draft.nodes.length }
+		};
+	}
+	summarize(project) {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const cards = this.store.readCards(project.id).filter(live);
+		return {
+			...project,
+			resources: this.store.listResources(project.id).map((resource) => this.resourceProgress(project.id, resource)),
+			cardCount: cards.length,
+			dueCount: cards.filter((card) => card.status === "active" && card.mastery.dueAt <= now).length,
+			lastActiveAt: this.store.readEvents(project.id).at(-1)?.at ?? project.createdAt,
+			openMisses: (() => {
+				const assessments = this.store.listAssessments(project.id);
+				const attempts = this.store.readAttempts(project.id);
+				let count = 0;
+				for (const resource of this.store.listResources(project.id)) for (const node of this.store.readRoadmap(project.id, resource.id)?.nodes ?? []) if (node.gate === "quiz") count += stationMastery(node, assessments, attempts).open.length;
+				return count;
+			})()
+		};
+	}
+	/** Every project with its resources' progress and card tallies. */
+	async listProjects() {
+		this.assertAlive("listProjects");
+		const projects = this.store.readIndex().projects.map((project) => this.summarize(project));
+		projects.sort((a, b) => b.lastActiveAt.localeCompare(a.lastActiveAt));
+		return { projects };
+	}
+	/** One project's summary plus its resources' full records. */
+	async getProject(request) {
+		this.assertAlive("getProject");
+		const project = this.readProjectOrRefusal(request.id);
+		if ("error" in project) return project;
+		return {
+			ok: true,
+			project: this.summarize(project.value),
+			resources: this.store.listResources(project.value.id)
+		};
+	}
+	/** Create a project. */
+	async createProject(request) {
+		this.assertAlive("createProject");
+		const name = request.name.trim();
+		if (name === "") return refuse("invalid", "a project needs a name — what the learner calls the subject (「神经科学」「雅思」)");
+		if (request.template !== void 0 && ![
+			"language",
+			"subject",
+			"custom"
+		].includes(request.template)) return refuse("invalid", "template is language | subject | custom — language: marks are words; subject: marks are concepts");
+		try {
+			const outcome = await this.store.withIndexLock(async () => {
+				const index = this.store.readIndex();
+				if (index.projects.some((project) => project.name === name)) return refuse("exists", `a project named ${JSON.stringify(name)} already exists — open it (library_read · projects) instead of creating a twin`);
+				const template = request.template ?? "subject";
+				const project = {
+					id: mintLibraryId("p"),
+					name,
+					template,
+					color: request.color !== void 0 && LIBRARY_COLORS.includes(request.color) ? request.color : TEMPLATE_LOOK[template].color,
+					icon: request.icon !== void 0 && LIBRARY_ICONS.includes(request.icon) ? request.icon : TEMPLATE_LOOK[template].icon,
+					...request.templateNote === void 0 || request.templateNote.trim() === "" ? {} : { templateNote: request.templateNote.trim() },
+					...request.goal === void 0 || request.goal.trim() === "" ? {} : { goal: request.goal.trim() },
+					createdAt: (/* @__PURE__ */ new Date()).toISOString()
+				};
+				this.store.writeProject(project);
+				this.store.writeIndex({
+					...index,
+					projects: [...index.projects, project]
+				});
+				return {
+					ok: true,
+					project
+				};
+			});
+			if (outcome.ok) this.changed(outcome.project.id);
+			return outcome;
+		} catch (error) {
+			return storeRefusal(error);
+		}
+	}
+	/** Change a project's look or goal (the sidebar's 「样式」). */
+	async updateProject(request) {
+		this.assertAlive("updateProject");
+		const patch = request.patch;
+		if (patch.color !== void 0 && !LIBRARY_COLORS.includes(patch.color)) return refuse("invalid", `color is one of ${LIBRARY_COLORS.join(" | ")}`);
+		if (patch.icon !== void 0 && !LIBRARY_ICONS.includes(patch.icon)) return refuse("invalid", `icon is one of ${LIBRARY_ICONS.join(" | ")}`);
+		if (patch.name !== void 0 && patch.name.trim() === "") return refuse("invalid", "a project keeps a name");
+		if (patch.template !== void 0 && ![
+			"language",
+			"subject",
+			"custom"
+		].includes(patch.template)) return refuse("invalid", "template is language | subject | custom — language: marks are words; subject: marks are concepts");
+		try {
+			const outcome = await this.store.withIndexLock(async () => {
+				const index = this.store.readIndex();
+				const project = index.projects.find((candidate) => candidate.id === request.id);
+				if (project === void 0) return refuse("not-found", `no project ${JSON.stringify(request.id)} — ids are minted (p_…); library_read · projects lists the ones that exist, and omitting projectId creates a new project`);
+				const { goal: _goal, ...rest } = project;
+				const goal = patch.goal === void 0 ? project.goal : patch.goal.trim();
+				const next = {
+					...rest,
+					...goal === void 0 || goal === "" ? {} : { goal },
+					...patch.color === void 0 ? {} : { color: patch.color },
+					...patch.icon === void 0 ? {} : { icon: patch.icon },
+					...patch.template === void 0 ? {} : { template: patch.template },
+					...patch.name === void 0 ? {} : { name: patch.name.trim() }
+				};
+				this.store.writeProject(next);
+				this.store.writeIndex({
+					...index,
+					projects: index.projects.map((candidate) => candidate.id === next.id ? next : candidate)
+				});
+				return {
+					ok: true,
+					project: next
+				};
+			});
+			if (outcome.ok) this.changed(request.id);
+			return outcome;
+		} catch (error) {
+			return storeRefusal(error);
+		}
+	}
+	/** Delete a project and everything it holds. */
+	async deleteProject(request) {
+		this.assertAlive("deleteProject");
+		try {
+			const outcome = await this.store.withIndexLock(async () => {
+				const index = this.store.readIndex();
+				if (!index.projects.some((project) => project.id === request.id)) return refuse("not-found", `no project ${JSON.stringify(request.id)} — library_read · projects lists the ones that exist`);
+				this.store.removeProject(request.id);
+				this.store.writeIndex({
+					...index,
+					projects: index.projects.filter((project) => project.id !== request.id)
+				});
+				return {
+					ok: true,
+					id: request.id
+				};
+			});
+			if (outcome.ok) this.changed(request.id);
+			return outcome;
+		} catch (error) {
+			return storeRefusal(error);
+		}
+	}
+	/**
+	* Put one entry on the project's shelf — the v5 unified write. A THICK
+	* entry (kind "book", or any kind carrying `toc`) registers its contents:
+	* the coach's table of contents, verified on the web whenever it can be,
+	* and cover locators count its rows. A THIN link is title + url + the
+	* coach's one-line why. Pass `resourceId` to correct an existing entry.
+	*/
+	async putResource(request) {
+		this.assertAlive("putResource");
+		const project = this.readProjectOrRefusal(request.projectId);
+		if ("error" in project) return project;
+		if (request.from !== void 0) {
+			const source = this.store.readResource(request.from.projectId, request.from.resourceId);
+			if (source === void 0) return refuse("not-found", `no resource ${JSON.stringify(request.from.resourceId)} in project ${JSON.stringify(request.from.projectId)} — the clone source must exist; library_read · resources there lists them`);
+			return await this.mutate(project.value.id, () => {
+				const existing = request.resourceId === void 0 ? void 0 : this.store.readResource(project.value.id, request.resourceId);
+				if (request.resourceId !== void 0 && existing === void 0) return refuse("not-found", `no resource ${JSON.stringify(request.resourceId)} in this project — omit resourceId to clone a fresh one`);
+				const now = (/* @__PURE__ */ new Date()).toISOString();
+				const { seq: _sourceSeq, ...copied } = source;
+				const resource = {
+					...copied,
+					id: existing?.id ?? mintLibraryId("r"),
+					...existing?.seq === void 0 ? {} : { seq: existing.seq },
+					createdAt: existing?.createdAt ?? now
+				};
+				this.store.writeResource(project.value.id, resource);
+				if (isThickResource(resource)) this.placeTextbook(project.value.id, resource.id, existing?.seq ?? request.seq);
+				if (existing === void 0) this.event(project.value.id, "resource.added", {
+					id: resource.id,
+					title: resource.title,
+					resourceId: resource.id,
+					...resource.toc === void 0 ? {} : { count: resource.toc.length }
+				});
+				return {
+					ok: true,
+					resource
+				};
+			});
+		}
+		const title = request.title?.trim() ?? "";
+		if (title === "") return refuse("invalid", "a resource needs its title — what its own page / cover calls it");
+		if (request.origin !== void 0 && !LIBRARY_RESOURCE_ORIGINS.includes(request.origin)) return refuse("invalid", "origin is learner | picked | authored — learner: the learner's own; picked: an existing book / course / link you chose; authored: a textbook you wrote yourself (your contents, your 讲义 are its text)");
+		if (request.seq !== void 0 && !(Number.isInteger(request.seq) && request.seq > 0)) return refuse("invalid", "seq is the textbook's place in the study order — a whole number from 1");
+		if (!LIBRARY_RESOURCE_KINDS.includes(request.kind)) return refuse("invalid", `kind is ${LIBRARY_RESOURCE_KINDS.join(" | ")} — book: a book (contents required); course: a lecture series with episodes (contents required); article | video | repo | tool | hardware: a thin link (url required)`);
+		const wantsToc = request.toc !== void 0;
+		const toc = (request.toc ?? []).filter((entry) => entry.title.trim() !== "" && entry.title.trim() !== entry.part?.trim());
+		if (request.kind === "book" || wantsToc) {
+			if (toc.length === 0) return refuse("invalid", "a thick resource (a book, a course with episodes) needs its table of contents — search the web for the contents (publisher page, library catalog), or ask the learner to photograph the contents page; each row: { title, part? }");
+			if (request.tocSource === void 0 || ![
+				"web",
+				"model",
+				"photo"
+			].includes(request.tocSource.by)) return refuse("invalid", "tocSource.by is web | model | photo — say where the contents came from; web needs the url");
+			if (request.tocSource.by === "web" && (request.tocSource.url === void 0 || !/^https?:\/\//.test(request.tocSource.url))) return refuse("invalid", "a web-sourced table of contents carries the url it came from (tocSource.url) — the learner checks it on the draft card");
+			if (request.bookKind !== void 0 && request.bookKind !== "knowledge" && request.bookKind !== "material") return refuse("invalid", "bookKind is knowledge | material — knowledge: the content is domain knowledge (a textbook, popular science; the coach may quiz from what it knows); material: specific text the model cannot recall (exam papers, novels; quizzing needs a photo or a web quote)");
+		} else {
+			const url = request.url?.trim() ?? "";
+			if (!/^https?:\/\//.test(url)) return refuse("invalid", "a thin link's url starts with http:// or https:// — the learner opens it straight off the shelf");
+		}
+		return await this.mutate(project.value.id, () => {
+			const existing = request.resourceId === void 0 ? void 0 : this.store.readResource(project.value.id, request.resourceId);
+			if (request.resourceId !== void 0 && existing === void 0) return refuse("not-found", `no resource ${JSON.stringify(request.resourceId)} in this project — omit resourceId to add a new one; library_read · resources lists the existing ids`);
+			if (existing === void 0 && toc.length > 0 && this.store.listResources(project.value.id).some((resource) => resource.title === title && resource.meta?.edition === request.edition?.trim() && isThickResource(resource))) return refuse("exists", `《${title}》 is already on this project's shelf — pass its resourceId to correct it`);
+			if (existing === void 0 && toc.length === 0 && request.url !== void 0 && this.store.listResources(project.value.id).some((resource) => resource.url === request.url?.trim())) return refuse("exists", `${request.url.trim()} is already on this project's shelf — pass its resourceId to correct it`);
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const meta = (() => {
+				const merged = {
+					...(() => {
+						const bookKind = request.bookKind ?? existing?.meta?.bookKind ?? (toc.length > 0 ? "knowledge" : void 0);
+						return bookKind === void 0 ? {} : { bookKind };
+					})(),
+					...request.short === void 0 || request.short.trim() === "" ? existing?.meta?.short === void 0 ? {} : { short: existing.meta.short } : { short: request.short.trim().slice(0, 8) },
+					...request.extras === void 0 ? existing?.meta?.extras === void 0 ? {} : { extras: existing.meta.extras } : { extras: request.extras.filter((extra) => typeof extra.title === "string" && extra.title.trim() !== "").map((extra) => ({
+						title: extra.title.trim(),
+						...extra.note === void 0 || extra.note.trim() === "" ? {} : { note: extra.note.trim() },
+						...extra.where === void 0 || extra.where.trim() === "" ? {} : { where: extra.where.trim() },
+						when: extra.when === "reference" ? "reference" : "before"
+					})) },
+					...request.author === void 0 || request.author.trim() === "" ? existing?.meta?.author === void 0 ? {} : { author: existing.meta.author } : { author: request.author.trim() },
+					...request.edition === void 0 || request.edition.trim() === "" ? existing?.meta?.edition === void 0 ? {} : { edition: existing.meta.edition } : { edition: request.edition.trim() },
+					...request.isbn === void 0 || request.isbn.trim() === "" ? existing?.meta?.isbn === void 0 ? {} : { isbn: existing.meta.isbn } : { isbn: request.isbn.trim() }
+				};
+				return Object.keys(merged).length === 0 ? void 0 : merged;
+			})();
+			const resource = {
+				id: existing?.id ?? mintLibraryId("r"),
+				title,
+				kind: request.kind,
+				...request.url === void 0 || request.url.trim() === "" ? existing?.url === void 0 ? {} : { url: existing.url } : { url: request.url.trim() },
+				...request.note === void 0 || request.note.trim() === "" ? existing?.note === void 0 ? {} : { note: existing.note } : { note: request.note.trim() },
+				origin: request.origin ?? existing?.origin ?? "picked",
+				...existing?.seq === void 0 || toc.length === 0 ? {} : { seq: existing.seq },
+				...toc.length === 0 ? {} : { toc: toc.map((entry, index) => ({
+					n: index + 1,
+					title: entry.title.trim(),
+					...entry.part === void 0 || entry.part.trim() === "" ? {} : { part: entry.part.trim() }
+				})) },
+				...request.tocSource === void 0 ? existing?.tocSource === void 0 ? {} : { tocSource: existing.tocSource } : { tocSource: {
+					...request.tocSource,
+					verifiedAt: request.tocSource.verifiedAt ?? now
+				} },
+				...meta === void 0 ? {} : { meta },
+				createdAt: existing?.createdAt ?? now
+			};
+			this.store.writeResource(project.value.id, resource);
+			const placed = isThickResource(resource) ? this.placeTextbook(project.value.id, resource.id, request.seq ?? existing?.seq) : resource;
+			if (existing === void 0) this.event(project.value.id, "resource.added", {
+				id: resource.id,
+				title: resource.title,
+				resourceId: resource.id,
+				...resource.toc === void 0 ? {} : { count: resource.toc.length }
+			});
+			return {
+				ok: true,
+				resource: placed
+			};
+		});
+	}
+	/**
+	* Renumber a project's textbooks gapless from 1 with `resourceId` at
+	* `seq` (clamped; omitted = keep its place, or last when it has none).
+	* Call inside the project lock. Returns the placed resource as stored.
+	*/
+	placeTextbook(projectId, resourceId, seq) {
+		const textbooks = this.store.listResources(projectId).filter(isThickResource);
+		const moving = textbooks.find((candidate) => candidate.id === resourceId);
+		const others = textbooks.filter((candidate) => candidate.id !== resourceId);
+		if (moving !== void 0) {
+			const at = seq === void 0 ? moving.seq === void 0 ? others.length : Math.min(others.filter((other) => (other.seq ?? Infinity) < moving.seq).length, others.length) : Math.min(Math.max(seq - 1, 0), others.length);
+			others.splice(at, 0, moving);
+		}
+		let placed;
+		for (const [index, textbook] of others.entries()) {
+			const next = textbook.seq === index + 1 ? textbook : {
+				...textbook,
+				seq: index + 1
+			};
+			if (next !== textbook) this.store.writeResource(projectId, next);
+			if (next.id === resourceId) placed = next;
+		}
+		return placed ?? this.store.readResource(projectId, resourceId);
+	}
+	/** Switch a textbook between 知识型 (knowledge) and 材料型 (material) — the learner's call on the textbook page. */
+	async setBookKind(request) {
+		this.assertAlive("setBookKind");
+		const project = this.readProjectOrRefusal(request.projectId);
+		if ("error" in project) return project;
+		if (request.bookKind !== "knowledge" && request.bookKind !== "material") return refuse("invalid", "bookKind is knowledge | material");
+		return await this.mutate(project.value.id, () => {
+			const resource = this.store.readResource(project.value.id, request.resourceId);
+			if (resource === void 0 || !isThickResource(resource)) return refuse("not-found", `no textbook ${JSON.stringify(request.resourceId)} in this project`);
+			const next = {
+				...resource,
+				meta: {
+					...resource.meta,
+					bookKind: request.bookKind
+				}
+			};
+			this.store.writeResource(project.value.id, next);
+			return {
+				ok: true,
+				resource: next
+			};
+		});
+	}
+	/** Move a textbook to another place in the study order (the rest shift). */
+	async moveResource(request) {
+		this.assertAlive("moveResource");
+		const project = this.readProjectOrRefusal(request.projectId);
+		if ("error" in project) return project;
+		if (!(Number.isInteger(request.seq) && request.seq > 0)) return refuse("invalid", "seq is a place in the study order — a whole number from 1");
+		return await this.mutate(project.value.id, () => {
+			const resource = this.store.readResource(project.value.id, request.resourceId);
+			if (resource === void 0) return refuse("not-found", `no resource ${JSON.stringify(request.resourceId)} in this project — library_read · resources lists them`);
+			if (!isThickResource(resource)) return refuse("invalid", `《${resource.title}》 is a link without contents — only textbooks have a place in the study order`);
+			this.placeTextbook(project.value.id, resource.id, request.seq);
+			return {
+				ok: true,
+				resources: this.store.listResources(project.value.id)
+			};
+		});
+	}
+	/** Remove a shelf entry: its record, roadmaps and pages (cards stay, unhung); the textbooks behind it move up. */
+	async removeResource(request) {
+		this.assertAlive("removeResource");
+		const project = this.readProjectOrRefusal(request.projectId);
+		if ("error" in project) return project;
+		return await this.mutate(project.value.id, () => {
+			if (this.store.readResource(project.value.id, request.resourceId) === void 0) return refuse("not-found", `no resource ${JSON.stringify(request.resourceId)} in this project`);
+			this.store.removeResource(project.value.id, request.resourceId);
+			this.placeTextbook(project.value.id, request.resourceId, void 0);
+			const cards = this.store.readCards(project.value.id);
+			if (cards.some((card) => card.resourceId === request.resourceId)) this.store.writeCards(project.value.id, cards.map((card) => {
+				if (card.resourceId !== request.resourceId) return card;
+				const { resourceId: _dropped, ...rest } = card;
+				return rest;
+			}));
+			return {
+				ok: true,
+				id: request.resourceId
+			};
+		});
+	}
+	/** One shelf entry, whole. */
+	async getResource(request) {
+		this.assertAlive("getResource");
+		const resource = this.store.readResource(request.projectId, request.resourceId);
+		if (resource === void 0) return refuse("not-found", `no resource ${JSON.stringify(request.resourceId)} — library_read · resources lists the project's`);
+		return {
+			ok: true,
+			resource
+		};
+	}
+	/** A project's shelf: textbooks in study order, then links oldest first. */
+	async listResources(request) {
+		this.assertAlive("listResources");
+		return { resources: this.store.listResources(request.projectId) };
+	}
+	/** The project holding a resource, when an id is all the caller has (the tools' project fallback). */
+	findResourceOwner(resourceId) {
+		this.assertAlive("findResourceOwner");
+		for (const project of this.store.readIndex().projects) if (this.store.readResource(project.id, resourceId) !== void 0) return project.id;
+	}
+};
+//#endregion
+//#region lib/types/service/cards.js
+/**
+* Knowledge cards: the dedupe write path, listing, editing, undo, review scheduling.
+*
+* One layer of the library service (see `service/core.ts` for the layering):
+* the methods are the service's own, moved here verbatim by domain.
+*
+* @module @khorsheed/dsh-library/service/cards
+*/
+var LibraryServiceCards = class extends LibraryServiceShelf {
+	/**
+	* Apply card inputs to the project's cards (call inside the project lock).
+	* Exact keys merge; near matches are held back unless `mergeNear` (photo
+	* words — a plural or a case away is the same word) or the input decides.
+	*/
+	applyCardInputs(projectId, inputs, defaultResourceId, options = {}) {
+		const cards = this.store.readCards(projectId);
+		const byId = new Map(cards.map((card) => [card.id, card]));
+		const order = cards.map((card) => card.id);
+		const added = [];
+		const merged = [];
+		const pending = [];
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		for (const [index, input] of inputs.entries()) {
+			const keys = [input.term, ...input.aliases ?? []].map(cardKey).filter((key) => key !== "");
+			const pool = [...byId.values()];
+			let target;
+			if (input.mergeInto !== void 0) target = byId.get(input.mergeInto);
+			else if (input.asNew !== true) {
+				target = exactMatch(pool, keys);
+				if (target === void 0) {
+					const near = nearMatches(pool, keys);
+					if (near.length > 0) {
+						if (options.mergeNear === true) target = near[0];
+						else {
+							pending.push({
+								index,
+								term: input.term,
+								candidates: near.map((card) => ({
+									id: card.id,
+									term: card.term,
+									gloss: card.gloss
+								}))
+							});
+							continue;
+						}
+					}
+				}
+			}
+			const resourceId = input.resourceId ?? defaultResourceId;
+			const source = {
+				type: input.source.type,
+				...input.source.ref === void 0 ? {} : { ref: input.source.ref },
+				...input.source.note === void 0 || input.source.note.trim() === "" ? {} : { note: input.source.note.trim() },
+				...input.weaken === true ? { weakened: true } : {},
+				at: now
+			};
+			const context = input.context === void 0 || input.context.sentence.trim() === "" ? void 0 : {
+				sentence: input.context.sentence.trim(),
+				...resourceId === void 0 ? {} : { resourceId },
+				...input.context.pageId === void 0 ? {} : { pageId: input.context.pageId },
+				...input.context.nodeId === void 0 ? {} : { nodeId: input.context.nodeId }
+			};
+			if (target !== void 0) {
+				const aliases = new Set(target.aliases);
+				const ownKeys = new Set(cardKeys(target));
+				if (!ownKeys.has(cardKey(input.term))) aliases.add(input.term.trim());
+				for (const alias of input.aliases ?? []) if (!ownKeys.has(cardKey(alias))) aliases.add(alias.trim());
+				const placeholder = target.gloss === "（待补释义）";
+				const next = {
+					...target,
+					aliases: [...aliases],
+					gloss: placeholder ? input.gloss.trim() : target.gloss,
+					...target.userGloss === void 0 && input.userGloss !== void 0 ? { userGloss: input.userGloss.trim() } : {},
+					contexts: context === void 0 || target.contexts.some((existing) => existing.sentence === context.sentence) ? target.contexts : [...target.contexts, context],
+					...target.resourceId === void 0 && resourceId !== void 0 ? { resourceId } : {},
+					sources: [...target.sources, source],
+					weakness: clampWeakness(target.weakness + (input.weaken === true ? 1 : 0)),
+					status: target.status === "deleted" ? "active" : target.status,
+					updatedAt: now
+				};
+				byId.set(next.id, next);
+				merged.push(next);
+				continue;
+			}
+			const card = {
+				id: mintLibraryId("c"),
+				kind: input.kind,
+				term: input.term.trim(),
+				aliases: (input.aliases ?? []).map((alias) => alias.trim()).filter((alias) => alias !== "" && cardKey(alias) !== cardKey(input.term)),
+				gloss: input.gloss.trim(),
+				...input.userGloss === void 0 || input.userGloss.trim() === "" ? {} : { userGloss: input.userGloss.trim() },
+				contexts: context === void 0 ? [] : [context],
+				...resourceId === void 0 ? {} : { resourceId },
+				sources: [source],
+				weakness: input.weaken === true || input.source.type === "chat" ? 1 : 0,
+				mastery: {
+					box: 0,
+					dueAt: now,
+					streak: 0
+				},
+				status: "active",
+				createdAt: now,
+				updatedAt: now
+			};
+			byId.set(card.id, card);
+			order.push(card.id);
+			added.push(card);
+		}
+		if (added.length > 0 || merged.length > 0) {
+			this.store.writeCards(projectId, order.map((cardId) => byId.get(cardId)));
+			const touched = [...added, ...merged];
+			const sourceType = inputs[0]?.source.type;
+			this.event(projectId, "cards.recorded", {
+				at: now,
+				title: touched.map((card) => card.term).join("、").slice(0, 300),
+				ids: touched.map((card) => card.id),
+				...sourceType === void 0 ? {} : { source: sourceType },
+				...sourceType === "chat" && inputs[0]?.source.ref !== void 0 ? { session: inputs[0].source.ref } : {},
+				...defaultResourceId === void 0 ? {} : { resourceId: defaultResourceId },
+				count: added.length,
+				count2: merged.length
+			});
+		}
+		return {
+			added,
+			merged,
+			pending,
+			at: now
+		};
+	}
+	/**
+	* Record cards (the coach's 「记下」, a manual add). Near-duplicates come back
+	* in `pending` with their candidates — resend each with `mergeInto` or `asNew`.
+	*/
+	async writeCards(request) {
+		this.assertAlive("writeCards");
+		const project = this.readProjectOrRefusal(request.projectId);
+		if ("error" in project) return project;
+		if (request.cards.length === 0) return refuse("invalid", "cards needs at least one card — each: { kind: word|concept, term, gloss, context?, source: { type: chat|photo|quiz|manual, note? }, weaken? }");
+		const errors = [];
+		for (const [index, input] of request.cards.entries()) {
+			if (input.kind !== "word" && input.kind !== "concept") errors.push(`cards[${index}].kind is word | concept`);
+			if (input.term.trim() === "" || input.gloss.trim() === "") errors.push(`cards[${index}] needs term and gloss — the gloss is the in-context meaning (a word) or a one-line explanation (a concept)`);
+			if (![
+				"photo",
+				"chat",
+				"quiz",
+				"manual"
+			].includes(input.source?.type)) errors.push(`cards[${index}].source.type is chat | photo | quiz | manual — chat: the learner asked / got stuck in conversation`);
+		}
+		const cards = this.store.readCards(project.value.id);
+		for (const [index, input] of request.cards.entries()) if (input.mergeInto !== void 0 && !cards.some((card) => card.id === input.mergeInto && live(card))) errors.push(`cards[${index}].mergeInto names ${JSON.stringify(input.mergeInto)}, which is not a live card — use an id from the pending candidates`);
+		if (errors.length === 1) return refuse("invalid", errors[0]);
+		if (errors.length > 1) return refuse("invalid", `${errors.length} problems in cards — fix them all, then resend:\n${errors.map((error) => `- ${error}`).join("\n")}`);
+		if (request.resourceId !== void 0 && this.store.readResource(project.value.id, request.resourceId) === void 0) return refuse("not-found", `no resource ${JSON.stringify(request.resourceId)} in this project — omit resource for a project-level card`);
+		return await this.mutate(project.value.id, () => {
+			const { at: _at, ...result } = this.applyCardInputs(project.value.id, request.cards, request.resourceId);
+			return {
+				ok: true,
+				...result
+			};
+		});
+	}
+	/** Cards, filtered and sorted (the sidebar list, the coach's search). */
+	async listCards(request) {
+		this.assertAlive("listCards");
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		let cards = this.store.readCards(request.projectId).filter(live);
+		if (request.includeMastered !== true) cards = cards.filter((card) => card.status === "active");
+		if (request.resourceId !== void 0) cards = cards.filter((card) => card.resourceId === request.resourceId);
+		if (request.nodeId !== void 0) cards = cards.filter((card) => card.contexts.some((context) => context.nodeId === request.nodeId));
+		if (request.kind !== void 0) cards = cards.filter((card) => card.kind === request.kind);
+		if (request.source !== void 0) cards = cards.filter((card) => card.sources.some((source) => source.type === request.source));
+		if (request.weakMin !== void 0) cards = cards.filter((card) => card.weakness >= request.weakMin);
+		if (request.due === true) cards = cards.filter((card) => card.mastery.dueAt <= now);
+		if (request.query !== void 0 && request.query.trim() !== "") cards = cards.filter((card) => cardMatchesQuery(card, request.query));
+		const sort = request.sort ?? "weak";
+		cards.sort((a, b) => sort === "recent" ? b.updatedAt.localeCompare(a.updatedAt) : sort === "due" ? a.mastery.dueAt.localeCompare(b.mastery.dueAt) : b.weakness - a.weakness || a.mastery.dueAt.localeCompare(b.mastery.dueAt));
+		return {
+			cards: cards.slice(0, request.limit ?? 200),
+			total: cards.length
+		};
+	}
+	/** The cards due for review across projects (or one), weakest first. */
+	async dueCards(request) {
+		this.assertAlive("dueCards");
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const projectIds = request.projectId !== void 0 ? [request.projectId] : this.store.readIndex().projects.map((project) => project.id);
+		const due = [];
+		for (const projectId of projectIds) for (const card of this.store.readCards(projectId)) if (card.status === "active" && card.mastery.dueAt <= now) due.push({
+			...card,
+			projectId
+		});
+		due.sort((a, b) => a.mastery.box - b.mastery.box || b.weakness - a.weakness || a.mastery.dueAt.localeCompare(b.mastery.dueAt));
+		return { cards: due.slice(0, request.limit ?? 200) };
+	}
+	/** Edit a card by hand: its words, or its status (mastered / deleted / active). */
+	async editCard(request) {
+		this.assertAlive("editCard");
+		const project = this.readProjectOrRefusal(request.projectId);
+		if ("error" in project) return project;
+		return await this.mutate(project.value.id, () => {
+			const cards = this.store.readCards(project.value.id);
+			const card = cards.find((candidate) => candidate.id === request.cardId);
+			if (card === void 0) return refuse("not-found", `no card ${JSON.stringify(request.cardId)}`);
+			const patch = request.patch;
+			if (patch.term !== void 0 && patch.term.trim() === "") return refuse("invalid", "a card keeps a term");
+			if (patch.gloss !== void 0 && patch.gloss.trim() === "") return refuse("invalid", "a card keeps a gloss");
+			const { resourceId: _old, ...rest } = card;
+			const next = {
+				...patch.resourceId === null ? rest : card,
+				...patch.term === void 0 ? {} : { term: patch.term.trim() },
+				...patch.gloss === void 0 ? {} : { gloss: patch.gloss.trim() },
+				...patch.userGloss === void 0 ? {} : { userGloss: patch.userGloss.trim() },
+				...patch.aliases === void 0 ? {} : { aliases: patch.aliases.map((alias) => alias.trim()).filter((alias) => alias !== "") },
+				...patch.status === void 0 ? {} : { status: patch.status },
+				...typeof patch.resourceId === "string" ? { resourceId: patch.resourceId } : {},
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			this.store.writeCards(project.value.id, cards.map((candidate) => candidate.id === card.id ? next : candidate));
+			this.event(project.value.id, "card.edited", {
+				id: card.id,
+				title: next.term
+			});
+			return {
+				ok: true,
+				card: next
+			};
+		});
+	}
+	/**
+	* Undo one recording (the toast's 撤销): cards it created are deleted; cards
+	* it merged into lose the source it stacked (and the weakness it added).
+	*/
+	async undoCards(request) {
+		this.assertAlive("undoCards");
+		const project = this.readProjectOrRefusal(request.projectId);
+		if ("error" in project) return project;
+		return await this.mutate(project.value.id, () => {
+			const wanted = new Set(request.ids);
+			let removed = 0;
+			let reverted = 0;
+			const cards = this.store.readCards(project.value.id).map((card) => {
+				if (!wanted.has(card.id)) return card;
+				if (card.createdAt === request.at) {
+					removed += 1;
+					return {
+						...card,
+						status: "deleted",
+						updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+					};
+				}
+				const dropped = card.sources.filter((source) => source.at === request.at);
+				if (dropped.length === 0) return card;
+				reverted += 1;
+				return {
+					...card,
+					sources: card.sources.filter((source) => source.at !== request.at),
+					weakness: clampWeakness(card.weakness - dropped.filter((source) => source.weakened === true).length),
+					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				};
+			});
+			this.store.writeCards(project.value.id, cards);
+			return {
+				ok: true,
+				removed,
+				reverted
+			};
+		});
+	}
+	/**
+	* One flashcard review (the daily 复习): only the schedule moves — forgot
+	* resets to box 0 (tomorrow), fuzzy keeps the box, recalled climbs one.
+	* Reviews never unlock nodes and never touch weakness.
+	*/
+	async reviewCard(request) {
+		this.assertAlive("reviewCard");
+		if (![
+			"forgot",
+			"fuzzy",
+			"recalled"
+		].includes(request.rating)) return refuse("invalid", "rating is forgot | fuzzy | recalled");
+		const project = this.readProjectOrRefusal(request.projectId);
+		if ("error" in project) return project;
+		return await this.mutate(project.value.id, () => {
+			const cards = this.store.readCards(project.value.id);
+			const card = cards.find((candidate) => candidate.id === request.cardId && live(candidate));
+			if (card === void 0) return refuse("not-found", `no card ${JSON.stringify(request.cardId)}`);
+			const now = /* @__PURE__ */ new Date();
+			const box = request.rating === "forgot" ? 0 : request.rating === "fuzzy" ? card.mastery.box : Math.min(card.mastery.box + 1, 5);
+			const next = {
+				...card,
+				mastery: {
+					box,
+					dueAt: leitnerDueAt(box, now),
+					streak: request.rating === "recalled" ? card.mastery.streak + 1 : 0
+				},
+				updatedAt: now.toISOString()
+			};
+			this.store.writeCards(project.value.id, cards.map((candidate) => candidate.id === card.id ? next : candidate));
+			return {
+				ok: true,
+				card: next
+			};
+		});
+	}
+};
+//#endregion
+//#region lib/types/service/roadmap.js
+/**
+* Paths: drafts, adoption (with practice rubrics materialized), discard, station notes, 读完.
+*
+* One layer of the library service (see `service/core.ts` for the layering):
+* the methods are the service's own, moved here verbatim by domain.
+*
+* @module @khorsheed/dsh-library/service/roadmap
+*/
+var LibraryServiceRoadmap = class extends LibraryServiceCards {
+	/** One textbook's adopted roadmap and its pending draft. */
+	async getRoadmap(request) {
+		this.assertAlive("getRoadmap");
+		const roadmap = this.store.readRoadmap(request.projectId, request.resourceId);
+		const draft = this.store.readRoadmap(request.projectId, request.resourceId, "draft");
+		return {
+			...roadmap === void 0 ? {} : { roadmap },
+			...draft === void 0 ? {} : { draft }
+		};
+	}
+	/**
+	* Write the coach's draft of one textbook's path; it replaces the
+	* textbook's previous draft. Shape rules: unique ids, a gate, at least one
+	* cover per node, references that exist, locators inside the resource's
+	* contents, dependencies pointing backwards. States are not the coach's to
+	* set — adoption initializes them.
+	*/
+	async draftRoadmap(request) {
+		this.assertAlive("draftRoadmap");
+		const project = this.readProjectOrRefusal(request.projectId);
+		if ("error" in project) return project;
+		const textbooks = this.store.listResources(project.value.id).filter(isThickResource);
+		const shelf = textbooks.length === 0 ? "this project has no textbook yet — register one first (library_textbook with a contents: the learner's book, one you pick, or one you author)" : `this project's textbooks: ${textbooks.map((textbook) => `${textbook.seq ?? "-"}. ${textbook.id} 《${textbook.title}》`).join("; ")}`;
+		if (typeof request.resourceId !== "string" || request.resourceId.trim() === "") return refuse("invalid", `a path belongs to one textbook — pass resource; ${shelf}`);
+		const primary = isLibraryId(request.resourceId) ? this.store.readResource(project.value.id, request.resourceId) : void 0;
+		if (primary === void 0) return refuse("not-found", `no resource ${JSON.stringify(request.resourceId)} in project ${JSON.stringify(project.value.name)} — ${shelf}`);
+		if (!isThickResource(primary)) return refuse("invalid", `《${primary.title}》 is a link without contents — it never carries a path; cite it inside a station of a textbook's path (also: ["${primary.id}"]). ${shelf}`);
+		if (request.nodes.length === 0) return refuse("invalid", "a roadmap needs at least one node — split the material into learning stations; each: { id, title, gate: \"quiz\"|\"acceptance\"|\"read\", goals, covers: [\"r_…#1-5\" | \"https://…\" | \"topic: …\"], dependsOn }; an acceptance station also needs acceptance: [...]");
+		if (request.passRatio !== void 0 && !(request.passRatio > 0 && request.passRatio <= 1)) return refuse("invalid", "passRatio is a fraction in (0, 1] — 0.8 means 8 of 10 right");
+		for (const node of request.nodes) {
+			if (node.points === void 0 || node.points.length === 0) continue;
+			if (node.gate !== "quiz") return refuse("invalid", `${node.title} is a ${node.gate} node — points (考点) belong to quiz-gated stations only`);
+			const seen = /* @__PURE__ */ new Set();
+			for (const point of node.points) {
+				if (!isLibraryId(point.id)) return refuse("invalid", `point id ${JSON.stringify(point.id)} on ${node.title} is not a safe slug (letters, digits, . _ -) — it is the mastery key, stable across quizzes`);
+				if (typeof point.title !== "string" || point.title.trim() === "") return refuse("invalid", `point ${point.id} on ${node.title} needs a title — the point as the learner reads it (「极限的定义」)`);
+				if (seen.has(point.id)) return refuse("invalid", `duplicate point id ${point.id} on ${node.title} — reference the existing one`);
+				seen.add(point.id);
+			}
+		}
+		const nodes = request.nodes.map((node) => ({
+			id: node.id,
+			title: node.title,
+			gate: node.gate,
+			goals: typeof node.goals === "string" ? [node.goals] : (node.goals ?? []).filter((goal) => typeof goal === "string"),
+			covers: node.covers ?? [],
+			dependsOn: node.dependsOn ?? [],
+			state: "locked",
+			...node.points === void 0 || node.points.length === 0 ? {} : { points: node.points.map((point) => ({
+				id: point.id,
+				title: point.title.trim()
+			})) },
+			...Array.isArray(node.acceptance) ? { acceptance: node.acceptance.flatMap((entry) => {
+				if (typeof entry === "string") return entry.trim() === "" ? [] : [entry];
+				if (typeof entry?.line !== "string" || entry.line.trim() === "") return [];
+				return [{
+					line: entry.line.trim(),
+					...typeof entry.ref === "string" && entry.ref.trim() !== "" ? { ref: entry.ref.trim() } : {}
+				}];
+			}) } : {}
+		}));
+		const shapeError = validateRoadmapShape(nodes, {
+			resourceId: primary.id,
+			resource: (candidate) => this.store.readResource(project.value.id, candidate),
+			hasAssessment: (candidate) => this.store.readAssessment(project.value.id, candidate) !== void 0
+		});
+		if (shapeError !== void 0) return refuse("invalid", shapeError);
+		return await this.mutate(project.value.id, () => {
+			const draft = {
+				primaryResourceId: primary.id,
+				status: "draft",
+				nodes,
+				...request.passRatio === void 0 ? {} : { passRatio: request.passRatio },
+				...request.note === void 0 || request.note.trim() === "" ? {} : { note: request.note.trim() },
+				generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			this.store.writeRoadmap(project.value.id, draft);
+			this.event(project.value.id, "roadmap.drafted", {
+				id: primary.id,
+				title: primary.title,
+				resourceId: primary.id,
+				count: nodes.length
+			});
+			return {
+				ok: true,
+				draft
+			};
+		});
+	}
+	/**
+	* The learner's 采用: the draft becomes the path. Nodes whose deps are
+	* all done start `current`; a node that survives a re-split (same id) keeps
+	* its state, its quiz stats and its 讲义, so re-planning never erases
+	* progress. Every acceptance station's rubric materializes as its practice
+	* assessment (unchanged lines reuse the live one — its history stays put;
+	* changed lines supersede it).
+	*/
+	async adoptRoadmap(request) {
+		this.assertAlive("adoptRoadmap");
+		const project = this.readProjectOrRefusal(request.projectId);
+		if ("error" in project) return project;
+		return await this.mutate(project.value.id, () => {
+			const draft = this.store.readRoadmap(project.value.id, request.resourceId, "draft");
+			if (draft === void 0) return refuse("not-found", "no draft to adopt here — ask the coach to draft a roadmap first");
+			const prior = new Map((this.store.readRoadmap(project.value.id, request.resourceId)?.nodes ?? []).map((node) => [node.id, node]));
+			const nodes = [];
+			for (const node of draft.nodes) {
+				const kept = prior.get(node.id);
+				const state = kept?.state === "done" ? "done" : "current";
+				nodes.push({
+					...node,
+					state,
+					...node.gate === "quiz" ? { quizStats: kept?.quizStats ?? { attempts: 0 } } : {},
+					...kept?.notes !== void 0 ? { notes: kept.notes } : {}
+				});
+			}
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const roadmap = {
+				...draft,
+				primaryResourceId: request.resourceId,
+				status: "adopted",
+				nodes,
+				adoptedAt: now
+			};
+			this.store.writeRoadmap(project.value.id, roadmap);
+			this.store.removeDraft(project.value.id, request.resourceId);
+			this.materializePracticeAssessments(project.value.id, nodes, now);
+			const primary = this.store.readResource(project.value.id, request.resourceId);
+			this.event(project.value.id, "roadmap.adopted", {
+				at: now,
+				id: request.resourceId,
+				title: primary?.title ?? request.resourceId,
+				resourceId: request.resourceId,
+				count: nodes.length
+			});
+			return {
+				ok: true,
+				roadmap
+			};
+		});
+	}
+	/**
+	* Give every acceptance node a practice assessment keyed to it: an
+	* unchanged rubric reuses the node's live assessment (its attempts stay
+	* attached); a changed rubric supersedes it (the old snapshot keeps the old
+	* history). Call inside the project lock.
+	*/
+	materializePracticeAssessments(projectId, nodes, at) {
+		const assessments = this.store.listAssessments(projectId);
+		for (const node of nodes) {
+			if (node.gate !== "acceptance") continue;
+			const rubric = acceptanceLines(node);
+			if (rubric.length === 0) continue;
+			const liveAssessment = assessments.find((assessment) => assessment.type === "practice" && assessment.scope.nodeId === node.id && assessment.supersededBy === void 0);
+			if (liveAssessment !== void 0 && (liveAssessment.rubric ?? []).length === rubric.length && rubric.every((line, index) => liveAssessment.rubric?.[index]?.line === line.line && liveAssessment.rubric?.[index]?.ref === line.ref)) continue;
+			const assessment = {
+				id: mintLibraryId("q"),
+				type: "practice",
+				scope: { nodeId: node.id },
+				rubric,
+				createdAt: at
+			};
+			this.store.writeAssessment(projectId, assessment);
+			if (liveAssessment !== void 0) this.store.writeAssessment(projectId, {
+				...liveAssessment,
+				supersededBy: assessment.id
+			});
+		}
+	}
+	/** Drop a textbook's draft without adopting it. */
+	async discardDraft(request) {
+		this.assertAlive("discardDraft");
+		const project = this.readProjectOrRefusal(request.projectId);
+		if ("error" in project) return project;
+		return await this.mutate(project.value.id, () => {
+			this.store.removeDraft(project.value.id, request.resourceId);
+			return {
+				ok: true,
+				resourceId: request.resourceId
+			};
+		});
+	}
+	/**
+	* Write (or rewrite) a station's 讲义 — the coach's distilled teaching,
+	* persisted on the adopted path's node. Replanning keeps it when the
+	* station's id survives; every write bumps `revisions`.
+	*/
+	/** Why a 讲义 has nowhere to land, naming the fix: the path is only a draft, the station sits on another textbook, or here are this path's stations. */
+	notesMiss(projectId, resourceId, nodeId) {
+		const book = resourceId === void 0 ? void 0 : this.store.readResource(projectId, resourceId);
+		const named = book === void 0 ? "this textbook" : `《${book.title}》 (${book.id})`;
+		const roadmap = this.store.readRoadmap(projectId, resourceId);
+		if (roadmap === void 0) return refuse("not-found", this.store.readRoadmap(projectId, resourceId, "draft") === void 0 ? `${named} has no path yet — draft one (library_roadmap); 讲义 land on an adopted path's stations` : `${named}'s path is still a draft — the learner adopts it in the sidebar (路线 → 采用) before 讲义 can land; teach in the conversation meanwhile, then write the 讲义`);
+		const elsewhere = this.store.listResources(projectId).filter((resource) => resource.id !== roadmap.primaryResourceId).find((resource) => this.store.readRoadmap(projectId, resource.id)?.nodes.some((candidate) => candidate.id === nodeId) === true);
+		if (elsewhere !== void 0) return refuse("not-found", `station ${JSON.stringify(nodeId)} is on 《${elsewhere.title}》's path — pass resource ${elsewhere.id}`);
+		return refuse("not-found", `no station ${JSON.stringify(nodeId)} on ${named}'s path — its stations: ${roadmap.nodes.map((candidate) => candidate.id).join(", ")}`);
+	}
+	async putNotes(request) {
+		this.assertAlive("putNotes");
+		const project = this.readProjectOrRefusal(request.projectId);
+		if ("error" in project) return project;
+		const text = request.text.trim();
+		if (text === "") return refuse("invalid", "notes need text — the distilled teaching for this station (markdown): the explanation, the points the learner got stuck on, the pitfalls");
+		return await this.mutate(project.value.id, () => {
+			const roadmap = this.store.readRoadmap(project.value.id, request.resourceId);
+			const node = roadmap?.nodes.find((candidate) => candidate.id === request.nodeId);
+			if (roadmap === void 0 || node === void 0) return this.notesMiss(project.value.id, request.resourceId, request.nodeId);
+			const book = roadmap.primaryResourceId === void 0 ? void 0 : this.store.readResource(project.value.id, roadmap.primaryResourceId);
+			const lesson = lessonProblems(text, node, book !== void 0);
+			if (lesson !== void 0) return refuse("invalid", lesson);
+			if (node.notes !== void 0 && node.notes.text !== "" && roadmap.primaryResourceId !== void 0) this.store.archiveNotes(project.value.id, roadmap.primaryResourceId, node.id, node.notes.revisions, node.notes.text);
+			const notes = {
+				text,
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				revisions: (node.notes?.revisions ?? 0) + 1
+			};
+			const next = {
+				...roadmap,
+				nodes: roadmap.nodes.map((candidate) => candidate.id === node.id ? {
+					...candidate,
+					notes
+				} : candidate)
+			};
+			this.store.writeRoadmap(project.value.id, next);
+			this.event(project.value.id, "node.noted", {
+				id: node.id,
+				title: node.title,
+				...request.resourceId === void 0 ? {} : { resourceId: request.resourceId },
+				count: notes.revisions
+			});
+			return {
+				ok: true,
+				notes
+			};
+		});
+	}
+	/** 「读完」: a current read node completes and unlocks what it gates. */
+	async markNodeRead(request) {
+		this.assertAlive("markNodeRead");
+		const project = this.readProjectOrRefusal(request.projectId);
+		if ("error" in project) return project;
+		return await this.mutate(project.value.id, () => {
+			const roadmap = this.store.readRoadmap(project.value.id, request.resourceId);
+			const node = roadmap?.nodes.find((candidate) => candidate.id === request.nodeId);
+			if (roadmap === void 0 || node === void 0) return refuse("not-found", `no node ${JSON.stringify(request.nodeId)} on the adopted path`);
+			if (node.gate !== "read") return refuse("state-machine", `${node.title} is a ${node.gate} node — only a read node completes by 读完 (a quiz node by passing its quiz, an acceptance station by acceptance)`);
+			if (node.state !== "current") return refuse("state-machine", `${node.title} is ${node.state} — only a current node can be marked read`);
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const { nodes, unlocked } = unlockReady(roadmap.nodes.map((candidate) => candidate.id === node.id ? {
+				...candidate,
+				state: "done"
+			} : candidate));
+			const next = {
+				...roadmap,
+				nodes
+			};
+			this.store.writeRoadmap(project.value.id, next);
+			this.store.appendEvents(project.value.id, [{
+				at: now,
+				type: "node.completed",
+				id: node.id,
+				title: node.title,
+				...request.resourceId === void 0 ? {} : { resourceId: request.resourceId }
+			}, ...unlocked.map((nodeId) => ({
+				at: now,
+				type: "node.unlocked",
+				id: nodeId,
+				title: titleOf(nodes, nodeId),
+				...request.resourceId === void 0 ? {} : { resourceId: request.resourceId }
+			}))]);
+			return {
+				ok: true,
+				roadmap: next,
+				unlocked
+			};
+		});
+	}
+};
+//#endregion
+//#region lib/types/service/pages.js
+/**
+* Photographed pages: recording (marks carded), listing, photo reads and saves.
+*
+* One layer of the library service (see `service/core.ts` for the layering):
+* the methods are the service's own, moved here verbatim by domain.
+*
+* @module @khorsheed/dsh-library/service/pages
+*/
+var LibraryServicePages = class extends LibraryServiceRoadmap {
+	/**
+	* Record one photographed page and card every mark at once (「一键全收」).
+	* Uncertain marks are kept on the page but never carded — the learner
+	* decides them. Each card's gloss is the mark's recognized gloss, else the
+	* learner's handwriting, else a placeholder the learner can fill in.
+	*/
+	async recordPage(request) {
+		this.assertAlive("recordPage");
+		const project = this.readProjectOrRefusal(request.projectId);
+		if ("error" in project) return project;
+		const resource = this.store.readResource(project.value.id, request.resourceId);
+		if (resource === void 0) return refuse("not-found", `no resource ${JSON.stringify(request.resourceId)} in this project — a page belongs to a resource`);
+		if (!isThickResource(resource)) return refuse("invalid", `《${resource.title}》 is a thin link — only a thick resource (one with a contents) has pages to photograph`);
+		const ref = request.attachment;
+		if (typeof ref?.attachmentId !== "string" || typeof ref.mediaType !== "string" || typeof ref.bytes !== "number" || typeof ref.width !== "number" || typeof ref.height !== "number") return refuse("ref-incomplete", "attachment needs the image block's whole durable reference — { attachmentId, mediaType, bytes, width, height }, copied verbatim; the photo itself is never copied");
+		if (request.text.trim() === "") return refuse("invalid", "text is the page's printed text as recognized — a photo-backed question quotes it, so transcribe the page, not only the marks");
+		const marks = request.marks.filter((mark) => mark.text.trim() !== "");
+		const pageId = mintLibraryId("pg");
+		const nodeId = request.nodeId;
+		if (nodeId !== void 0) {
+			const roadmap = this.store.readRoadmap(project.value.id, resource.id);
+			if (roadmap !== void 0 && !roadmap.nodes.some((node) => node.id === nodeId)) return refuse("not-found", `no node ${JSON.stringify(nodeId)} on this resource's path — omit nodeId or read the roadmap`);
+		}
+		const kind = profileOf(project.value.template).markKind;
+		const inputs = marks.filter((mark) => mark.uncertain !== true).map((mark) => ({
+			kind,
+			term: mark.text,
+			gloss: mark.gloss ?? mark.handNote ?? "（待补释义）",
+			...mark.handNote === void 0 ? {} : { userGloss: mark.handNote },
+			...mark.sentence === void 0 ? {} : { context: {
+				sentence: mark.sentence,
+				pageId,
+				...nodeId === void 0 ? {} : { nodeId }
+			} },
+			source: {
+				type: "photo",
+				ref: pageId,
+				...request.label === void 0 ? {} : { note: request.label }
+			},
+			resourceId: resource.id
+		}));
+		return await this.mutate(project.value.id, () => {
+			const cards = this.applyCardInputs(project.value.id, inputs, resource.id, { mergeNear: kind === "word" });
+			const page = {
+				id: pageId,
+				resourceId: resource.id,
+				...nodeId === void 0 ? {} : { nodeId },
+				...request.label === void 0 || request.label.trim() === "" ? {} : { label: request.label.trim() },
+				attachment: {
+					attachmentId: ref.attachmentId,
+					mediaType: ref.mediaType,
+					bytes: ref.bytes,
+					width: ref.width,
+					height: ref.height
+				},
+				text: request.text,
+				marks,
+				cardIds: [...cards.added, ...cards.merged].map((card) => card.id),
+				at: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			this.store.appendPage(project.value.id, page);
+			this.event(project.value.id, "page.recorded", {
+				id: page.id,
+				title: page.label ?? resource.title,
+				resourceId: resource.id,
+				count: cards.added.length,
+				count2: cards.merged.length
+			});
+			return {
+				ok: true,
+				page,
+				cards,
+				uncertain: marks.filter((mark) => mark.uncertain === true).map((mark) => mark.text)
+			};
+		});
+	}
+	/** One resource's pages, optionally one node's. */
+	async listPages(request) {
+		this.assertAlive("listPages");
+		const pages = this.store.readPages(request.projectId, request.resourceId);
+		return { pages: request.nodeId === void 0 ? pages : pages.filter((page) => page.nodeId === request.nodeId) };
+	}
+	/** Find one page anywhere in the project. */
+	findPage(projectId, pageId) {
+		for (const resource of this.store.listResources(projectId)) {
+			const page = this.store.readPages(projectId, resource.id).find((candidate) => candidate.id === pageId);
+			if (page !== void 0) return page;
+		}
+	}
+	/**
+	* One page's photo, as base64 — whitelisted: the page must be one this
+	* project recorded, so the Remote never reads an arbitrary attachment.
+	*/
+	async readPagePhoto(request) {
+		this.assertAlive("readPagePhoto");
+		const page = this.findPage(request.projectId, request.pageId);
+		if (page === void 0) return refuse("not-found", `no page ${JSON.stringify(request.pageId)} in this project`);
+		const attachments = this.ctx.get("attachments");
+		if (attachments === void 0) return refuse("unavailable", "this deployment mounts no attachment store — the photo cannot be read back here");
+		try {
+			const stored = await attachments.readImage(page.attachment);
+			return {
+				ok: true,
+				data: Buffer.from(stored.data).toString("base64"),
+				mediaType: stored.ref.mediaType
+			};
+		} catch (error) {
+			return refuse("io", `the photo could not be read — ${libraryErrorMessage(error)}`);
+		}
+	}
+	/** Save a browser-uploaded photo into the host attachment store (the sidebar's 拍照). */
+	async savePhoto(request) {
+		this.assertAlive("savePhoto");
+		const attachments = this.ctx.get("attachments");
+		if (attachments?.saveImage === void 0) return refuse("unavailable", "this deployment mounts no attachment store — photos cannot be saved here");
+		try {
+			return {
+				ok: true,
+				attachment: await attachments.saveImage({
+					data: Buffer.from(request.data, "base64"),
+					mediaType: request.mediaType
+				})
+			};
+		} catch (error) {
+			return refuse("invalid", `the photo was refused — ${libraryErrorMessage(error)}`);
+		}
+	}
+};
+//#endregion
+//#region lib/types/service/assess.js
+/**
+* Assessments and attempts: quizzes (the two-axis checks), the assess cascade, acceptance sittings.
+*
+* One layer of the library service (see `service/core.ts` for the layering):
+* the methods are the service's own, moved here verbatim by domain.
+*
+* @module @khorsheed/dsh-library/service/assess
+*/
+var LibraryServiceAssess = class extends LibraryServicePages {
+	/** A project's assessments, optionally one resource's / node's / one type's. */
+	async listAssessments(request) {
+		this.assertAlive("listAssessments");
+		return { assessments: this.store.listAssessments(request.projectId).filter((assessment) => (request.resourceId === void 0 || assessment.scope.resourceId === request.resourceId) && (request.nodeId === void 0 || assessment.scope.nodeId === request.nodeId) && (request.type === void 0 || assessment.type === request.type)) };
+	}
+	/** One assessment, whole. */
+	async getAssessment(request) {
+		this.assertAlive("getAssessment");
+		const assessment = this.store.readAssessment(request.projectId, request.assessmentId);
+		if (assessment === void 0) return refuse("not-found", `no assessment ${JSON.stringify(request.assessmentId)} — library_read · quiz without an id lists the project's`);
+		return {
+			ok: true,
+			assessment
+		};
+	}
+	/**
+	* Store a quiz behind the two-axis checks. Target: a marked / asked / missed
+	* question names the live cards it probes. Evidence: a photo quote names a
+	* recorded page (a quote the page text lacks comes back as a warning); a web
+	* quote carries its url; whether domain knowledge may back a CONTENT question
+	* is judged on the gated node's covers (a material book, a thin link or a
+	* bare url among them demands a verbatim quote) — a resource-scoped quiz
+	* without a node keeps the resource-level rule, and a scopeless free quiz
+	* allows knowledge. A node-scoped quiz supersedes the station's live one.
+	*/
+	async putQuiz(request) {
+		this.assertAlive("putQuiz");
+		const project = this.readProjectOrRefusal(request.projectId);
+		if ("error" in project) return project;
+		const scope = request.quiz.scope;
+		const resource = scope.resourceId === void 0 ? void 0 : this.store.readResource(project.value.id, scope.resourceId);
+		if (scope.resourceId !== void 0 && resource === void 0) return refuse("not-found", `quiz scope names resource ${JSON.stringify(scope.resourceId)}, which project ${JSON.stringify(project.value.name)} does not hold — library_read · resources lists them`);
+		if (request.quiz.focus !== void 0 && ![
+			"mine",
+			"book",
+			"mixed"
+		].includes(request.quiz.focus)) return refuse("invalid", "quiz.focus is mine | book | mixed — mine: only the learner's own cards; book: only the chapter's content");
+		if (request.quiz.questions.length === 0) return refuse("invalid", "a quiz needs at least one question — each: { id, kind, prompt, options?, answer, explanation?, target: { kind, cardIds? }, evidence: { kind, pageId?, url?, quote? } }");
+		const nodeId = scope.nodeId;
+		let lockedNote;
+		let gatedNode;
+		let gatedRoadmap;
+		if (nodeId !== void 0) {
+			const roadmaps = scope.resourceId !== void 0 ? [this.store.readRoadmap(project.value.id, scope.resourceId)] : this.store.listResources(project.value.id).filter(isThickResource).map((candidate) => this.store.readRoadmap(project.value.id, candidate.id));
+			for (const roadmap of roadmaps) {
+				const node = roadmap?.nodes.find((candidate) => candidate.id === nodeId);
+				if (node !== void 0) {
+					gatedRoadmap = roadmap;
+					gatedNode = node;
+					break;
+				}
+			}
+			if (gatedNode === void 0 || gatedRoadmap === void 0) return refuse("not-found", `quiz scope names node ${JSON.stringify(nodeId)}, which no adopted path holds — library_read · roadmap lists the nodes`);
+			if (gatedNode.gate === "read") return refuse("invalid", `${gatedNode.title} is a read node — it has no quiz gate; quiz a quiz-gated node, or leave scope.node off for a free practice quiz`);
+			if (gatedNode.gate === "acceptance") return refuse("invalid", `${gatedNode.title} is an acceptance station — it completes by acceptance (library_assess with node), not by a quiz; to gate it ON a quiz, compose the quiz without a node (resource-level or free), then reference it from the station's acceptance: { line: "…", ref: "<quiz id>" } — the line auto-passes when the quiz passes`);
+			if (gatedNode.state === "locked") lockedNote = `${gatedNode.title} is still locked — the learner can take this quiz, but passing it completes the node only once the nodes before it are done`;
+		}
+		const pointAdds = [];
+		if (request.quiz.addPoints !== void 0 && request.quiz.addPoints.length > 0) {
+			if (gatedNode === void 0) return refuse("invalid", "addPoints belongs to a station quiz (scope.node) — a resource-level or free quiz has no points to extend");
+			const seen = new Set((gatedNode.points ?? []).map((point) => point.id));
+			for (const point of request.quiz.addPoints) {
+				if (!isLibraryId(point.id)) return refuse("invalid", `point id ${JSON.stringify(point.id)} is not a safe slug (letters, digits, . _ -)`);
+				if (typeof point.title !== "string" || point.title.trim() === "") return refuse("invalid", `point ${point.id} needs a title — the point as the learner reads it (「极限的定义」)`);
+				if (seen.has(point.id)) return refuse("invalid", `point ${point.id} already exists on ${gatedNode.title} — reference it (point: ${JSON.stringify(point.id)}), never re-add`);
+				seen.add(point.id);
+				pointAdds.push({
+					id: point.id,
+					title: point.title.trim()
+				});
+			}
+		}
+		const knownPoints = [...gatedNode?.points ?? [], ...pointAdds];
+		const knownPointIds = new Set(knownPoints.map((point) => point.id));
+		const liveCards = new Set(this.store.readCards(project.value.id).filter(live).map((card) => card.id));
+		const pageResourceIds = resource !== void 0 ? [resource.id] : gatedNode !== void 0 ? [...new Set(gatedNode.covers.flatMap((cover) => coverKind(cover) === "resource" ? [cover.ref] : []))] : this.store.listResources(project.value.id).map((candidate) => candidate.id);
+		const pages = new Map(pageResourceIds.flatMap((candidate) => this.store.readPages(project.value.id, candidate).map((page) => [page.id, page])));
+		const seenIds = /* @__PURE__ */ new Set();
+		const warnings = lockedNote === void 0 ? [] : [lockedNote];
+		const errors = [];
+		for (const [index, question] of request.quiz.questions.entries()) {
+			const label = `questions[${index}]${question.id === "" ? "" : ` (${question.id})`}`;
+			if (question.id === "" || seenIds.has(question.id)) errors.push(`${label} needs a unique id — q1, q2, … is plenty`);
+			seenIds.add(question.id);
+			if (![
+				"choice",
+				"fill",
+				"free"
+			].includes(question.kind)) errors.push(`${label}.kind is choice | fill | free`);
+			if (question.prompt.trim() === "" || question.answer.trim() === "") errors.push(`${label} needs both a prompt and an answer — a question without its answer cannot be graded`);
+			if (question.kind === "choice" && (question.options === void 0 || question.options.length < 2)) errors.push(`${label} is a choice question with fewer than two options`);
+			else if (question.kind === "choice" && question.options !== void 0 && choiceOptionIndex(question.options, question.answer) < 0) errors.push(`${label}.answer matches no option — a choice question's answer IS one of its options, copied verbatim (or its letter); write the correct option first, then the distractors around it`);
+			const target = question.target;
+			const targetOk = target !== void 0 && [
+				"marked",
+				"asked",
+				"missed",
+				"topic"
+			].includes(target.kind);
+			if (!targetOk) errors.push(`${label} needs target: { kind: marked|asked|missed|topic, cardIds? } — what the question aims at: the learner's marked cards, the points they asked about, the ones they missed before, or the chapter's topic`);
+			else {
+				const focus = request.quiz.focus;
+				if (focus === "mine" && target.kind === "topic") errors.push(`${label} tests the chapter's topic, but the learner asked for their OWN points only (focus: mine) — every question must target their cards (marked / asked / missed, with cardIds from library_read · cards). If this node has too few cards, write fewer questions and tell the learner; never pad with book content`);
+				if (focus === "book" && target.kind !== "topic") errors.push(`${label} targets the learner's cards, but they asked for the book's content only (focus: book) — target: { kind: "topic" } for every question`);
+				if (target.kind !== "topic") {
+					if (target.cardIds === void 0 || target.cardIds.length === 0) errors.push(`${label} targets ${target.kind} cards but names none — target.cardIds lists the cards it probes (library_read · cards finds them)`);
+					else {
+						const unknown = target.cardIds.filter((cardId) => !liveCards.has(cardId));
+						if (unknown.length > 0) errors.push(`${label} names cards that do not exist: ${unknown.join(", ")} — use ids from library_read · cards`);
+					}
+				}
+			}
+			if (question.point !== void 0) {
+				if (gatedNode === void 0) errors.push(`${label} names point ${JSON.stringify(question.point)}, but points belong to a station quiz (scope.node) — a resource-level or free quiz carries none`);
+				else if (!knownPointIds.has(question.point)) errors.push(`${label} probes point ${JSON.stringify(question.point)}, which ${gatedNode.title} does not hold — its points are: ${knownPoints.map((point) => `${point.id} (${point.title})`).join(", ") || "none yet"}; reuse one or add it via addPoints`);
+			} else if (knownPoints.length > 0) errors.push(`${label} names no point — this station's quizzes tag every question with the point it probes (point: one of ${[...knownPointIds].join(", ")})`);
+			const evidence = question.evidence;
+			if (evidence === void 0 || ![
+				"photo",
+				"web",
+				"knowledge"
+			].includes(evidence.kind)) errors.push(`${label} needs evidence: { kind: photo|web|knowledge, … } — what the answer rests on`);
+			else {
+				if (evidence.kind === "photo") {
+					const page = evidence.pageId === void 0 ? void 0 : pages.get(evidence.pageId);
+					if (page === void 0) errors.push(`${label} rests on a photo but names no recorded page — evidence.pageId comes from library_read · pages`);
+					else {
+						const quote = normalizeFragment(evidence.quote ?? "");
+						if (quote.length < 4) errors.push(`${label} rests on a photo — quote the printed passage (evidence.quote) the answer comes from`);
+						else if (!normalizeFragment(page.text).includes(quote)) warnings.push(`${label}: its quote is not verbatim in page ${page.label ?? page.id}'s text — stored; re-read the page and fix the quote`);
+					}
+				}
+				if (evidence.kind === "web") {
+					if (evidence.url === void 0 || !/^https?:\/\//.test(evidence.url)) errors.push(`${label} rests on the web — evidence.url is the page the quote is from`);
+					else if (normalizeFragment(evidence.quote ?? "").length < 8) errors.push(`${label} rests on the web — quote the passage (a sentence or two) so the learner can check it`);
+				}
+				if (evidence.kind === "knowledge" && targetOk && target.kind === "topic") {
+					if (gatedNode === void 0) {
+						if (resource !== void 0 && isThickResource(resource) && resource.meta?.bookKind === "material") errors.push(`${label} asks about 《${resource.title}》's content from memory — it is a material book (its exact text is what is tested). Ask the learner to photograph the page and quote it (evidence.kind photo); a web quote only from the SAME edition's text, verbatim — never your own words as a quote. If the book is really a textbook of domain knowledge, it is mis-typed: the learner switches it to 知识型 on the textbook page`);
+					} else {
+						const blocker = coversVerbatimBlocker(gatedNode.covers, (candidate) => this.store.readResource(project.value.id, candidate), gatedRoadmap?.primaryResourceId);
+						if (blocker !== void 0) errors.push(`${label} asks the station's content from memory, but ${blocker}. Ask the learner to photograph the page and quote it (evidence.kind photo); a web quote only from the same text, verbatim — never your own words as a quote, never material from another project`);
+					}
+				}
+			}
+			const text = [
+				question.prompt,
+				question.answer,
+				...question.options ?? [],
+				question.explanation ?? ""
+			].join(" ");
+			if (!text.includes("$") && /[√∫∑∏∂∞±]|\\[a-zA-Z]{2,}|\^\{|\w\^\d/.test(text)) warnings.push(`${label} reads like math without any $…$ — the sidebar typesets LaTeX only inside $…$ / $$…$$, so this shows as raw text; rewrite the formula parts (e.g. $\\sqrt{x+1}$)`);
+		}
+		if (errors.length === 1) return refuse("evidence-gate", errors[0]);
+		if (errors.length > 1) return refuse("evidence-gate", `${errors.length} problems in questions — fix them all, then resend:\n${errors.map((error) => `- ${error}`).join("\n")}`);
+		const probed = new Set(request.quiz.questions.map((question) => question.point));
+		const uncovered = knownPoints.filter((point) => !probed.has(point.id));
+		if (uncovered.length > 0) warnings.push(`never asks about ${uncovered.map((point) => point.title).join(", ")} — fine for a retake; a full chapter quiz touches every point at least once`);
+		if (nodeId === void 0) warnings.push(resource === void 0 ? "stored as a free quiz (no station, no resource): the learner finds it on the project page (自由测验) and it gates nothing — name node (a quiz-gated station) to gate one" : `stored as a resource-level quiz of 《${resource.title}》 (no station): the learner finds it on the resource page (本书测验) — name node (a quiz-gated station) to gate one`);
+		return await this.mutate(project.value.id, () => {
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const quiz = {
+				id: mintLibraryId("q"),
+				type: "quiz",
+				scope: {
+					...resource === void 0 ? {} : { resourceId: resource.id },
+					...nodeId === void 0 ? {} : { nodeId }
+				},
+				...request.quiz.focus === void 0 ? {} : { focus: request.quiz.focus },
+				questions: request.quiz.questions,
+				createdAt: now
+			};
+			this.store.writeAssessment(project.value.id, quiz);
+			if (gatedNode !== void 0) {
+				for (const assessment of this.store.listAssessments(project.value.id)) if (assessment.type === "quiz" && assessment.scope.nodeId === gatedNode.id && assessment.supersededBy === void 0) this.store.writeAssessment(project.value.id, {
+					...assessment,
+					supersededBy: quiz.id
+				});
+			}
+			if (pointAdds.length > 0 && gatedNode !== void 0 && gatedRoadmap !== void 0) {
+				const nodes = gatedRoadmap.nodes.map((node) => node.id === gatedNode.id ? {
+					...node,
+					points: [...node.points ?? [], ...pointAdds]
+				} : node);
+				this.store.writeRoadmap(project.value.id, {
+					...gatedRoadmap,
+					nodes
+				});
+			}
+			this.event(project.value.id, "quiz.created", {
+				at: quiz.createdAt,
+				id: quiz.id,
+				...resource === void 0 ? {} : { resourceId: resource.id },
+				count: request.quiz.questions.length,
+				...pointAdds.length === 0 ? {} : { count2: pointAdds.length }
+			});
+			return {
+				ok: true,
+				quiz,
+				warnings
+			};
+		});
+	}
+	/**
+	* Grade a sitting — the only cascading write. Two shapes, exactly one key:
+	* `assessmentId` (or the legacy alias `quizId`) judges a stored quiz;
+	* `nodeId` accepts an ACCEPTANCE station — resolved to the node's current
+	* practice assessment, each verdict's task naming one rubric line (its id
+	* L1…, or the line verbatim).
+	*
+	* Void verdicts count for nothing. Every probed card moves: a pass climbs a
+	* Leitner box and eases weakness by one; a fail resets to box 0 (due
+	* tomorrow) and adds weakness. A failed line with no card gets one
+	* (`missedCard`). The gated node's stats update (quiz nodes); at or above
+	* the pass ratio it completes and unlocks its dependents.
+	*/
+	async putAttempt(request) {
+		this.assertAlive("putAttempt");
+		const project = this.readProjectOrRefusal(request.projectId);
+		if ("error" in project) return project;
+		const assessmentId = request.assessmentId ?? request.quizId;
+		const nodeId = request.nodeId;
+		if (assessmentId === void 0 === (nodeId === void 0)) return refuse("invalid", "assess takes exactly one of quiz / node — quiz: a graded sitting on a stored quiz; node: acceptance of an acceptance station");
+		if (request.verdicts.length === 0) return refuse("invalid", "library_assess needs the verdicts — one per question: { task: <question id>, criterion, pass, ratio?, evidence, by, void?, missedCard? }");
+		if (assessmentId !== void 0) return await this.putQuizAttempt(project.value, assessmentId, request.verdicts);
+		return await this.putPracticeAttempt(project.value, nodeId ?? "", request.resourceId, request.verdicts);
+	}
+	/** The quiz path of putAttempt: verdicts judged against a stored quiz's questions. */
+	async putQuizAttempt(project, assessmentId, verdicts) {
+		const assessment = this.store.readAssessment(project.id, assessmentId);
+		if (assessment === void 0 || assessment.type !== "quiz" && assessment.type !== "retake" || assessment.questions === void 0) return refuse("not-found", `no quiz ${JSON.stringify(assessmentId)} — store the quiz first (library_quiz), then assess it`);
+		const questionById = new Map(assessment.questions.map((question) => [question.id, question]));
+		for (const [index, verdict] of verdicts.entries()) {
+			if (!questionById.has(verdict.task)) return refuse("invalid", `verdicts[${index}] judges task ${JSON.stringify(verdict.task)}, which quiz ${assessment.id} does not ask — its questions are: ${assessment.questions.map((question) => question.id).join(", ")}`);
+			if (verdict.criterion.trim() === "" || verdict.evidence.trim() === "") return refuse("invalid", `verdicts[${index}] (${verdict.task}) needs criterion and evidence — WHAT was judged and WHERE the answer is grounded`);
+			if (verdict.by !== "llm" && verdict.by !== "self" && verdict.by !== "user") return refuse("invalid", `verdicts[${index}].by must be llm | self | user`);
+			if (verdict.ratio !== void 0 && !(verdict.ratio >= 0 && verdict.ratio <= 1)) return refuse("invalid", `verdicts[${index}].ratio is partial credit in [0, 1]`);
+		}
+		const counted = verdicts.filter((verdict) => verdict.void !== true);
+		const ratio = counted.length === 0 ? 0 : counted.reduce((sum, verdict) => sum + (verdict.ratio ?? (verdict.pass ? 1 : 0)), 0) / counted.length;
+		return await this.mutate(project.id, () => {
+			const now = /* @__PURE__ */ new Date();
+			const at = now.toISOString();
+			const befores = (assessment.scope.nodeId !== void 0 ? [assessment.scope.nodeId] : [...new Set((assessment.questions ?? []).flatMap((question) => {
+				const origin = question.origin === void 0 ? void 0 : this.store.readAssessment(project.id, question.origin.assessmentId);
+				return origin?.scope.nodeId === void 0 ? [] : [origin.scope.nodeId];
+			}))]).map((stationId) => [stationId, this.stationMasteryOf(project.id, stationId, stationId === assessment.scope.nodeId ? assessment.scope.resourceId : void 0)]);
+			const attempt = {
+				id: mintLibraryId("a"),
+				assessmentId: assessment.id,
+				verdicts,
+				ratio,
+				at
+			};
+			this.store.appendAttempt(project.id, attempt);
+			const cards = this.store.readCards(project.id);
+			const byId = new Map(cards.map((card) => [card.id, card]));
+			const order = cards.map((card) => card.id);
+			const touched = /* @__PURE__ */ new Map();
+			const resource = assessment.scope.resourceId === void 0 ? void 0 : this.store.readResource(project.id, assessment.scope.resourceId);
+			for (const verdict of counted) {
+				const question = questionById.get(verdict.task);
+				const credit = verdict.ratio ?? (verdict.pass ? 1 : 0);
+				const passed = verdict.pass && credit >= .5;
+				const cardIds = [...question.target.cardIds ?? []];
+				if (cardIds.length === 0 && !passed && (verdict.missedCard?.term.trim() ?? "") !== "") {
+					const created = this.missedCardFor(question, verdict, assessment, resource?.id, project.template, at);
+					const existing = exactMatch([...byId.values()], [cardKey(created.term)]);
+					if (existing === void 0) {
+						byId.set(created.id, created);
+						order.push(created.id);
+						touched.set(created.id, {
+							id: created.id,
+							term: created.term,
+							weakness: created.weakness,
+							mastery: created.mastery,
+							created: true
+						});
+						continue;
+					}
+					cardIds.push(existing.id);
+				}
+				for (const cardId of cardIds) {
+					const card = byId.get(cardId);
+					if (card === void 0 || !live(card)) continue;
+					const box = passed ? Math.min(card.mastery.box + 1, 5) : 0;
+					const next = {
+						...card,
+						mastery: {
+							box,
+							dueAt: leitnerDueAt(box, now),
+							streak: passed ? card.mastery.streak + 1 : 0
+						},
+						weakness: clampWeakness(card.weakness + (passed ? -1 : 1)),
+						sources: passed ? card.sources : [...card.sources, {
+							type: "quiz",
+							ref: assessment.id,
+							note: verdict.criterion.slice(0, 120),
+							weakened: true,
+							at
+						}],
+						updatedAt: at
+					};
+					byId.set(card.id, next);
+					touched.set(card.id, {
+						id: card.id,
+						term: card.term,
+						weakness: next.weakness,
+						mastery: next.mastery
+					});
+				}
+			}
+			if (touched.size > 0) this.store.writeCards(project.id, order.map((cardId) => byId.get(cardId)));
+			let unlocked = [];
+			let completed;
+			const roadmap = assessment.scope.nodeId === void 0 ? void 0 : this.findNodeRoadmap(project.id, assessment.scope.nodeId, assessment.scope.resourceId);
+			const passRatio = roadmap?.passRatio ?? .8;
+			const gated = assessment.scope.nodeId === void 0 ? void 0 : roadmap?.nodes.find((node) => node.id === assessment.scope.nodeId);
+			if (roadmap !== void 0 && gated !== void 0 && gated.gate === "quiz" && assessment.type === "quiz") {
+				const updated = roadmap.nodes.map((node) => {
+					if (node.id !== gated.id) return node;
+					const stats = node.quizStats ?? { attempts: 0 };
+					const next = {
+						...node,
+						quizStats: {
+							attempts: stats.attempts + 1,
+							lastRatio: ratio,
+							bestRatio: Math.max(stats.bestRatio ?? 0, ratio)
+						}
+					};
+					if (ratio >= passRatio && node.state === "current") {
+						completed = node.id;
+						return {
+							...next,
+							state: "done"
+						};
+					}
+					return next;
+				});
+				const result = completed === void 0 ? {
+					nodes: updated,
+					unlocked: []
+				} : unlockReady(updated);
+				unlocked = result.unlocked;
+				this.store.writeRoadmap(project.id, {
+					...roadmap,
+					nodes: result.nodes
+				});
+			}
+			const created = [...touched.values()].filter((update) => update.created === true);
+			const onResource = assessment.scope.resourceId === void 0 ? {} : { resourceId: assessment.scope.resourceId };
+			const pointChanges = befores.flatMap(([stationId, before]) => this.pointChangesSince(project.id, stationId, stationId === assessment.scope.nodeId ? assessment.scope.resourceId : void 0, before, at));
+			this.store.appendEvents(project.id, [
+				{
+					at,
+					type: "attempt.assessed",
+					id: assessment.id,
+					...onResource,
+					ratio
+				},
+				...created.length === 0 ? [] : [{
+					at,
+					type: "cards.recorded",
+					source: "quiz",
+					title: created.map((update) => update.term).join("、").slice(0, 300),
+					ids: created.map((update) => update.id),
+					...onResource,
+					count: created.length
+				}],
+				...completed === void 0 ? [] : [{
+					at,
+					type: "node.completed",
+					id: completed,
+					title: titleOf(roadmap?.nodes ?? [], completed),
+					...onResource,
+					ratio
+				}],
+				...unlocked.map((nodeId) => ({
+					at,
+					type: "node.unlocked",
+					id: nodeId,
+					title: titleOf(roadmap?.nodes ?? [], nodeId),
+					...onResource
+				}))
+			]);
+			return {
+				ok: true,
+				attempt,
+				cardUpdates: [...touched.values()],
+				unlocked,
+				...completed === void 0 ? {} : { completed },
+				passRatio,
+				...pointChanges.length === 0 ? {} : { pointChanges }
+			};
+		});
+	}
+	/**
+	* The practice path of putAttempt: acceptance of a hands-on station, judged
+	* against the node's current practice assessment (materialized at adoption).
+	* No probed cards — a failed acceptance line with a `missedCard` leaves (or
+	* re-weakens) a card; at the pass ratio the station completes.
+	*/
+	async putPracticeAttempt(project, nodeId, resourceId, verdicts) {
+		const roadmap = this.findNodeRoadmap(project.id, nodeId, resourceId);
+		const node = roadmap?.nodes.find((candidate) => candidate.id === nodeId);
+		if (roadmap === void 0 || node === void 0) return refuse("not-found", `no station ${JSON.stringify(nodeId)} on the adopted path — library_read · roadmap lists the nodes`);
+		if (node.gate !== "acceptance") return refuse("state-machine", `${node.title} is a ${node.gate} node — a quiz node completes by passing its quiz (assess with quiz), a read node by 读完; only an acceptance station takes acceptance verdicts`);
+		const assessment = this.store.listAssessments(project.id).find((candidate) => candidate.type === "practice" && candidate.scope.nodeId === node.id && candidate.supersededBy === void 0);
+		const rubric = assessment?.rubric ?? acceptanceLines(node);
+		if (rubric.length === 0) return refuse("invalid", `${node.title} carries no acceptance lines — the coach drafts them into the roadmap (library_roadmap)`);
+		const passRatio = roadmap.passRatio ?? .8;
+		const attempts = this.store.readAttempts(project.id);
+		const auto = [];
+		const autoTasks = /* @__PURE__ */ new Set();
+		for (const line of rubric) {
+			if (line.ref === void 0) continue;
+			const referenced = this.store.readAssessment(project.id, line.ref);
+			const latest = referenced === void 0 ? void 0 : attempts.filter((attempt) => attempt.assessmentId === referenced.id).at(-1);
+			const quizRatio = latest?.ratio ?? 0;
+			auto.push({
+				task: line.id,
+				criterion: line.line,
+				pass: latest !== void 0 && quizRatio >= passRatio,
+				ratio: quizRatio,
+				evidence: latest === void 0 ? `机检：${line.ref} 还没有判分记录` : `机检：${line.ref} 最新一场 ${Math.round(quizRatio * 100)}%（过线 ${Math.round(passRatio * 100)}%）`,
+				by: "auto"
+			});
+			autoTasks.add(line.id);
+		}
+		const judged = [];
+		for (const [index, verdict] of verdicts.entries()) {
+			const line = rubric.find((candidate) => candidate.id === verdict.task) ?? rubric.find((candidate) => candidate.line === verdict.criterion);
+			if (line === void 0) return refuse("invalid", `verdicts[${index}] names no rubric line — task is the line id, criterion the line verbatim; the rubric is: ${rubric.map((candidate) => `${candidate.id} ${JSON.stringify(candidate.line)}`).join(", ")}`);
+			if (autoTasks.has(line.id)) return refuse("invalid", `verdicts[${index}] judges ${line.id}, which assessment ${line.ref} machine-checks — a ref line takes no verdict`);
+			if (verdict.evidence.trim() === "") return refuse("invalid", `verdicts[${index}] needs evidence — what the learner showed (terminal output, a screenshot, a repo link)`);
+			if (verdict.by !== "llm" && verdict.by !== "self" && verdict.by !== "user") return refuse("invalid", `verdicts[${index}].by must be llm | self | user`);
+			if (verdict.ratio !== void 0 && !(verdict.ratio >= 0 && verdict.ratio <= 1)) return refuse("invalid", `verdicts[${index}].ratio is partial credit in [0, 1]`);
+			judged.push({
+				...verdict,
+				task: line.id,
+				criterion: line.line
+			});
+		}
+		const all = [...judged, ...auto];
+		const counted = all.filter((verdict) => verdict.void !== true);
+		const ratio = counted.length === 0 ? 0 : counted.reduce((sum, verdict) => sum + (verdict.ratio ?? (verdict.pass ? 1 : 0)), 0) / counted.length;
+		return await this.mutate(project.id, () => {
+			const now = /* @__PURE__ */ new Date();
+			const at = now.toISOString();
+			let key = assessment;
+			if (key === void 0) {
+				key = {
+					id: mintLibraryId("q"),
+					type: "practice",
+					scope: { nodeId: node.id },
+					rubric,
+					createdAt: at
+				};
+				this.store.writeAssessment(project.id, key);
+			}
+			const attempt = {
+				id: mintLibraryId("a"),
+				assessmentId: key.id,
+				verdicts: all,
+				ratio,
+				at
+			};
+			this.store.appendAttempt(project.id, attempt);
+			const cards = this.store.readCards(project.id);
+			const byId = new Map(cards.map((card) => [card.id, card]));
+			const order = cards.map((card) => card.id);
+			const touched = /* @__PURE__ */ new Map();
+			for (const verdict of counted) {
+				if (verdict.pass && (verdict.ratio ?? 1) >= .5 || verdict.missedCard === void 0) continue;
+				const term = verdict.missedCard.term.trim() || verdict.criterion.slice(0, 80);
+				const gloss = verdict.missedCard.gloss.trim() || verdict.criterion;
+				const existing = exactMatch([...byId.values()], [cardKey(term)]);
+				if (existing !== void 0) {
+					if (!live(existing)) continue;
+					const next = {
+						...existing,
+						mastery: {
+							box: 0,
+							dueAt: leitnerDueAt(0, now),
+							streak: 0
+						},
+						weakness: clampWeakness(existing.weakness + 1),
+						sources: [...existing.sources, {
+							type: "quiz",
+							note: verdict.criterion.slice(0, 120),
+							weakened: true,
+							at
+						}],
+						updatedAt: at
+					};
+					byId.set(next.id, next);
+					touched.set(next.id, {
+						id: next.id,
+						term: next.term,
+						weakness: next.weakness,
+						mastery: next.mastery
+					});
+					continue;
+				}
+				const card = {
+					id: mintLibraryId("c"),
+					kind: project.template === "language" && !/\s/.test(term) ? "word" : "concept",
+					term,
+					aliases: [],
+					gloss,
+					contexts: [],
+					sources: [{
+						type: "quiz",
+						note: verdict.criterion.slice(0, 120),
+						weakened: true,
+						at
+					}],
+					weakness: 1,
+					mastery: {
+						box: 0,
+						dueAt: leitnerDueAt(0, now),
+						streak: 0
+					},
+					status: "active",
+					createdAt: at,
+					updatedAt: at
+				};
+				byId.set(card.id, card);
+				order.push(card.id);
+				touched.set(card.id, {
+					id: card.id,
+					term: card.term,
+					weakness: card.weakness,
+					mastery: card.mastery,
+					created: true
+				});
+			}
+			if (touched.size > 0) this.store.writeCards(project.id, order.map((cardId) => byId.get(cardId)));
+			let unlocked = [];
+			let completed;
+			if (ratio >= passRatio && node.state === "current") {
+				completed = node.id;
+				const result = unlockReady(roadmap.nodes.map((candidate) => candidate.id === node.id ? {
+					...candidate,
+					state: "done"
+				} : candidate));
+				unlocked = result.unlocked;
+				this.store.writeRoadmap(project.id, {
+					...roadmap,
+					nodes: result.nodes
+				});
+			}
+			const created = [...touched.values()].filter((update) => update.created === true);
+			const onResource = resourceId === void 0 ? {} : { resourceId };
+			this.store.appendEvents(project.id, [
+				{
+					at,
+					type: "attempt.assessed",
+					id: node.id,
+					...onResource,
+					ratio
+				},
+				...created.length === 0 ? [] : [{
+					at,
+					type: "cards.recorded",
+					source: "quiz",
+					title: created.map((update) => update.term).join("、").slice(0, 300),
+					ids: created.map((update) => update.id),
+					...onResource,
+					count: created.length
+				}],
+				...completed === void 0 ? [] : [{
+					at,
+					type: "node.completed",
+					id: completed,
+					title: titleOf(roadmap.nodes, completed),
+					...onResource,
+					ratio
+				}],
+				...unlocked.map((unlockedId) => ({
+					at,
+					type: "node.unlocked",
+					id: unlockedId,
+					title: titleOf(roadmap.nodes, unlockedId),
+					...onResource
+				}))
+			]);
+			return {
+				ok: true,
+				attempt,
+				cardUpdates: [...touched.values()],
+				unlocked,
+				...completed === void 0 ? {} : { completed },
+				passRatio
+			};
+		});
+	}
+	/** Every open miss across the project's adopted quiz stations, newest first. */
+	projectOpenMisses(projectId) {
+		const assessments = this.store.listAssessments(projectId);
+		const attempts = this.store.readAttempts(projectId);
+		const open = [];
+		for (const resource of this.store.listResources(projectId)) for (const node of this.store.readRoadmap(projectId, resource.id)?.nodes ?? []) if (node.gate === "quiz") open.push(...stationMastery(node, assessments, attempts).open);
+		return open.sort((a, b) => b.at.localeCompare(a.at));
+	}
+	/** A station's mastery as the ledger stands (undefined off a station, or for a node no adopted path holds). */
+	stationMasteryOf(projectId, nodeId, resourceId) {
+		if (nodeId === void 0) return void 0;
+		const node = this.findNodeRoadmap(projectId, nodeId, resourceId)?.nodes.find((candidate) => candidate.id === nodeId);
+		if (node === void 0) return void 0;
+		return stationMastery(node, this.store.listAssessments(projectId), this.store.readAttempts(projectId));
+	}
+	/**
+	* The points a write moved, read against `before`; each change is ledgered
+	* as a `point.changed` event (今日 「最近的变化」). Call inside the lock,
+	* after the write.
+	*/
+	pointChangesSince(projectId, nodeId, resourceId, before, at) {
+		if (nodeId === void 0 || before === void 0) return [];
+		const after = this.stationMasteryOf(projectId, nodeId, resourceId);
+		if (after === void 0) return [];
+		const changes = masteryChanges(nodeId, before, after);
+		const roadmap = this.findNodeRoadmap(projectId, nodeId, resourceId);
+		const onResource = roadmap?.primaryResourceId === void 0 ? {} : { resourceId: roadmap.primaryResourceId };
+		if (changes.length > 0) this.store.appendEvents(projectId, changes.map((change) => {
+			const point = after.points.find((candidate) => candidate.id === change.pointId);
+			const note = point?.notes.at(-1);
+			return {
+				at,
+				type: "point.changed",
+				id: change.pointId,
+				nodeId,
+				title: change.title,
+				...onResource,
+				from: change.from,
+				to: change.to,
+				count: point?.open.length ?? 0,
+				...change.to === "weak" && note !== void 0 && (point?.open.length ?? 0) === 0 ? { detail: (note.term ?? note.text).slice(0, 300) } : {}
+			};
+		}));
+		return changes;
+	}
+	/**
+	* 订正: a retake paper re-asking a station's open misses (all, or the keys
+	* named — `${assessmentId}:${questionId}`). Its verdicts move the points,
+	* never the station's pass record. No coach needed: the questions exist.
+	*/
+	async createRetake(request) {
+		this.assertAlive("createRetake");
+		const project = this.readProjectOrRefusal(request.projectId);
+		if ("error" in project) return project;
+		return await this.mutate(project.value.id, () => {
+			let open;
+			if (request.nodeId === void 0) open = this.projectOpenMisses(project.value.id);
+			else {
+				const mastery = this.stationMasteryOf(project.value.id, request.nodeId, request.resourceId);
+				if (mastery === void 0) return refuse("not-found", `no adopted station ${JSON.stringify(request.nodeId)}`);
+				open = [...mastery.open];
+			}
+			const wanted = request.keys === void 0 || request.keys.length === 0 ? void 0 : new Set(request.keys);
+			const misses = open.filter((miss) => wanted === void 0 || wanted.has(miss.key));
+			if (misses.length === 0) return refuse("invalid", `nothing to retake here — ${request.nodeId === void 0 ? "the project" : "this station"} has no open misses`);
+			const roadmap = request.nodeId === void 0 ? void 0 : this.findNodeRoadmap(project.value.id, request.nodeId, request.resourceId);
+			const assessment = {
+				id: mintLibraryId("q"),
+				type: "retake",
+				scope: request.nodeId === void 0 ? {} : {
+					nodeId: request.nodeId,
+					...roadmap?.primaryResourceId === void 0 ? {} : { resourceId: roadmap.primaryResourceId }
+				},
+				questions: misses.map((miss, index) => ({
+					...miss.question,
+					id: `r${index + 1}`,
+					origin: {
+						assessmentId: miss.assessmentId,
+						questionId: miss.questionId
+					}
+				})),
+				createdAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			this.store.writeAssessment(project.value.id, assessment);
+			return {
+				ok: true,
+				assessment
+			};
+		});
+	}
+	/**
+	* A coach note on a knowledge point: the learner stuck on it here. The
+	* point turns weak until a newer probe passes (subject projects — a weak
+	* point lands on its point, not on a card).
+	*/
+	async notePoint(request) {
+		this.assertAlive("notePoint");
+		const project = this.readProjectOrRefusal(request.projectId);
+		if ("error" in project) return project;
+		const text = request.text.trim();
+		if (text === "") return refuse("invalid", "a point note needs its text — what the learner stuck on, in one line");
+		return await this.mutate(project.value.id, () => {
+			const roadmap = this.findNodeRoadmap(project.value.id, request.nodeId, request.resourceId);
+			const node = roadmap?.nodes.find((candidate) => candidate.id === request.nodeId);
+			if (roadmap === void 0 || node === void 0) return refuse("not-found", `no adopted station ${JSON.stringify(request.nodeId)} — library_read · roadmap lists them`);
+			const point = node.points?.find((candidate) => candidate.id === request.pointId);
+			if (point === void 0) return refuse("not-found", `station ${node.title} has no point ${JSON.stringify(request.pointId)} — its points: ${(node.points ?? []).map((candidate) => `${candidate.id} (${candidate.title})`).join(", ") || "none"}`);
+			const before = this.stationMasteryOf(project.value.id, request.nodeId, request.resourceId);
+			const at = (/* @__PURE__ */ new Date()).toISOString();
+			const note = {
+				text: text.slice(0, 1e3),
+				...request.term === void 0 || request.term.trim() === "" ? {} : { term: request.term.trim().slice(0, 100) },
+				at,
+				...request.session === void 0 ? {} : { session: request.session }
+			};
+			this.store.writeRoadmap(project.value.id, {
+				...roadmap,
+				nodes: roadmap.nodes.map((candidate) => candidate.id !== node.id ? candidate : {
+					...candidate,
+					points: (candidate.points ?? []).map((entry) => entry.id !== point.id ? entry : {
+						...entry,
+						notes: [...entry.notes ?? [], note]
+					})
+				})
+			});
+			const changes = this.pointChangesSince(project.value.id, request.nodeId, request.resourceId, before, at);
+			return {
+				ok: true,
+				point: this.stationMasteryOf(project.value.id, request.nodeId, request.resourceId).points.find((candidate) => candidate.id === point.id),
+				changes
+			};
+		});
+	}
+	/** The roadmap holding one node: the hinted textbook's first, then every adopted path of the project. */
+	findNodeRoadmap(projectId, nodeId, resourceId) {
+		const hinted = this.store.readRoadmap(projectId, resourceId);
+		if (hinted?.nodes.some((node) => node.id === nodeId)) return hinted;
+		for (const resource of this.store.listResources(projectId)) {
+			const roadmap = this.store.readRoadmap(projectId, resource.id);
+			if (roadmap?.nodes.some((node) => node.id === nodeId)) return roadmap;
+		}
+	}
+	/** The card a missed, card-less question leaves behind. */
+	missedCardFor(question, verdict, quiz, resourceId, template, at) {
+		const term = verdict.missedCard?.term.trim() ?? "";
+		const gloss = verdict.missedCard?.gloss.trim() || question.answer.trim();
+		return {
+			id: mintLibraryId("c"),
+			kind: template === "language" && verdict.missedCard !== void 0 && !/\s/.test(term) ? "word" : "concept",
+			term,
+			aliases: [],
+			gloss,
+			contexts: question.evidence.quote === void 0 ? [] : [{
+				sentence: question.evidence.quote,
+				...resourceId === void 0 ? {} : { resourceId },
+				...question.evidence.pageId === void 0 ? {} : { pageId: question.evidence.pageId }
+			}],
+			...resourceId === void 0 ? {} : { resourceId },
+			sources: [{
+				type: "quiz",
+				ref: quiz.id,
+				note: verdict.criterion.slice(0, 120),
+				weakened: true,
+				at
+			}],
+			weakness: 1,
+			mastery: {
+				box: 0,
+				dueAt: leitnerDueAt(0, new Date(at)),
+				streak: 0
+			},
+			status: "active",
+			createdAt: at,
+			updatedAt: at
+		};
+	}
+	/**
+	* A project's graded sittings, newest first. `nodeId` narrows to one node's
+	* history: sittings keyed to an assessment scoped on it, plus legacy v4
+	* acceptance sittings that named the node directly. `assessmentId` narrows
+	* to one assessment's sittings.
+	*/
+	async listAttempts(request) {
+		this.assertAlive("listAttempts");
+		let attempts = this.store.readAttempts(request.projectId);
+		if (request.assessmentId !== void 0) attempts = attempts.filter((attempt) => attempt.assessmentId === request.assessmentId);
+		if (request.nodeId !== void 0) {
+			const nodeAssessmentIds = new Set(this.store.listAssessments(request.projectId).filter((assessment) => assessment.scope.nodeId === request.nodeId).map((assessment) => assessment.id));
+			attempts = attempts.filter((attempt) => attempt.nodeId === request.nodeId || attempt.assessmentId !== void 0 && nodeAssessmentIds.has(attempt.assessmentId));
+		}
+		return { attempts: attempts.reverse() };
+	}
+};
+//#endregion
+//#region lib/types/service/bindings.js
+/**
+* Session bindings, the per-turn binding summary, events, activity and stats — the top layer, exported as LibraryService.
+*
+* One layer of the library service (see `service/core.ts` for the layering):
+* the methods are the service's own, moved here verbatim by domain.
+*
+* @module @khorsheed/dsh-library/service/bindings
+*/
+var LibraryService = class extends LibraryServiceAssess {
+	/** The project / resource a session works on, when it is bound. */
+	getBinding(sessionId) {
+		this.assertAlive("getBinding");
+		return this.store.readBindings().get(sessionId);
+	}
+	/** Bind a session (null unbinds). The project and resource must exist. */
+	async setBinding(sessionId, binding) {
+		this.assertAlive("setBinding");
+		if (sessionId === "") return refuse("invalid", "no session to bind");
+		if (binding !== null) {
+			const project = this.readProjectOrRefusal(binding.projectId);
+			if ("error" in project) return project;
+			if (binding.resourceId !== void 0 && this.store.readResource(binding.projectId, binding.resourceId) === void 0) return refuse("not-found", `no resource ${JSON.stringify(binding.resourceId)} in project ${JSON.stringify(project.value.name)} — resource ids are minted (r_…), never chosen by the caller; library_read · resources lists them. Registering the resource (library_textbook) binds this session itself — no separate library_binding call needed`);
+		}
+		try {
+			await this.store.withBindingsLock(() => {
+				const bindings = new Map(this.store.readBindings());
+				const before = bindings.get(sessionId);
+				const previous = before === void 0 ? void 0 : before.projectId !== binding?.projectId ? before.projectId : before.previousProjectId;
+				if (binding === null) bindings.delete(sessionId);
+				else bindings.set(sessionId, {
+					projectId: binding.projectId,
+					...binding.resourceId === void 0 ? {} : { resourceId: binding.resourceId },
+					...previous === void 0 ? {} : { previousProjectId: previous }
+				});
+				this.store.writeBindings(bindings);
+			});
+			if (binding !== null) this.changed(binding.projectId);
+			return {
+				ok: true,
+				binding
+			};
+		} catch (error) {
+			return storeRefusal(error);
+		}
+	}
+	/**
+	* The bound session's working set, read synchronously (the per-turn prompt
+	* context renders inside a synchronous callback): the project, the bound
+	* resource, every textbook's path state in study order (so the coach reads
+	* what the learner adopted, discarded or reordered in the sidebar, every
+	* turn), and the weakest live cards.
+	*/
+	bindingSummary(sessionId, cardLimit = 12) {
+		this.assertAlive("bindingSummary");
+		const binding = this.getBinding(sessionId);
+		if (binding === void 0) return {
+			textbooks: [],
+			weakCards: []
+		};
+		let project;
+		try {
+			project = this.store.readProject(binding.projectId);
+		} catch {
+			project = void 0;
+		}
+		if (project === void 0) return {
+			binding,
+			textbooks: [],
+			weakCards: []
+		};
+		const resource = binding.resourceId === void 0 ? void 0 : this.store.readResource(project.id, binding.resourceId);
+		const textbooks = this.store.listResources(project.id).filter(isThickResource).map((textbook) => this.resourceProgress(project.id, textbook));
+		const weakCards = this.store.readCards(project.id).filter((card) => card.status === "active" && card.weakness > 0 && (resource === void 0 || card.resourceId === resource.id)).sort((a, b) => b.weakness - a.weakness || b.updatedAt.localeCompare(a.updatedAt)).slice(0, cardLimit);
+		const current = resource === void 0 ? void 0 : this.store.readRoadmap(project.id, resource.id)?.nodes.find((node) => node.state === "current" && node.gate === "quiz");
+		const mastery = current === void 0 ? void 0 : this.stationMasteryOf(project.id, current.id, resource?.id);
+		return {
+			binding,
+			project,
+			...resource === void 0 ? {} : { resource },
+			textbooks,
+			...current === void 0 || mastery === void 0 ? {} : { station: {
+				id: current.id,
+				title: current.title,
+				mastery
+			} },
+			weakCards
+		};
+	}
+	/** One project's audit trail, newest first, optionally some types only. */
+	async listEvents(request) {
+		this.assertAlive("listEvents");
+		const types = request.types === void 0 ? void 0 : new Set(request.types);
+		return { events: this.store.readEvents(request.projectId).filter((event) => types === void 0 || types.has(event.type)).reverse().slice(0, request.limit ?? 20) };
+	}
+	/** 「教练最近记下」: card recordings from chats and quizzes, across projects, newest first. */
+	/** A project's name, when it exists (synchronous — the per-turn context reads it). */
+	projectName(projectId) {
+		try {
+			return this.store.readProject(projectId)?.name;
+		} catch {
+			return;
+		}
+	}
+	/** The newest knowledge-point state changes across projects (今日 「最近的变化」). */
+	async recentChanges(request) {
+		this.assertAlive("recentChanges");
+		const changes = [];
+		for (const project of this.store.readIndex().projects) for (const event of this.store.readEvents(project.id)) {
+			if (event.type !== "point.changed" || event.nodeId === void 0 || event.resourceId === void 0 || event.id === void 0) continue;
+			if ((this.store.readRoadmap(project.id, event.resourceId)?.nodes.find((candidate) => candidate.id === event.nodeId))?.points?.some((point) => point.id === event.id) !== true) continue;
+			changes.push({
+				...event,
+				projectId: project.id,
+				projectName: project.name
+			});
+		}
+		changes.sort((a, b) => b.at.localeCompare(a.at));
+		return { changes: changes.slice(0, request.limit ?? 10) };
+	}
+	async recentRecords(request) {
+		this.assertAlive("recentRecords");
+		const records = [];
+		for (const project of this.store.readIndex().projects) {
+			const liveTerms = new Map(this.store.readCards(project.id).filter((card) => card.status !== "deleted").map((card) => [card.id, card.term]));
+			for (const event of this.store.readEvents(project.id)) {
+				if (event.type !== "cards.recorded" || event.source !== "chat" && event.source !== "quiz") continue;
+				const ids = (event.ids ?? []).filter((cardId) => liveTerms.has(cardId));
+				if (event.ids !== void 0 && ids.length === 0) continue;
+				records.push({
+					...event,
+					...event.ids === void 0 ? {} : {
+						ids,
+						title: ids.map((cardId) => liveTerms.get(cardId)).join("、").slice(0, 300)
+					},
+					projectId: project.id,
+					projectName: project.name
+				});
+			}
+		}
+		records.sort((a, b) => b.at.localeCompare(a.at));
+		return { records: records.slice(0, request.limit ?? 10) };
+	}
+	/**
+	* The newest event's timestamp across the library — the pane's change poll.
+	* The Remote face is request/response (no push), so the sidebar learns
+	* host-side writes (a landed quiz, a recorded page) by polling this and
+	* re-reading when it moves. Writes that log no event (creating a project)
+	* move it too. `session` names the newest session-made write, so the client
+	* can reveal the library next to the conversation that just started using it.
+	*/
+	async latestActivity() {
+		this.assertAlive("latestActivity");
+		let latest = this.lastChangeAt;
+		for (const project of this.store.readIndex().projects) {
+			const at = this.store.readEvents(project.id).at(-1)?.at;
+			if (at !== void 0 && (latest === void 0 || at > latest)) latest = at;
+		}
+		return {
+			...latest === void 0 ? {} : { at: latest },
+			...this.lastSessionWrite === void 0 ? {} : { session: {
+				id: this.lastSessionWrite.session,
+				at: this.lastSessionWrite.at
+			} }
+		};
+	}
+	/** The whole-library tally. */
+	async stats() {
+		this.assertAlive("stats");
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		let books = 0;
+		let cards = 0;
+		let due = 0;
+		let quizzes = 0;
+		let attempts = 0;
+		const index = this.store.readIndex();
+		for (const project of index.projects) {
+			books += this.store.listResources(project.id).filter(isThickResource).length;
+			quizzes += this.store.listAssessments(project.id).filter((assessment) => assessment.type === "quiz").length;
+			attempts += this.store.readAttempts(project.id).length;
+			for (const card of this.store.readCards(project.id)) {
+				if (card.status !== "active") continue;
+				cards += 1;
+				if (card.mastery.dueAt <= now) due += 1;
+			}
+		}
+		return {
+			projects: index.projects.length,
+			books,
+			cards,
+			due,
+			quizzes,
+			attempts
+		};
+	}
+};
+//#endregion
+//#region lib/types/remote.js
+var __runInitializers = function(thisArg, initializers, value) {
+	var useValue = arguments.length > 2;
+	for (var i = 0; i < initializers.length; i++) value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+	return useValue ? value : void 0;
+};
+var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+	function accept(f) {
+		if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+		return f;
+	}
+	var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+	var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+	var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+	var _, done = false;
+	for (var i = decorators.length - 1; i >= 0; i--) {
+		var context = {};
+		for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+		for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+		context.addInitializer = function(f) {
+			if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+			extraInitializers.push(accept(f || null));
+		};
+		var result = (0, decorators[i])(kind === "accessor" ? {
+			get: descriptor.get,
+			set: descriptor.set
+		} : descriptor[key], context);
+		if (kind === "accessor") {
+			if (result === void 0) continue;
+			if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+			if (_ = accept(result.get)) descriptor.get = _;
+			if (_ = accept(result.set)) descriptor.set = _;
+			if (_ = accept(result.init)) initializers.unshift(_);
+		} else if (_ = accept(result)) {
+			if (kind === "field") initializers.unshift(_);
+			else descriptor[key] = _;
+		}
+	}
+	if (target) Object.defineProperty(target, contextIn.name, descriptor);
+	done = true;
+};
+/** The wire namespace is `library`: the browser calls `remote.library.*`. */
+let LibraryRemoteService = (() => {
+	let _classSuper = TypertRemoteService;
+	let _instanceExtraInitializers = [];
+	let _capabilities_decorators;
+	let _listProjects_decorators;
+	let _getProject_decorators;
+	let _createProject_decorators;
+	let _updateProject_decorators;
+	let _deleteProject_decorators;
+	let _getResource_decorators;
+	let _listResources_decorators;
+	let _putResource_decorators;
+	let _setBookKind_decorators;
+	let _moveResource_decorators;
+	let _removeResource_decorators;
+	let _getRoadmap_decorators;
+	let _adoptRoadmap_decorators;
+	let _discardDraft_decorators;
+	let _markNodeRead_decorators;
+	let _listPages_decorators;
+	let _readPagePhoto_decorators;
+	let _savePhoto_decorators;
+	let _recordPage_decorators;
+	let _listCards_decorators;
+	let _dueCards_decorators;
+	let _writeCards_decorators;
+	let _editCard_decorators;
+	let _undoCards_decorators;
+	let _reviewCard_decorators;
+	let _listAssessments_decorators;
+	let _getAssessment_decorators;
+	let _putAttempt_decorators;
+	let _listAttempts_decorators;
+	let _boundTarget_decorators;
+	let _bindTarget_decorators;
+	let _listEvents_decorators;
+	let _recentChanges_decorators;
+	let _createRetake_decorators;
+	let _recentRecords_decorators;
+	let _latestActivity_decorators;
+	let _stats_decorators;
+	return class LibraryRemoteService extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_capabilities_decorators = [Remote("capabilities")];
+			_listProjects_decorators = [Remote("listProjects")];
+			_getProject_decorators = [Remote("getProject")];
+			_createProject_decorators = [Remote("createProject")];
+			_updateProject_decorators = [Remote("updateProject")];
+			_deleteProject_decorators = [Remote("deleteProject")];
+			_getResource_decorators = [Remote("getResource")];
+			_listResources_decorators = [Remote("listResources")];
+			_putResource_decorators = [Remote("putResource")];
+			_setBookKind_decorators = [Remote("setBookKind")];
+			_moveResource_decorators = [Remote("moveResource")];
+			_removeResource_decorators = [Remote("removeResource")];
+			_getRoadmap_decorators = [Remote("getRoadmap")];
+			_adoptRoadmap_decorators = [Remote("adoptRoadmap")];
+			_discardDraft_decorators = [Remote("discardDraft")];
+			_markNodeRead_decorators = [Remote("markNodeRead")];
+			_listPages_decorators = [Remote("listPages")];
+			_readPagePhoto_decorators = [Remote("readPagePhoto")];
+			_savePhoto_decorators = [Remote("savePhoto")];
+			_recordPage_decorators = [Remote("recordPage")];
+			_listCards_decorators = [Remote("listCards")];
+			_dueCards_decorators = [Remote("dueCards")];
+			_writeCards_decorators = [Remote("writeCards")];
+			_editCard_decorators = [Remote("editCard")];
+			_undoCards_decorators = [Remote("undoCards")];
+			_reviewCard_decorators = [Remote("reviewCard")];
+			_listAssessments_decorators = [Remote("listAssessments")];
+			_getAssessment_decorators = [Remote("getAssessment")];
+			_putAttempt_decorators = [Remote("putAttempt")];
+			_listAttempts_decorators = [Remote("listAttempts")];
+			_boundTarget_decorators = [Remote("boundTarget")];
+			_bindTarget_decorators = [Remote("bindTarget")];
+			_listEvents_decorators = [Remote("listEvents")];
+			_recentChanges_decorators = [Remote("recentChanges")];
+			_createRetake_decorators = [Remote("createRetake")];
+			_recentRecords_decorators = [Remote("recentRecords")];
+			_latestActivity_decorators = [Remote("latestActivity")];
+			_stats_decorators = [Remote("stats")];
+			__esDecorate(this, null, _capabilities_decorators, {
+				kind: "method",
+				name: "capabilities",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "capabilities" in obj,
+					get: (obj) => obj.capabilities
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _listProjects_decorators, {
+				kind: "method",
+				name: "listProjects",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "listProjects" in obj,
+					get: (obj) => obj.listProjects
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _getProject_decorators, {
+				kind: "method",
+				name: "getProject",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "getProject" in obj,
+					get: (obj) => obj.getProject
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _createProject_decorators, {
+				kind: "method",
+				name: "createProject",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "createProject" in obj,
+					get: (obj) => obj.createProject
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _updateProject_decorators, {
+				kind: "method",
+				name: "updateProject",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "updateProject" in obj,
+					get: (obj) => obj.updateProject
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _deleteProject_decorators, {
+				kind: "method",
+				name: "deleteProject",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "deleteProject" in obj,
+					get: (obj) => obj.deleteProject
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _getResource_decorators, {
+				kind: "method",
+				name: "getResource",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "getResource" in obj,
+					get: (obj) => obj.getResource
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _listResources_decorators, {
+				kind: "method",
+				name: "listResources",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "listResources" in obj,
+					get: (obj) => obj.listResources
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _putResource_decorators, {
+				kind: "method",
+				name: "putResource",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "putResource" in obj,
+					get: (obj) => obj.putResource
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _setBookKind_decorators, {
+				kind: "method",
+				name: "setBookKind",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "setBookKind" in obj,
+					get: (obj) => obj.setBookKind
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _moveResource_decorators, {
+				kind: "method",
+				name: "moveResource",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "moveResource" in obj,
+					get: (obj) => obj.moveResource
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _removeResource_decorators, {
+				kind: "method",
+				name: "removeResource",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "removeResource" in obj,
+					get: (obj) => obj.removeResource
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _getRoadmap_decorators, {
+				kind: "method",
+				name: "getRoadmap",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "getRoadmap" in obj,
+					get: (obj) => obj.getRoadmap
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _adoptRoadmap_decorators, {
+				kind: "method",
+				name: "adoptRoadmap",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "adoptRoadmap" in obj,
+					get: (obj) => obj.adoptRoadmap
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _discardDraft_decorators, {
+				kind: "method",
+				name: "discardDraft",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "discardDraft" in obj,
+					get: (obj) => obj.discardDraft
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _markNodeRead_decorators, {
+				kind: "method",
+				name: "markNodeRead",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "markNodeRead" in obj,
+					get: (obj) => obj.markNodeRead
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _listPages_decorators, {
+				kind: "method",
+				name: "listPages",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "listPages" in obj,
+					get: (obj) => obj.listPages
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _readPagePhoto_decorators, {
+				kind: "method",
+				name: "readPagePhoto",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "readPagePhoto" in obj,
+					get: (obj) => obj.readPagePhoto
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _savePhoto_decorators, {
+				kind: "method",
+				name: "savePhoto",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "savePhoto" in obj,
+					get: (obj) => obj.savePhoto
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _recordPage_decorators, {
+				kind: "method",
+				name: "recordPage",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "recordPage" in obj,
+					get: (obj) => obj.recordPage
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _listCards_decorators, {
+				kind: "method",
+				name: "listCards",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "listCards" in obj,
+					get: (obj) => obj.listCards
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _dueCards_decorators, {
+				kind: "method",
+				name: "dueCards",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "dueCards" in obj,
+					get: (obj) => obj.dueCards
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _writeCards_decorators, {
+				kind: "method",
+				name: "writeCards",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "writeCards" in obj,
+					get: (obj) => obj.writeCards
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _editCard_decorators, {
+				kind: "method",
+				name: "editCard",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "editCard" in obj,
+					get: (obj) => obj.editCard
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _undoCards_decorators, {
+				kind: "method",
+				name: "undoCards",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "undoCards" in obj,
+					get: (obj) => obj.undoCards
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _reviewCard_decorators, {
+				kind: "method",
+				name: "reviewCard",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "reviewCard" in obj,
+					get: (obj) => obj.reviewCard
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _listAssessments_decorators, {
+				kind: "method",
+				name: "listAssessments",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "listAssessments" in obj,
+					get: (obj) => obj.listAssessments
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _getAssessment_decorators, {
+				kind: "method",
+				name: "getAssessment",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "getAssessment" in obj,
+					get: (obj) => obj.getAssessment
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _putAttempt_decorators, {
+				kind: "method",
+				name: "putAttempt",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "putAttempt" in obj,
+					get: (obj) => obj.putAttempt
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _listAttempts_decorators, {
+				kind: "method",
+				name: "listAttempts",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "listAttempts" in obj,
+					get: (obj) => obj.listAttempts
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _boundTarget_decorators, {
+				kind: "method",
+				name: "boundTarget",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "boundTarget" in obj,
+					get: (obj) => obj.boundTarget
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _bindTarget_decorators, {
+				kind: "method",
+				name: "bindTarget",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "bindTarget" in obj,
+					get: (obj) => obj.bindTarget
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _listEvents_decorators, {
+				kind: "method",
+				name: "listEvents",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "listEvents" in obj,
+					get: (obj) => obj.listEvents
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _recentChanges_decorators, {
+				kind: "method",
+				name: "recentChanges",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "recentChanges" in obj,
+					get: (obj) => obj.recentChanges
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _createRetake_decorators, {
+				kind: "method",
+				name: "createRetake",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "createRetake" in obj,
+					get: (obj) => obj.createRetake
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _recentRecords_decorators, {
+				kind: "method",
+				name: "recentRecords",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "recentRecords" in obj,
+					get: (obj) => obj.recentRecords
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _latestActivity_decorators, {
+				kind: "method",
+				name: "latestActivity",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "latestActivity" in obj,
+					get: (obj) => obj.latestActivity
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _stats_decorators, {
+				kind: "method",
+				name: "stats",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "stats" in obj,
+					get: (obj) => obj.stats
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static inject = ["library"];
+		constructor(ctx, _config = {}) {
+			super(ctx, "libraryRemote", { namespace: "library" });
+			__runInitializers(this, _instanceExtraInitializers);
+		}
+		/** The service core this face delegates to. */
+		get core() {
+			return this.ctx.library;
+		}
+		/** What this composition can do: storage and attachments, with the reason — the display contract. */
+		capabilities() {
+			return this.core.capabilities();
+		}
+		/** Every project with its shelf progress and card tallies. */
+		listProjects() {
+			return this.core.listProjects();
+		}
+		/** One project's summary plus its resources. */
+		getProject(request) {
+			return this.core.getProject(request);
+		}
+		/** Create a project. */
+		createProject(request) {
+			return this.core.createProject(request);
+		}
+		/** Change a project's look, goal or name. */
+		updateProject(request) {
+			return this.core.updateProject(request);
+		}
+		/** Delete a project and everything it holds. */
+		deleteProject(request) {
+			return this.core.deleteProject(request);
+		}
+		/** One shelf entry, whole. */
+		getResource(request) {
+			return this.core.getResource(request);
+		}
+		/** A project's shelf: textbooks in study order, then links oldest first. */
+		listResources(request) {
+			return this.core.listResources(request);
+		}
+		/** Put one entry on the shelf (a thin link from the sidebar's add form). */
+		putResource(request) {
+			return this.core.putResource(request);
+		}
+		/** Switch a textbook between 知识型 and 材料型. */
+		setBookKind(request) {
+			return this.core.setBookKind(request);
+		}
+		/** Move a textbook to another place in the study order. */
+		moveResource(request) {
+			return this.core.moveResource(request);
+		}
+		/** Remove a shelf entry (its cards stay, unhung). */
+		removeResource(request) {
+			return this.core.removeResource(request);
+		}
+		/** One textbook's adopted roadmap and its pending draft. */
+		getRoadmap(request) {
+			return this.core.getRoadmap(request);
+		}
+		/** The learner's 采用. */
+		adoptRoadmap(request) {
+			return this.core.adoptRoadmap(request);
+		}
+		/** Drop a draft. */
+		discardDraft(request) {
+			return this.core.discardDraft(request);
+		}
+		/** 「读完」 a read node. */
+		markNodeRead(request) {
+			return this.core.markNodeRead(request);
+		}
+		/** One resource's pages, optionally one node's. */
+		listPages(request) {
+			return this.core.listPages(request);
+		}
+		/** One page's photo, base64 — whitelisted to recorded pages. */
+		readPagePhoto(request) {
+			return this.core.readPagePhoto(request);
+		}
+		/** Save a browser-uploaded photo into the attachment store. */
+		savePhoto(request) {
+			return this.core.savePhoto(request);
+		}
+		/** Record a recognized page and card its marks. */
+		recordPage(request) {
+			return this.core.recordPage(request);
+		}
+		/** Cards, filtered and sorted. */
+		listCards(request) {
+			return this.core.listCards(request);
+		}
+		/** Due cards across projects (or one). */
+		dueCards(request) {
+			return this.core.dueCards(request);
+		}
+		/** Record cards by hand. */
+		writeCards(request) {
+			return this.core.writeCards(request);
+		}
+		/** Edit one card. */
+		editCard(request) {
+			return this.core.editCard(request);
+		}
+		/** The toast's 撤销. */
+		undoCards(request) {
+			return this.core.undoCards(request);
+		}
+		/** One flashcard review. */
+		reviewCard(request) {
+			return this.core.reviewCard(request);
+		}
+		/** A project's assessments, optionally one resource's / node's / one type's. */
+		listAssessments(request) {
+			return this.core.listAssessments(request);
+		}
+		/** One assessment, whole. */
+		getAssessment(request) {
+			return this.core.getAssessment(request);
+		}
+		/** Grade a sitting answered in the sidebar (choice / fill judged in the page). */
+		putAttempt(request) {
+			return this.core.putAttempt(request);
+		}
+		/** A project's graded sittings, newest first; `nodeId` narrows to one station's history, `assessmentId` to one assessment's. */
+		listAttempts(request) {
+			return this.core.listAttempts(request);
+		}
+		/** The calling session's binding, or null. */
+		async boundTarget(sessionId) {
+			return this.core.getBinding(String(sessionId)) ?? null;
+		}
+		/** Bind the calling session to a project / resource (null unbinds). */
+		bindTarget(sessionId, request) {
+			return this.core.setBinding(String(sessionId), request.binding);
+		}
+		/** One project's audit trail, newest first. */
+		listEvents(request) {
+			return this.core.listEvents(request);
+		}
+		/** 「教练最近记下」 across projects. */
+		/** The newest knowledge-point state changes (今日 「最近的变化」). */
+		recentChanges(request) {
+			return this.core.recentChanges(request);
+		}
+		/** 订正: a retake paper over a station's open misses (all, or the keys named). */
+		createRetake(request) {
+			return this.core.createRetake(request);
+		}
+		recentRecords(request) {
+			return this.core.recentRecords(request);
+		}
+		/** The newest event's timestamp anywhere — the pane polls it to re-read (no push channel). */
+		latestActivity() {
+			return this.core.latestActivity();
+		}
+		/** The whole-library tally. */
+		stats() {
+			return this.core.stats();
+		}
+	};
+})();
+//#endregion
+//#region lib/types/index.js
+/** Cordis plugin name used by loader diagnostics. */
+const name = "library";
+/**
+* Plugin body: provide the service core, then mount the Remote data face.
+*
+* No `static inject`: every optional capability (`attachments`) is probed at
+* the point of use, so the row boots in any composition and degrades —
+* `unavailable`/`storage-unavailable` refusals instead of a boot failure.
+*
+* @param ctx - owning Cordis context.
+* @param config - optional plugin config.
+*/
+function apply(ctx, config = {}) {
+	const service = new LibraryService(ctx, config);
+	ctx.provide("library", service);
+	ctx.plugin(LibraryRemoteService, {});
+	service.store.migrateState().catch((error) => {
+		ctx.logger.warn(`library: state migration did not run — ${libraryErrorMessage(error)}`);
+	});
+}
+//#endregion
+export { DEFAULT_PASS_RATIO, LEITNER_INTERVAL_DAYS, LIBRARY_COLORS, LIBRARY_EVENT_TYPES, LIBRARY_ICONS, LIBRARY_ID_PATTERN, LIBRARY_RESOURCE_KINDS, LIBRARY_RESOURCE_ORIGINS, LIBRARY_STATE_VERSION, LibraryDisposedError, LibraryRemoteService, LibraryService, LibraryStore, LibraryStoreError, MAX_BOX, MAX_WEAKNESS, NEAR_DUPLICATE, STATE_ROOT_SEGMENT, TEMPLATE_LOOK, acceptanceLines, acquireLibraryLock, apply, assertLibraryId, cardKey, cardKeys, cardMatchesQuery, coverKind, coverTopic, coversVerbatimBlocker, emptyLibraryIndex, exactMatch, formatLocator, isLibraryId, isThickResource, keySimilarity, leitnerDueAt, libraryErrorMessage, mintLibraryId, name, nearMatches, normalizeAssessment, normalizeAttachmentRef, normalizeAttempt, normalizeBindings, normalizeCard, normalizeEvent, normalizeLibraryIndex, normalizeNodeCover, normalizePage, normalizeProject, normalizeResource, normalizeRoadmap, parseLocator, resolveLibraryStateRoot, unlockReady, validateRoadmapShape };