@khorsheed/dsh-reader 0.3.0 → 0.3.2

package/lib/index.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
-import { mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { execFile, spawn } from "node:child_process";
 import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 //#region lib/types/types.js
 /**
@@ -86,6 +87,67 @@ const MAX_TOTAL_BODY_CHARS = 12582912;
 */
 const INLINE_BODY_MAX_CHARS = 262144;
 /**
+* Hosts that bounce every first visit through a cookie handshake, not a login.
+*
+* Springer Nature answers a cookie-less request with a 303 to
+* `idp.<brand>/authorize?response_type=cookie`, which mints a one-time code and
+* sends the browser back to the article (measured 2026-10-04 on
+* link.springer.com and www.nature.com). The host fetch does not follow the
+* cross-origin hop and keeps no cookies, so the plain fetch can never finish
+* it; a headless browser does (the rendered fetch read the full EPJ Data
+* Science article). The `idp` name alone would read as a login wall.
+*/
+const COOKIE_HANDSHAKE_HOSTS = /* @__PURE__ */ new Set(["idp.springer.com", "idp.nature.com"]);
+/**
+* Whether a fetch failure is a cross-origin hop into a known cookie handshake.
+*
+* @param message - the seam's recorded failure message.
+* @returns true when the failure is the handshake, which a browser completes.
+*/
+function isCookieHandshake(message) {
+	const origin = /cross-origin redirect to (\S+)/i.exec(message)?.[1];
+	if (origin === void 0) return false;
+	try {
+		return COOKIE_HANDSHAKE_HOSTS.has(new URL(origin).hostname.toLowerCase());
+	} catch {
+		return false;
+	}
+}
+/**
+* The article a challenge page stands in front of, when its URL names it.
+*
+* A bot wall usually redirects to its own page and carries the original in a
+* query parameter (mp.weixin.qq.com → `/mp/wappoc_appmsgcaptcha?…&target_url=`).
+* Builds before 2026-10-04 saved that landing URL as the link itself, which
+* then titled the card and was what every retry — the rendered fetch included
+* — asked for; the state normalizer walks such a link back with this.
+*
+* @param url - a stored link.
+* @returns the http(s) target, or `undefined` when the URL is not a challenge landing.
+*/
+function challengeTarget(url) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		return;
+	}
+	if (!/captcha|challenge/i.test(parsed.pathname)) return void 0;
+	for (const key of [
+		"target_url",
+		"targetUrl",
+		"return_url",
+		"redirect_url"
+	]) {
+		const value = parsed.searchParams.get(key);
+		if (value === null) continue;
+		try {
+			const target = new URL(value);
+			if (target.protocol === "https:" || target.protocol === "http:") return target.toString();
+		} catch {}
+	}
+}
+/**
 * Build a display label for a source from its URL: the registrable-ish host
 * plus the last meaningful path segment, which is what distinguishes several
 * feeds from one publisher.
@@ -274,11 +336,14 @@ function normalizeStateDoc(value) {
 	const record = value;
 	const sources = Array.isArray(record.sources) ? record.sources : [];
 	const refresh = typeof record.refresh === "object" && record.refresh !== null ? record.refresh : {};
+	const seenIds = /* @__PURE__ */ new Set();
 	return {
 		version: 1,
 		sources: sources.flatMap((item) => {
 			const source = normalizeSource(item);
-			return source === void 0 ? [] : [source];
+			if (source === void 0 || seenIds.has(source.id)) return [];
+			seenIds.add(source.id);
+			return [source];
 		}),
 		refresh: {
 			enabled: refresh.enabled !== false,
@@ -426,7 +491,8 @@ function normalizeAnnotations(value) {
 		const tagIds = Array.isArray(record.tagIds) ? [...new Set(record.tagIds.filter((id) => typeof id === "string" && id.length > 0))] : [];
 		const fetch = normalizeFetch(record.fetch);
 		const translation = normalizeTranslation(record.translation);
-		const failureCode = PREVIEW_FAILURE_CODES.has(String(record.failureCode)) ? record.failureCode : void 0;
+		const storedFailureCode = PREVIEW_FAILURE_CODES.has(String(record.failureCode)) ? record.failureCode : void 0;
+		const failureCode = storedFailureCode === "login" && typeof record.error === "string" && isCookieHandshake(record.error) ? "blocked" : storedFailureCode;
 		const annotation = {
 			...body === void 0 ? {} : { body },
 			...fetch === void 0 ? {} : { fetch },
@@ -488,16 +554,20 @@ function normalizeSource(value) {
 	if (typeof value !== "object" || value === null) return void 0;
 	const record = value;
 	const id = typeof record.id === "string" ? record.id : void 0;
-	const url = typeof record.url === "string" ? record.url : void 0;
-	if (id === void 0 || url === void 0) return void 0;
+	const storedUrl = typeof record.url === "string" ? record.url : void 0;
+	if (id === void 0 || storedUrl === void 0) return void 0;
 	const kind = record.kind === "link" ? "link" : "rss";
+	const target = kind === "link" ? challengeTarget(storedUrl) : void 0;
+	const url = target ?? storedUrl;
+	const storedLabel = typeof record.label === "string" && record.label.length > 0 ? record.label : void 0;
+	const label = target !== void 0 && (storedLabel === void 0 || storedLabel === defaultSourceLabel(storedUrl)) ? defaultSourceLabel(target) : storedLabel ?? url;
 	const status = record.status === "ok" || record.status === "fetching" || record.status === "error" ? record.status : void 0;
 	const failure = normalizePreviewFailure(record.failure);
 	return {
 		id,
 		kind,
 		url,
-		label: typeof record.label === "string" && record.label.length > 0 ? record.label : url,
+		label,
 		enabled: record.enabled !== false,
 		addedAt: typeof record.addedAt === "string" ? record.addedAt : (/* @__PURE__ */ new Date(0)).toISOString(),
 		...typeof record.fetchedAt === "string" ? { fetchedAt: record.fetchedAt } : {},
@@ -525,9 +595,10 @@ function normalizePreviewFailure(value) {
 	const record = value;
 	const code = record.code;
 	if (typeof code !== "string" || !PREVIEW_FAILURE_CODES.has(code)) return void 0;
+	const message = typeof record.message === "string" ? record.message.slice(0, 500) : "";
 	return {
-		code,
-		message: typeof record.message === "string" ? record.message.slice(0, 500) : "",
+		code: code === "login" && isCookieHandshake(message) ? "blocked" : code,
+		message,
 		at: typeof record.at === "string" ? record.at : (/* @__PURE__ */ new Date(0)).toISOString()
 	};
 }
@@ -628,7 +699,7 @@ var ReaderStore = class {
 			renameSync(temporary, target);
 		} catch (error) {
 			rmSync(temporary, { force: true });
-			throw new ReaderStoreError(`reader: ${target} could not be written — ${errorMessage$1(error)}`, "io");
+			throw new ReaderStoreError(`reader: ${target} could not be written — ${errorMessage$2(error)}`, "io");
 		}
 		return name;
 	}
@@ -654,7 +725,7 @@ var ReaderStore = class {
 			renameSync(temporary, target);
 		} catch (error) {
 			rmSync(temporary, { force: true });
-			throw new ReaderStoreError(`reader: ${target} could not be written — ${errorMessage$1(error)}`, "io");
+			throw new ReaderStoreError(`reader: ${target} could not be written — ${errorMessage$2(error)}`, "io");
 		}
 		return name;
 	}
@@ -727,7 +798,7 @@ var ReaderStore = class {
 			mkdirSync(this.stateRoot, { recursive: true });
 			return true;
 		} catch (error) {
-			this.unwritable = `${this.stateRoot}: ${errorMessage$1(error)}`;
+			this.unwritable = `${this.stateRoot}: ${errorMessage$2(error)}`;
 			return false;
 		}
 	}
@@ -750,7 +821,7 @@ var ReaderStore = class {
 				doc: emptyStateDoc(),
 				version: null
 			};
-			throw new ReaderStoreError(`reader: ${this.file} could not be read — ${errorMessage$1(error)}`, "io");
+			throw new ReaderStoreError(`reader: ${this.file} could not be read — ${errorMessage$2(error)}`, "io");
 		}
 		try {
 			return {
@@ -780,7 +851,7 @@ var ReaderStore = class {
 			renameSync(temporary, this.file);
 		} catch (error) {
 			rmSync(temporary, { force: true });
-			throw new ReaderStoreError(`reader: ${this.file} could not be written — ${errorMessage$1(error)}`, "io");
+			throw new ReaderStoreError(`reader: ${this.file} could not be written — ${errorMessage$2(error)}`, "io");
 		}
 		const text = serializeStateDoc(doc);
 		return String(text.length) + ":" + String(statSync(this.file).mtimeMs);
@@ -816,7 +887,7 @@ function isMissing(error) {
 	return error?.code === "ENOENT";
 }
 /** A native fs failure's message, with its code, for the wire. */
-function errorMessage$1(error) {
+function errorMessage$2(error) {
 	const code = error?.code;
 	const message = error instanceof Error ? error.message : String(error);
 	return code === void 0 ? message : `${code}: ${message}`;
@@ -1169,6 +1240,104 @@ function arxivHtmlUrl(url) {
 	if (link === void 0 || link.kind === "html") return void 0;
 	return `https://arxiv.org/html/${link.id}`;
 }
+//#endregion
+//#region lib/types/document-fetch.js
+/**
+* The document fetcher: the reader's own instance of the official HTTP fetch
+* provider, so feeds and article pages arrive as the origin served them.
+*
+* Why not `ctx.web.fetch` alone: the seam runs whichever provider the host
+* selects, and from 0.2.1-rc.2 the web-search settings switch for the DeepSeek
+* Search/Fetch API moves `web.fetchProvider` too. That provider answers
+* Markdown (`body.kind: 'text'`), a constant 200, and the request URL as the
+* final URL — so `classifyPayload` reads every feed as a page, the extractor
+* gets no HTML, and the cross-origin redirect handling never fires. The
+* request carries only a URL; no caller can ask for the HTTP provider (seam
+* registry S22).
+*
+* So when the mounted `web` is the official service (it carries
+* `registerFetchProvider`), the reader fetches through its own
+* `HttpFetchProvider` — the same class the default `http` row registers, with
+* that row's default limits, so the policy (public addresses only, connection
+* pinned, same-origin redirects, charset decoding) and the errors
+* (`WEB_REDIRECT_BLOCKED` naming the target origin) are exactly today's.
+* `ctx.web` stays the permission: without it nothing is fetched. A host
+* without the provider package (or any other `web` shape, such as a test's
+* plain `{ fetch }`) is fetched through as before.
+*
+* Retire when the seam lets one request name its provider (S22).
+*
+* @module @khorsheed/dsh-reader/document-fetch
+*/
+/**
+* The reader's own fetch limits: the `http` row's defaults
+* (`@deepseek-ai/dsh-web-fetch-http` Config, 0.1.5 through 0.2.1-rc.3) except
+* `maxBodyChars`. The row's 100 000 is sized for a page handed to a model; the
+* reader extracts the article itself from the raw HTML, and a modern page
+* carries several hundred KB of inline script before its last paragraph
+* (measured: claude.com's articles, 620 KB, cut mid-sentence at 100 000). 2 000 000
+* is what deployments ran the row at while the reader still fetched through
+* it, and the per-source storage budget (`MAX_BODY_CHARS_PER_SOURCE`) is
+* sized to match. A deployment changes these with the reader's own
+* `fetchLimits`: the row's config does not reach this instance.
+*/
+const DOCUMENT_FETCH_DEFAULTS = {
+	maxResponseBytes: 5e6,
+	maxBodyChars: 2e6,
+	timeoutMs: 3e4,
+	maxRedirects: 5
+};
+/** Whether a mounted `web` is the official service rather than some other shape. */
+function isOfficialWebService(web) {
+	return typeof web?.registerFetchProvider === "function";
+}
+const loadOfficialProvider = () => import("@deepseek-ai/dsh-web-fetch-http").then((module) => module, () => void 0);
+/**
+* Pick the fetcher for raw documents.
+*
+* Built once per service: the first fetch on an official web service loads
+* the provider package and keeps the instance; a failed load is remembered
+* too, and every later fetch goes through the seam.
+*/
+var DocumentFetch = class {
+	web;
+	limits;
+	load;
+	provider;
+	/**
+	* @param web - the probed web seam, read on every call (it may come and go).
+	* @param limits - the reader's configured fetch limits, over the defaults.
+	* @param load - the provider package loader (tests inject one).
+	*/
+	constructor(web, limits = {}, load = loadOfficialProvider) {
+		this.web = web;
+		this.limits = limits;
+		this.load = load;
+	}
+	/**
+	* The fetcher for this call, or undefined when no web capability is mounted.
+	* @returns the reader's own provider on an official web service, else the seam itself.
+	*/
+	async current() {
+		const web = this.web();
+		if (web === void 0 || web === null) return void 0;
+		const seam = web;
+		if (!isOfficialWebService(web)) return seam;
+		this.provider ??= this.load().then((module) => {
+			if (module === void 0 || typeof module.HttpFetchProvider !== "function") return void 0;
+			try {
+				return new module.HttpFetchProvider({
+					...DOCUMENT_FETCH_DEFAULTS,
+					...this.limits,
+					userAgent: module.DEFAULT_USER_AGENT ?? "deepseek-harness/0.0.1 (+https://github.com/deepseek-ai)"
+				});
+			} catch {
+				return;
+			}
+		});
+		return await this.provider ?? seam;
+	}
+};
 /** An honest agent line — bot walls are reported, never impersonated around. */
 const IMAGE_FETCH_USER_AGENT = "dsh-reader image rescue (+https://github.com/Khorsheed/dsh-plugins)";
 /**
@@ -1837,103 +2006,1632 @@ async function resolveLink(url, fetch) {
 	for (const resolver of LINK_RESOLVERS) if (resolver.match(parsed)) return resolver.resolve(parsed, fetch);
 	return null;
 }
-/** Cross-origin redirect hops the service will follow before giving up. */
-const MAX_REDIRECT_HOPS = 3;
-/** Upper bound on summaries handed to the browser in one call. */
-const SUMMARY_LIMIT = 500;
-/** How many sentence hashes one memory-slice read answers (the table never crosses). */
-const TRANSLATION_SLICE_LIMIT = 2e3;
-/** How many sentences one write batch may carry (a long article is ~500). */
-const TRANSLATION_WRITE_LIMIT = 2e3;
-/** One sentence's source or translation is never longer than a few paragraphs. */
-const TRANSLATION_TEXT_LIMIT = 4e3;
-/** Thrown when a payload cannot become a source. */
-var UnsupportedContent = class extends Error {};
+//#endregion
+//#region lib/types/captions.js
 /**
-* Whether a failed fetch is the HTML endpoint's "this paper has no HTML
-* version" — a bare 404 from the content fetch, and nothing else. A refusal
-* (403/401) or a transport error is a fact about the REQUEST, not about which
-* face of the paper exists, and must not silently reroute to another page.
+* Captions → the transcript a video or audio entry reads as.
+*
+* Every platform's caption file is parsed into the same flat cue list (start,
+* end, text), merged into paragraphs a person can read (sentence ends, pauses,
+* a length cap), and rendered as article markup where each paragraph carries
+* its start time. The markup is the entry's body: notes, highlights,
+* translation and the model's ¶ numbering all work on it unchanged, and the
+* player reads `data-t` to seek.
+*
+* Pure: no fs, no network — the formats are measured on real files and pinned
+* by the specs.
+*
+* @module @khorsheed/dsh-reader/captions
 */
-function isNoHtmlVersion(error) {
-	return error instanceof UnsupportedContent && error.message === "HTTP 404";
+/** Collapse whitespace and strip the markup some caption files carry. */
+function clean(text) {
+	return text.replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&#39;/g, "'").replace(/&quot;/g, "\"").replace(/\s+/g, " ").trim();
+}
+/** Seconds from `hh:mm:ss.mmm` / `mm:ss.mmm` / `hh:mm:ss,mmm`. */
+function clock(value) {
+	const parts = value.trim().replace(",", ".").split(":").map(Number);
+	if (parts.some((part) => !Number.isFinite(part))) return NaN;
+	return parts.reduce((total, part) => total * 60 + part, 0);
 }
 /**
-* Classify a fetched payload as a feed or an article page.
-*
-* The decision comes from the CONTENT, not from asking the user: nobody pasting
-* a URL can be expected to know whether it is a feed, and guessing wrong used
-* to mean silently creating an empty subscription.
+* YouTube's `json3` captions: `events[]` with `tStartMs`, `dDurationMs` and
+* `segs[].utf8`. Auto captions also carry `aAppend` newline events and
+* word-level `tOffsetMs`; only whole events become cues.
+*/
+function parseJson3(raw) {
+	const data = JSON.parse(raw);
+	const cues = [];
+	for (const event of data.events ?? []) {
+		if (event.segs === void 0 || event.aAppend === 1) continue;
+		const text = clean(event.segs.map((seg) => seg.utf8 ?? "").join(""));
+		if (text === "") continue;
+		const startMs = event.tStartMs ?? 0;
+		cues.push({
+			start: startMs / 1e3,
+			end: (startMs + (event.dDurationMs ?? 0)) / 1e3,
+			text
+		});
+	}
+	return cues;
+}
+/**
+* WebVTT. YouTube's auto captions in VTT are ROLLING: each cue repeats the
+* previous line and adds the next, with inline word timings. The rolling
+* duplicates are dropped by keeping only the text a cue adds over the one
+* before it.
+*/
+function parseVtt(raw) {
+	const blocks = raw.replace(/\r/g, "").split(/\n\n+/);
+	const cues = [];
+	let previous = "";
+	for (const block of blocks) {
+		const lines = block.split("\n");
+		const timing = lines.findIndex((line) => line.includes("-->"));
+		if (timing < 0) continue;
+		const [from, to] = lines[timing].split("-->");
+		const start = clock(from ?? "");
+		const end = clock((to ?? "").trim().split(/\s+/)[0] ?? "");
+		if (!Number.isFinite(start)) continue;
+		const textLines = lines.slice(timing + 1).map((line) => clean(line)).filter((line) => line !== "");
+		let text = textLines.join(" ");
+		if (text === "") continue;
+		if (previous !== "" && text.startsWith(previous)) text = text.slice(previous.length).trim();
+		else if (textLines.length > 1 && textLines[0] === previous) text = textLines.slice(1).join(" ");
+		previous = textLines[textLines.length - 1] ?? previous;
+		if (text === "" || cues.length > 0 && cues[cues.length - 1].text === text) continue;
+		cues.push({
+			start,
+			end: Number.isFinite(end) ? end : start,
+			text
+		});
+	}
+	return cues;
+}
+/** SubRip (`.srt`). */
+function parseSrt(raw) {
+	const cues = [];
+	for (const block of raw.replace(/\r/g, "").split(/\n\n+/)) {
+		const lines = block.split("\n");
+		const timing = lines.findIndex((line) => line.includes("-->"));
+		if (timing < 0) continue;
+		const [from, to] = lines[timing].split("-->");
+		const start = clock(from ?? "");
+		const end = clock(to ?? "");
+		const text = clean(lines.slice(timing + 1).join(" "));
+		if (!Number.isFinite(start) || text === "") continue;
+		cues.push({
+			start,
+			end: Number.isFinite(end) ? end : start,
+			text
+		});
+	}
+	return cues;
+}
+/** Bilibili's subtitle JSON: `body[]` with `from`, `to`, `content` (seconds). */
+function parseBiliJson(raw) {
+	return (JSON.parse(raw).body ?? []).flatMap((item) => {
+		const text = clean(item.content ?? "");
+		if (text === "" || typeof item.from !== "number") return [];
+		return [{
+			start: item.from,
+			end: typeof item.to === "number" ? item.to : item.from,
+			text
+		}];
+	});
+}
+/**
+* Parse a caption file by its extension (the one yt-dlp wrote).
 *
-* @param raw - the decoded payload.
-* @returns which kind of source this payload can become.
+* @param raw - the file's text.
+* @param ext - `json3`, `vtt`, `srt` or `json`.
 */
-function classifyPayload(raw) {
-	const head = raw.slice(0, 512).trimStart().toLowerCase();
-	if (head.startsWith("<?xml")) return "feed";
-	if (/^<rss[\s>]/.test(head)) return "feed";
-	if (/^<feed[\s>]/.test(head)) return "feed";
-	if (/^<rdf:rdf[\s>]/.test(head)) return "feed";
-	return "page";
+function parseCaptions(raw, ext) {
+	switch (ext.toLowerCase()) {
+		case "json3": return parseJson3(raw);
+		case "vtt": return parseVtt(raw);
+		case "srt": return parseSrt(raw);
+		case "json": return parseBiliJson(raw);
+		default: return [];
+	}
 }
-/** The reader service. */
-var ReaderService = class {
-	store;
-	ctx;
-	timer;
-	disposed = false;
-	/** The document of record when no filesystem is mounted. */
-	memoryDoc;
-	/** Rescued images, by URL — a pane remount re-fails every blocked image, and this is what keeps that a memory read. */
-	imageCache = new ImageFetchCache();
+/** True when a line ends a sentence (Latin or CJK punctuation). */
+function endsSentence(text) {
+	return /[.!?。！？…]["'”’）)]?$/.test(text);
+}
+/** True for text that is mostly CJK (joined without spaces). */
+function isCjk(text) {
+	return /[㐀-鿿]/.test(text);
+}
+/** The merge rules (exported for the specs). */
+const MERGE = {
+	/** A paragraph closes at a sentence end once it is at least this long (seconds). */
+	minSeconds: 15,
+	/** …and always closes past this length, sentence end or not. */
+	maxSeconds: 60,
+	/** A pause this long between cues closes the paragraph too. */
+	pauseSeconds: 2.5,
 	/**
-	* @param ctx - owning context.
-	* @param config - optional state-root override.
+	* Unpunctuated captions (YouTube's automatic ones carry no punctuation at
+	* all — measured 2026-10-20): close at the first pause of this length once
+	* the paragraph has run {@link MERGE.bareMinSeconds}, and always by
+	* {@link MERGE.bareMaxSeconds}.
 	*/
-	constructor(ctx, config = {}) {
-		this.ctx = ctx;
-		this.store = new ReaderStore(config);
-		ctx.effect(() => () => {
-			this.disposed = true;
-			if (this.timer !== void 0) clearTimeout(this.timer);
-		}, "reader: daily refresh");
-		this.armSchedule();
+	barePauseSeconds: .7,
+	bareMinSeconds: 15,
+	bareMaxSeconds: 35,
+	/** Below this share of sentence-ending cues, captions count as unpunctuated. */
+	punctuatedShare: .1
+};
+/**
+* Merge caption cues into readable paragraphs.
+*
+* Punctuated captions close a paragraph at a sentence end once it has run
+* {@link MERGE.minSeconds}, at a pause of {@link MERGE.pauseSeconds}, or past
+* {@link MERGE.maxSeconds}. Unpunctuated ones have no sentence ends to use, so
+* they close at a short pause past {@link MERGE.bareMinSeconds} — short enough
+* to point at, long enough to read as prose rather than subtitles.
+*
+* @param cues - the caption cues in time order.
+* @returns the paragraphs.
+*/
+function mergeCues(cues) {
+	const sorted = [...cues].sort((left, right) => left.start - right.start);
+	const punctuated = sorted.length > 0 && sorted.filter((cue) => endsSentence(cue.text)).length / sorted.length >= MERGE.punctuatedShare;
+	const segments = [];
+	let current;
+	const flush = () => {
+		if (current === void 0 || current.lines.length === 0) return;
+		const joiner = isCjk(current.lines.map((line) => line.text).join("")) ? "" : " ";
+		segments.push({
+			start: current.start,
+			end: current.end,
+			text: current.lines.map((line) => line.text).join(joiner).replace(/\s+/g, " ").trim(),
+			lines: current.lines
+		});
+		current = void 0;
+	};
+	for (let index = 0; index < sorted.length; index++) {
+		const cue = sorted[index];
+		if (current !== void 0 && cue.start - current.end >= MERGE.pauseSeconds) flush();
+		if (current === void 0) current = {
+			start: cue.start,
+			end: cue.end,
+			lines: []
+		};
+		current.lines.push({
+			start: cue.start,
+			text: cue.text
+		});
+		current.end = Math.max(current.end, cue.end);
+		const length = current.end - current.start;
+		if (punctuated) {
+			if (length >= MERGE.minSeconds && endsSentence(cue.text) || length >= MERGE.maxSeconds) flush();
+		} else {
+			const next = sorted[index + 1];
+			const gap = next === void 0 ? Infinity : next.start - cue.end;
+			if (length >= MERGE.bareMinSeconds && gap >= MERGE.barePauseSeconds || length >= MERGE.bareMaxSeconds) flush();
+		}
 	}
-	/** Capabilities the browser may rely on. */
-	async capabilities() {
-		const doc = await this.currentDoc();
+	flush();
+	return segments;
+}
+/** Escape text for HTML content. */
+function escapeHtml$1(text) {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+/**
+* The transcript as article markup: one `<p>` per paragraph, its start time in
+* `data-t` (seconds, one decimal) — the attribute the player seeks by.
+*
+* @param segments - the merged paragraphs.
+*/
+function renderTranscript(segments) {
+	return segments.map((segment) => `<p data-t="${segment.start.toFixed(1)}">${escapeHtml$1(segment.text)}</p>`).join("\n");
+}
+//#endregion
+//#region lib/types/local-transcribe.js
+/**
+* Local transcription of a video or audio entry without captions, on the
+* optional `transcribe` engine (@khorsheed/dsh-transcribe).
+*
+* Opening such an entry starts a job (2026-10-20 decision: automatic on open,
+* never on feed refresh): the audio is fetched into a temporary directory —
+* yt-dlp for a video, curl for an audio URL — handed to the engine, and the
+* finished stretches render as transcript paragraphs while it runs. A job
+* still QUEUED when the reader leaves is withdrawn; a RUNNING one finishes and
+* is stored either way (`cancel` with `force`, the 字幕 switch and the 取消
+* button, stops it). The engine's first use downloads its models: the job
+* waits for one confirmation (`needs-models`) and then runs.
+*
+* The engine is restated here structurally (no code edge between the
+* packages) and probed on every start.
+*
+* @module @khorsheed/dsh-reader/local-transcribe
+*/
+/** Sentence ends in either script. */
+const SENTENCE_END = /[。！？!?…]$|[^.\d]\.$/;
+/** A run-on sentence (SenseVoice punctuates English sparsely) closes at a comma past this long (s)… */
+const LONG_AT_COMMA_SEC = 20;
+/** …at a pause between words past this long… */
+const LONG_AT_PAUSE_SEC = 30;
+/** …and in any case by this. */
+const LONGEST_CUE_SEC = 45;
+/**
+* Engine stretches as caption-like cues: one per sentence (the engine's
+* stretches are cut at pauses, not sentence ends), so the transcript merges
+* into the same paragraphs platform captions do. A sentence that runs on
+* without a period is closed at a comma or a pause once it is long, or a
+* single cue would make a minute-and-a-half paragraph (measured 2026-10-20).
+*
+* @param segments - the engine's segments, in order.
+*/
+function cuesFromSegments(segments, speakers) {
+	const cues = [];
+	let text = "";
+	let start;
+	let end = 0;
+	let speaker;
+	const flush = () => {
+		const trimmed = text.replace(/\s+/g, " ").trim();
+		if (start !== void 0 && trimmed !== "") cues.push({
+			start,
+			end,
+			text: trimmed,
+			...speaker === void 0 ? {} : { speaker }
+		});
+		text = "";
+		start = void 0;
+	};
+	const tokens = segments.flatMap((segment) => segment.tokens);
+	for (let index = 0; index < tokens.length; index++) {
+		const token = tokens[index];
+		const voice = speakers?.[index];
+		if (voice !== void 0 && voice !== speaker) {
+			flush();
+			speaker = voice;
+		}
+		start ??= token.start;
+		text += token.text;
+		end = token.end;
+		const length = end - start;
+		const next = tokens[index + 1];
+		if (SENTENCE_END.test(text.trimEnd()) || length >= LONG_AT_COMMA_SEC && /[,，、;；]$/.test(token.text.trim()) || length >= LONG_AT_PAUSE_SEC && next !== void 0 && next.start - token.end >= .4 || length >= LONGEST_CUE_SEC) flush();
+	}
+	flush();
+	return cues;
+}
+/** A run of one voice shorter than this is the diarizer flickering, not a turn (s). */
+const MIN_TURN_SEC = 2.5;
+/**
+* Each token's speaker, as an index in order of first appearance (A, B, …):
+* the turn covering the token's middle, else the nearest one; then runs of a
+* voice shorter than {@link MIN_TURN_SEC} are folded into the voice before
+* them — a diarizer's boundary wobble would otherwise split sentences.
+*
+* @param segments - the transcript's segments.
+* @param turns - the engine's turns.
+*/
+function speakerPerToken(segments, turns) {
+	const sorted = [...turns].sort((a, b) => a.start - b.start);
+	const order = /* @__PURE__ */ new Map();
+	const tokens = segments.flatMap((segment) => segment.tokens);
+	const out = [...tokens.map((token) => {
+		const at = (token.start + token.end) / 2;
+		let best;
+		let distance = Infinity;
+		for (const turn of sorted) {
+			const d = at < turn.start ? turn.start - at : at > turn.end ? at - turn.end : 0;
+			if (d < distance) {
+				distance = d;
+				best = turn;
+			}
+			if (turn.start > at + distance) break;
+		}
+		return best?.cluster ?? -1;
+	})];
+	let runStart = 0;
+	for (let index = 1; index <= out.length; index++) {
+		if (index < out.length && out[index] === out[runStart]) continue;
+		const length = (tokens[index - 1]?.end ?? 0) - (tokens[runStart]?.start ?? 0);
+		if (runStart > 0 && length < MIN_TURN_SEC) for (let k = runStart; k < index; k++) out[k] = out[runStart - 1];
+		runStart = index;
+	}
+	for (let index = 1; index < out.length; index++) if (/^\s*[\p{P}]+\s*$/u.test(tokens[index].text)) out[index] = out[index - 1];
+	return out.map((cluster) => {
+		if (!order.has(cluster)) order.set(cluster, order.size);
+		return order.get(cluster);
+	});
+}
+/** Escape text for HTML content. */
+function escapeText(text) {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+/**
+* The transcript with its speakers: paragraphs never cross a change of voice,
+* and each carries `data-spk` (the speaker's index) beside its `data-t`.
+*/
+function renderSpeakerTranscript(segments, turns) {
+	const cues = cuesFromSegments(segments, speakerPerToken(segments, turns));
+	const out = [];
+	let run = [];
+	const flush = () => {
+		const speaker = run[0]?.speaker;
+		for (const paragraph of mergeCues(run)) out.push(`<p ${LOCAL_MARK} data-spk="${String(speaker ?? 0)}" data-t="${paragraph.start.toFixed(1)}">${escapeText(paragraph.text)}</p>`);
+		run = [];
+	};
+	for (const cue of cues) {
+		if (run.length > 0 && cue.speaker !== run[0].speaker) flush();
+		run.push(cue);
+	}
+	flush();
+	return out.join("\n");
+}
+/** The marker a locally transcribed paragraph carries (the 来源 line reads it). */
+const LOCAL_MARK = "data-src=\"local\"";
+/** The engine's segments as transcript markup, each paragraph marked local. */
+function renderLocalTranscript(segments) {
+	return renderTranscript(mergeCues(cuesFromSegments(segments))).replace(/<p data-t=/g, `<p ${LOCAL_MARK} data-t=`);
+}
+/**
+* The language to ask for: always detection (SenseVoice). Measured
+* 2026-10-20: a platform says nothing reliable about the spoken language — a
+* Bilibili upload of an English interview came out of the Chinese model as
+* lower-case English with Chinese punctuation — and on Chinese speech
+* SenseVoice reads about as well as Paraformer (a 90 s sample: each missed
+* two or three characters the other got right).
+*/
+function languageFor(_media) {
+	return "auto";
+}
+/** Fetch a URL to a file with curl (it honors the deployment's proxy environment). */
+function curlTo(url, file, signal) {
+	return new Promise((resolve, reject) => {
+		execFile("curl", [
+			"-fsSL",
+			"--retry",
+			"2",
+			"-o",
+			file,
+			url
+		], {
+			signal,
+			timeout: 18e5
+		}, (error) => {
+			if (error === null) resolve();
+			else reject(/* @__PURE__ */ new Error(`下载音频失败：${error.message.split("\n")[0] ?? ""}`));
+		});
+	});
+}
+/** A model download larger than this asks first; a small addition (the 2 MB VAD) just happens. */
+const CONFIRM_BYTES = 2e7;
+/** Share of the progress bar the audio download takes. */
+const FETCH_SHARE = .1;
+/** How often a running job writes its finished segments down (ms). */
+const SAVE_EVERY_MS = 15e3;
+/** How long a restart waits for the engine to be provided before giving up on resuming (ms). */
+const RESUME_WAIT_MS = 6e5;
+function readJson(path) {
+	try {
+		return JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return;
+	}
+}
+function writeJson(path, value) {
+	try {
+		writeFileSync(`${path}.tmp`, JSON.stringify(value));
+		renameSync(`${path}.tmp`, path);
+	} catch {}
+}
+/** The reader's local transcription jobs, by entry. */
+var LocalTranscriber = class {
+	deps;
+	jobs = /* @__PURE__ */ new Map();
+	/** Jobs a previous process left mid-way, waiting for the engine. */
+	resumable = [];
+	resumeTimer;
+	disposing = false;
+	constructor(deps) {
+		this.deps = deps;
+		try {
+			const cutoff = Date.now() - 864e5;
+			for (const name of readdirSync(deps.tmpRoot)) {
+				if (!name.startsWith("audio-")) continue;
+				const dir = join(deps.tmpRoot, name);
+				if (statSync(dir).mtimeMs < cutoff) {
+					rmSync(dir, {
+						recursive: true,
+						force: true
+					});
+					continue;
+				}
+				const record = readJson(join(dir, "job.json"));
+				if (record?.entryId !== void 0 && record.media !== void 0) this.resumable.push({
+					dir,
+					record
+				});
+				else rmSync(dir, {
+					recursive: true,
+					force: true
+				});
+			}
+		} catch {}
+		if (this.resumable.length > 0) {
+			const since = Date.now();
+			this.resumeTimer = setInterval(() => {
+				const engine = this.deps.engine();
+				if (engine === void 0 && Date.now() - since < RESUME_WAIT_MS) return;
+				clearInterval(this.resumeTimer);
+				this.resumeTimer = void 0;
+				for (const { dir, record } of this.resumable.splice(0)) {
+					if (engine === void 0 || this.jobs.has(record.entryId)) {
+						rmSync(dir, {
+							recursive: true,
+							force: true
+						});
+						continue;
+					}
+					const job = {
+						state: "queued",
+						progress: FETCH_SHARE,
+						segments: [],
+						rendered: 0,
+						abort: new AbortController()
+					};
+					this.jobs.set(record.entryId, job);
+					this.execute(record, engine, "auto", job, dir);
+				}
+			}, this.deps.resumePollMs ?? 2e3);
+			this.resumeTimer.unref?.();
+		}
+	}
+	/** An entry's job as the browser sees it. */
+	status(entryId) {
+		const job = this.jobs.get(entryId);
+		if (job === void 0) return {
+			entryId,
+			state: "idle"
+		};
+		if (job.rendered !== job.segments.length && job.state !== "done") {
+			job.html = renderLocalTranscript(job.segments);
+			job.rendered = job.segments.length;
+		}
 		return {
-			protocolVersion: 1,
-			hasFs: this.store.available,
-			...doc.lastRefreshAt === void 0 ? {} : { lastRefreshAt: doc.lastRefreshAt },
-			hasSideChat: this.sideChat() !== void 0,
-			...doc.refresh.enabled ? { nextRefreshAt: new Date(Date.now() + delayUntilNext(/* @__PURE__ */ new Date(), doc.refresh.timeOfDay)).toISOString() } : {}
+			entryId,
+			state: job.state,
+			progress: job.progress,
+			...job.ahead === void 0 ? {} : { ahead: job.ahead },
+			...job.html === void 0 ? {} : { html: job.html },
+			...job.language === void 0 ? {} : { language: job.language },
+			...job.error === void 0 ? {} : { error: job.error },
+			...job.speakers === void 0 ? {} : { speakers: job.speakers }
 		};
 	}
-	/** The source list, without payloads. */
-	async listSources() {
-		return { sources: (await this.currentDoc()).sources.slice(0, SUMMARY_LIMIT).map(summarize$1) };
-	}
 	/**
-	* Add a source, deciding what it is from what comes back.
+	* Start (or rejoin) an entry's transcription.
 	*
-	* The one rule this method exists to enforce: **a URL the reader pasted is
-	* never thrown away.** A fetch that fails, a bot challenge, a login wall and
-	* a PDF all end the same way — a `link` source that exists, carries the
-	* reason it has no previewable body, and can be opened, tagged, refreshed
-	* manually or deleted. Only a URL that cannot be a source at all
-	* (`invalid-url`) or one already present (`duplicate`) is refused.
+	* @param request - the entry, its media, and whether the model download was confirmed.
+	*/
+	async start(request) {
+		const current = this.jobs.get(request.entryId);
+		if (current !== void 0 && current.state !== "failed" && current.state !== "done") return this.status(request.entryId);
+		const engine = this.deps.engine();
+		if (engine === void 0) return {
+			entryId: request.entryId,
+			state: "unavailable"
+		};
+		const language = languageFor(request.media);
+		const bytes = await engine.missingBytes(engine.modelsFor({
+			language,
+			diarize: false
+		}));
+		if (bytes > CONFIRM_BYTES && request.confirmModels !== true) return {
+			entryId: request.entryId,
+			state: "needs-models",
+			bytes
+		};
+		const job = {
+			state: "fetching",
+			progress: 0,
+			segments: [],
+			rendered: 0,
+			abort: new AbortController()
+		};
+		this.jobs.set(request.entryId, job);
+		const record = {
+			entryId: request.entryId,
+			url: request.url,
+			media: request.media,
+			...request.title === void 0 ? {} : { title: request.title },
+			phase: "transcribe"
+		};
+		this.execute(record, engine, language, job);
+		return this.status(request.entryId);
+	}
+	/**
+	* Leave or stop an entry's job: a queued (or still fetching) job is
+	* withdrawn either way; a running one only with `force`.
+	*/
+	cancel(entryId, force) {
+		const job = this.jobs.get(entryId);
+		if (job === void 0) return {
+			entryId,
+			state: "idle"
+		};
+		if (force || job.state === "queued" || job.state === "fetching") {
+			job.abort.abort();
+			this.jobs.delete(entryId);
+			return {
+				entryId,
+				state: "idle"
+			};
+		}
+		return this.status(entryId);
+	}
+	/** Whether the engine is installed right now. */
+	engineAvailable() {
+		return this.deps.engine() !== void 0;
+	}
+	/** Stop everything (plugin disposal) — keeping each job's record, so the next process resumes it. */
+	dispose() {
+		this.disposing = true;
+		if (this.resumeTimer !== void 0) clearInterval(this.resumeTimer);
+		for (const job of this.jobs.values()) job.abort.abort();
+		this.jobs.clear();
+	}
+	/**
+	* Run (or resume) one job: fetch the audio unless the record has it,
+	* transcribe from where the saved segments end, store, then the speakers.
 	*
-	* @param request - the pasted URL and an optional label.
-	* @returns the decision, or a domain refusal.
+	* @param resumeDir - a previous process's directory for this job.
 	*/
-	async addSource(request) {
-		const url = normalizeUrl(request.url);
-		if (url === void 0) return "invalid-url";
-		const doc = await this.currentDoc();
-		if (doc.sources.some((source) => sameTarget(source.url, url))) return "duplicate";
-		const now = (/* @__PURE__ */ new Date()).toISOString();
-		const resolution = await this.resolvePaper(url);
+	async execute(record, engine, language, job, resumeDir) {
+		const signal = job.abort.signal;
+		mkdirSync(this.deps.tmpRoot, { recursive: true });
+		const dir = resumeDir ?? mkdtempSync(join(this.deps.tmpRoot, "audio-"));
+		const recordPath = join(dir, "job.json");
+		const segmentsPath = join(dir, "segments.json");
+		writeJson(recordPath, record);
+		let lastSave = 0;
+		const saveSegments = (force) => {
+			if (!force && Date.now() - lastSave < SAVE_EVERY_MS) return;
+			lastSave = Date.now();
+			writeJson(segmentsPath, job.segments);
+		};
+		try {
+			let file = record.file !== void 0 && existsSync(record.file) ? record.file : void 0;
+			if (file === void 0) {
+				job.segments = [];
+				if (record.media.kind === "video") file = await this.deps.videoAudio(record.url, dir, {
+					signal,
+					onProgress: (fraction) => {
+						job.progress = FETCH_SHARE * fraction;
+					}
+				});
+				else {
+					file = join(dir, "audio");
+					await curlTo(record.media.ref, file, signal);
+				}
+				record.file = file;
+				record.phase = "transcribe";
+				writeJson(recordPath, record);
+			} else job.segments = readJson(segmentsPath) ?? [];
+			job.progress = FETCH_SHARE;
+			let segments;
+			let detected = record.language;
+			if (record.phase === "transcribe") {
+				job.state = "queued";
+				const earlier = [...job.segments];
+				const fromSec = earlier[earlier.length - 1]?.end ?? 0;
+				const result = await engine.run({
+					input: { files: [file] },
+					...fromSec > 0 ? { fromSec } : {},
+					language,
+					diarize: false,
+					owner: "@khorsheed/dsh-reader",
+					...record.title === void 0 ? {} : { label: record.title }
+				}, {
+					signal,
+					onProgress: (progress) => {
+						if (progress.stage === "queued") {
+							job.state = "queued";
+							if (progress.ahead === void 0) delete job.ahead;
+							else job.ahead = progress.ahead;
+							return;
+						}
+						job.state = "transcribing";
+						delete job.ahead;
+						job.progress = FETCH_SHARE + .9 * progress.progress;
+					},
+					onSegments: (more) => {
+						job.segments.push(...more);
+						saveSegments(false);
+					}
+				});
+				segments = [...earlier, ...result.segments];
+				detected = result.language ?? detected;
+			} else segments = job.segments;
+			const html = renderLocalTranscript(segments);
+			if (html === "") throw new Error("没有识别出语音");
+			if (detected !== void 0) job.language = detected;
+			job.segments = segments;
+			saveSegments(true);
+			if (record.phase === "transcribe") {
+				await this.deps.store(record.entryId, record.url, html, detected);
+				record.phase = "speakers";
+				if (detected !== void 0) record.language = detected;
+				writeJson(recordPath, record);
+			}
+			job.html = html;
+			job.rendered = segments.length;
+			job.progress = 1;
+			if (engine.speakers !== void 0) {
+				job.state = "speakers";
+				try {
+					const voices = await engine.speakers({
+						input: { files: [file] },
+						speech: segments.map((segment) => ({
+							start: segment.start,
+							end: segment.end
+						})),
+						owner: "@khorsheed/dsh-reader",
+						...record.title === void 0 ? {} : { label: record.title }
+					}, { signal });
+					const count = voices.single ? 1 : new Set(voices.turns.map((turn) => turn.cluster)).size;
+					if (count >= 2) {
+						const split = renderSpeakerTranscript(segments, voices.turns);
+						await this.deps.store(record.entryId, record.url, split, detected, count);
+						job.html = split;
+					} else await this.deps.store(record.entryId, record.url, html, detected, 1);
+					job.speakers = count;
+				} catch (error) {
+					if (signal.aborted) return;
+					job.speakersError = error instanceof Error ? error.message : String(error);
+				}
+			}
+			job.state = "done";
+		} catch (error) {
+			if (signal.aborted) return;
+			job.state = "failed";
+			job.error = error instanceof Error ? error.message : String(error);
+		} finally {
+			if (!this.disposing) rmSync(dir, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+};
+//#endregion
+//#region lib/types/media.js
+/**
+* Video and audio entries: what kind of media a link or a feed item is, and
+* how the browser plays it.
+*
+* The kind is decided per ITEM, never per source (the 2026-10-20 decision): a
+* feed may carry articles, audio and video side by side. The signals, best
+* first, are a feed enclosure's MIME type, a link the resolvers recognize
+* (YouTube, Bilibili, Xiaoyuzhou), and — on the host, where pages are fetched
+* — a page whose main content is a player. A page with real prose stays an
+* article even when it embeds a video.
+*
+* Pure and shared by both halves.
+*
+* @module @khorsheed/dsh-reader/media
+*/
+/**
+* Recognize a media link from its URL alone.
+*
+* @param input - any URL.
+* @returns the link, or `undefined` for anything else.
+*/
+function mediaLink(input) {
+	let url;
+	try {
+		url = new URL(input);
+	} catch {
+		return;
+	}
+	const host = url.hostname.replace(/^(www|m)\./, "");
+	if (host === "youtube.com" || host === "music.youtube.com") {
+		const v = url.searchParams.get("v");
+		if (url.pathname === "/watch" && v !== null && /^[\w-]{6,}$/.test(v)) return {
+			provider: "youtube",
+			kind: "video",
+			id: v
+		};
+		const short = /^\/(?:shorts|live|embed)\/([\w-]{6,})/.exec(url.pathname);
+		if (short !== null) return {
+			provider: "youtube",
+			kind: "video",
+			id: short[1]
+		};
+		const channel = /^\/(@[\w.-]+|channel\/UC[\w-]{10,}|c\/[\w.-]+|user\/[\w.-]+)\/?$/.exec(url.pathname.replace(/\/(videos|featured|streams)\/?$/, "/"));
+		if (channel !== null) return {
+			provider: "youtube",
+			kind: "channel",
+			id: channel[1]
+		};
+		return;
+	}
+	if (host === "youtu.be") {
+		const id = url.pathname.slice(1);
+		return /^[\w-]{6,}$/.test(id) ? {
+			provider: "youtube",
+			kind: "video",
+			id
+		} : void 0;
+	}
+	if (host === "bilibili.com" || host === "b23.tv") {
+		const bv = /\/video\/(BV[0-9A-Za-z]{10})/.exec(url.pathname);
+		if (bv !== null) return {
+			provider: "bilibili",
+			kind: "video",
+			id: bv[1]
+		};
+		return;
+	}
+	if (host === "xiaoyuzhoufm.com") {
+		const episode = /^\/episode\/([0-9a-f]{24})/.exec(url.pathname);
+		if (episode !== null) return {
+			provider: "xiaoyuzhou",
+			kind: "audio",
+			id: episode[1]
+		};
+		const podcast = /^\/podcast\/([0-9a-f]{24})/.exec(url.pathname);
+		if (podcast !== null) return {
+			provider: "xiaoyuzhou",
+			kind: "podcast",
+			id: podcast[1]
+		};
+	}
+}
+/** Hosts whose links are only redirects to a media page (Bilibili's share links). */
+const SHORT_LINK_HOSTS = /* @__PURE__ */ new Set(["b23.tv", "bili2233.cn"]);
+/** True for a share short link that must be resolved before it can be recognized. */
+function isShortMediaLink(input) {
+	try {
+		return SHORT_LINK_HOSTS.has(new URL(input).hostname.replace(/^www\./, ""));
+	} catch {
+		return false;
+	}
+}
+/**
+* The clean address of a recognized video link: the platform's canonical page,
+* without the share-tracking parameters a resolved short link drags along.
+*
+* @param input - a video URL.
+*/
+function canonicalMediaUrl(input) {
+	const link = mediaLink(input);
+	if (link?.provider === "bilibili" && link.kind === "video") {
+		const page = new URL(input).searchParams.get("p");
+		return `https://www.bilibili.com/video/${link.id}/${page !== null && page !== "1" ? `?p=${encodeURIComponent(page)}` : ""}`;
+	}
+	if (link?.provider === "youtube" && link.kind === "video") return `https://www.youtube.com/watch?v=${link.id}`;
+}
+/** The `<meta name>` a media link's synthetic page carries its description in. */
+const MEDIA_META_NAME = "dsh-reader:media";
+//#endregion
+//#region lib/types/ytdlp.js
+/**
+* yt-dlp on the host: video metadata and platform captions, never the video.
+*
+* Measured 2026-10-20: a 2023 yt-dlp (and the 2025 one pip can still install
+* on a Python 3.9 environment) can no longer read YouTube — captions now need
+* the current extractor and a JavaScript runtime. So the reader keeps its own
+* copy of the official STANDALONE release (bundled Python) under its state
+* root, fetched on first use and self-updated (`-U`) when it is two weeks old;
+* a path configured by the deployment wins over it. Node — the host's own
+* runtime — is handed to yt-dlp as its JavaScript runtime.
+*
+* Metadata (`--dump-single-json`) and captions (`--write-subs`) are requested
+* with `--skip-download`; the only download is an AUDIO track, for local
+* transcription of a video without captions, deleted once transcribed.
+*
+* @module @khorsheed/dsh-reader/ytdlp
+*/
+/** The release asset for this platform, or `undefined` where none is published. */
+function releaseAsset(platform = process.platform, arch = process.arch) {
+	if (platform === "darwin") return "yt-dlp_macos";
+	if (platform === "linux") return arch === "arm64" ? "yt-dlp_linux_aarch64" : "yt-dlp_linux";
+	if (platform === "win32") return "yt-dlp.exe";
+}
+/** How old the managed binary may get before a self-update (ms). */
+const UPDATE_AFTER_MS = 12096e5;
+/** Tracks that are not speech captions. */
+const NOT_CAPTIONS = /* @__PURE__ */ new Set([
+	"live_chat",
+	"danmaku",
+	"rechat"
+]);
+/** Caption formats, best first (json3 is YouTube's cleanest; json is Bilibili's). */
+const FORMATS = [
+	"json3",
+	"vtt",
+	"srt",
+	"json"
+];
+/** The best format a track offers, among the ones the parser reads. */
+function bestFormat(formats) {
+	const offered = new Set((formats ?? []).map((format) => format.ext));
+	return FORMATS.find((format) => offered.has(format));
+}
+/**
+* Choose the caption track: the uploader's own captions in the video's
+* language first, then any uploaded track, then the platform's automatic
+* captions in the ORIGINAL language (YouTube marks it `<lang>-orig`; the other
+* auto tracks are machine translations, which are also what trips its rate
+* limit). Manual and automatic tracks are equally "captions" to the reader
+* (2026-10-20); the choice only prefers the better one.
+*
+* @param info - the video's info JSON.
+*/
+function chooseCaptionTrack(info) {
+	const language = (info.language ?? "").toLowerCase();
+	const manual = Object.entries(info.subtitles ?? {}).filter(([lang]) => !NOT_CAPTIONS.has(lang));
+	const pick = (entries, auto, preferred) => {
+		for (const want of preferred) {
+			const hit = entries.find(([lang]) => lang.toLowerCase() === want) ?? entries.find(([lang]) => want !== "" && lang.toLowerCase().startsWith(want));
+			const ext = hit === void 0 ? void 0 : bestFormat(hit[1]);
+			if (hit !== void 0 && ext !== void 0) return {
+				lang: hit[0],
+				auto,
+				ext
+			};
+		}
+		for (const [lang, formats] of entries) {
+			const ext = bestFormat(formats);
+			if (ext !== void 0) return {
+				lang,
+				auto,
+				ext
+			};
+		}
+	};
+	const fromManual = pick(manual, false, [
+		language,
+		"zh",
+		"en",
+		"ai-zh"
+	].filter((item) => item !== ""));
+	if (fromManual !== void 0) return fromManual;
+	const auto = Object.entries(info.automatic_captions ?? {}).filter(([lang]) => !NOT_CAPTIONS.has(lang));
+	const fromOriginal = pick(auto.filter(([lang]) => lang.endsWith("-orig")), true, language === "" ? [] : [`${language}-orig`]);
+	if (fromOriginal !== void 0) return fromOriginal;
+	return language === "" ? void 0 : pick(auto.filter(([lang]) => lang.toLowerCase() === language), true, [language]);
+}
+/** Run a process, resolving its stdout. */
+function run(file, args, timeoutMs) {
+	return new Promise((resolve, reject) => {
+		execFile(file, [...args], {
+			timeout: timeoutMs,
+			maxBuffer: 67108864,
+			env: process.env
+		}, (error, stdout, stderr) => {
+			if (error !== null) {
+				const tail = String(stderr).trim().split("\n").filter((line) => /ERROR|error:/i.test(line)).slice(-1)[0];
+				reject(new Error(tail ?? error.message));
+				return;
+			}
+			resolve(String(stdout));
+		});
+	});
+}
+/**
+* Run a process to completion, honoring an abort signal and reporting stdout
+* lines as they come.
+*/
+function runStreaming(file, args, options) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(file, [...args], {
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: process.env,
+			...options.signal === void 0 ? {} : { signal: options.signal }
+		});
+		const timer = setTimeout(() => {
+			child.kill("SIGTERM");
+		}, options.timeoutMs);
+		let buffered = "";
+		let stderr = "";
+		child.stdout.on("data", (chunk) => {
+			buffered += chunk.toString("utf8");
+			const lines = buffered.split(/\r?\n|\r/);
+			buffered = lines.pop() ?? "";
+			for (const line of lines) options.onLine?.(line);
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr = (stderr + chunk.toString("utf8")).slice(-4e3);
+		});
+		child.on("error", (error) => {
+			clearTimeout(timer);
+			reject(error);
+		});
+		child.on("close", (code) => {
+			clearTimeout(timer);
+			if (code === 0) resolve();
+			else reject(new Error(stderr.trim().split("\n").filter((line) => /ERROR|error:/i.test(line)).slice(-1)[0] ?? `${file.split("/").pop() ?? file} exited with ${String(code)}`));
+		});
+	});
+}
+/** The yt-dlp manager. */
+var YtDlp = class {
+	configured;
+	binDir;
+	tmpRoot;
+	ensuring;
+	/**
+	* @param stateRoot - the reader's state root (the managed binary lives under `bin/`).
+	* @param configured - a deployment-configured binary path, which wins.
+	*/
+	constructor(stateRoot, configured) {
+		this.configured = configured;
+		this.binDir = join(stateRoot, "bin");
+		this.tmpRoot = join(stateRoot, "tmp");
+	}
+	/** The binary to run: the configured one, else the managed one (fetched / updated as needed). */
+	binary() {
+		if (this.configured !== void 0 && this.configured !== "") return Promise.resolve(this.configured);
+		this.ensuring ??= this.ensureManaged().finally(() => {
+			this.ensuring = void 0;
+		});
+		return this.ensuring;
+	}
+	/** Fetch the standalone release on first use; self-update it when stale. */
+	async ensureManaged() {
+		const asset = releaseAsset();
+		if (asset === void 0) throw new Error(`yt-dlp: no standalone release for ${process.platform}/${process.arch}`);
+		const target = join(this.binDir, asset);
+		if (!existsSync(target)) {
+			mkdirSync(this.binDir, { recursive: true });
+			const partial = `${target}.download`;
+			await run("curl", [
+				"-fsSL",
+				"--retry",
+				"2",
+				"-o",
+				partial,
+				`https://github.com/yt-dlp/yt-dlp/releases/latest/download/${asset}`
+			], 3e5);
+			chmodSync(partial, 493);
+			renameSync(partial, target);
+			return target;
+		}
+		if (Date.now() - statSync(target).mtimeMs > UPDATE_AFTER_MS) await run(target, ["-U"], 12e4).catch(() => void 0);
+		return target;
+	}
+	/** The version of the binary in use. */
+	async version() {
+		return (await run(await this.binary(), ["--version"], 3e4)).trim();
+	}
+	/** The common flags: no download, no formats needed, Node as the JS runtime. */
+	base() {
+		return [
+			"--skip-download",
+			"--ignore-no-formats-error",
+			"--no-playlist",
+			"--no-warnings",
+			"--js-runtimes",
+			`node:${process.execPath}`
+		];
+	}
+	/**
+	* A video's metadata.
+	*
+	* @param url - the video page URL.
+	*/
+	async info(url) {
+		const line = (await run(await this.binary(), [
+			...this.base(),
+			"--dump-single-json",
+			url
+		], 12e4)).trim().split("\n").filter((item) => item.startsWith("{")).pop();
+		if (line === void 0) throw new Error("yt-dlp: no metadata");
+		return JSON.parse(line);
+	}
+	/**
+	* A channel's newest videos (a flat listing: no video is opened).
+	*
+	* YouTube's own channel feed (`feeds/videos.xml`) answers 404 (measured
+	* 2026-10-20), so the listing is yt-dlp's; `approximate_date` gives each
+	* entry a day-precision date.
+	*
+	* @param url - the channel URL.
+	* @param limit - how many of the newest videos.
+	*/
+	async channel(url, limit = 15) {
+		const listing = /\/(videos|streams|shorts)\/?$/.test(url) ? url : `${url.replace(/\/+$/, "")}/videos`;
+		const line = (await run(await this.binary(), [
+			"--flat-playlist",
+			"--dump-single-json",
+			"--playlist-end",
+			String(limit),
+			"--no-warnings",
+			"--extractor-args",
+			"youtubetab:approximate_date",
+			"--js-runtimes",
+			`node:${process.execPath}`,
+			listing
+		], 18e4)).trim().split("\n").filter((item) => item.startsWith("{")).pop();
+		if (line === void 0) throw new Error("yt-dlp: no channel listing");
+		const data = JSON.parse(line);
+		const title = data.channel ?? data.uploader ?? data.title?.replace(/ - Videos$/, "");
+		return {
+			...title === void 0 ? {} : { title },
+			entries: (data.entries ?? []).map((entry) => {
+				const { thumbnails, ...rest } = entry;
+				const thumbnail = entry.thumbnail ?? thumbnails?.[thumbnails.length - 1]?.url;
+				return thumbnail === void 0 ? rest : {
+					...rest,
+					thumbnail
+				};
+			})
+		};
+	}
+	/**
+	* A video's audio track, downloaded for local transcription (the smallest
+	* audio-only format; the platform's combined stream when there is none).
+	*
+	* @param url - the video page URL.
+	* @param dir - an empty directory the file lands in.
+	* @param options - abort, and download progress 0–1.
+	* @returns the downloaded file.
+	*/
+	async audio(url, dir, options = {}) {
+		await runStreaming(await this.binary(), [
+			"-f",
+			"wa[acodec!=none]/ba/b",
+			"--no-playlist",
+			"--no-warnings",
+			"--newline",
+			"--no-part",
+			"--js-runtimes",
+			`node:${process.execPath}`,
+			"-o",
+			join(dir, "audio.%(ext)s"),
+			url
+		], {
+			timeoutMs: 18e5,
+			...options.signal === void 0 ? {} : { signal: options.signal },
+			onLine: (line) => {
+				const percent = /^\[download\]\s+([\d.]+)%/.exec(line)?.[1];
+				if (percent !== void 0) options.onProgress?.(Number(percent) / 100);
+			}
+		});
+		const file = readdirSync(dir).find((name) => name.startsWith("audio."));
+		if (file === void 0) throw new Error("yt-dlp: no audio downloaded");
+		return join(dir, file);
+	}
+	/**
+	* One caption track's cues.
+	*
+	* @param url - the video page URL.
+	* @param track - the chosen track.
+	*/
+	async captions(url, track) {
+		mkdirSync(this.tmpRoot, { recursive: true });
+		const dir = mkdtempSync(join(this.tmpRoot, "subs-"));
+		try {
+			await run(await this.binary(), [
+				...this.base(),
+				track.auto ? "--write-auto-subs" : "--write-subs",
+				"--sub-langs",
+				track.lang,
+				"--sub-format",
+				track.ext,
+				"-o",
+				join(dir, "captions.%(ext)s"),
+				url
+			], 18e4);
+			const file = readdirSync(dir).find((name) => name.startsWith("captions.") && !name.endsWith(".part"));
+			if (file === void 0) return [];
+			return parseCaptions(readFileSync(join(dir, file), "utf8"), file.split(".").pop() ?? "");
+		} finally {
+			rmSync(dir, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+};
+//#endregion
+//#region lib/types/media-host.js
+/**
+* The host half of video and audio entries: the pages a media link becomes,
+* the feeds a channel or podcast becomes, and the transcript a video reads as.
+*
+* - A single video (YouTube, Bilibili) or Xiaoyuzhou episode is stored as a
+*   `link` source whose payload is a SYNTHETIC page: title, description,
+*   thumbnail, and a `<meta name="dsh-reader:media">` carrying the media
+*   description the browser half reads (`readMediaMeta`). Every other part of
+*   the reader then treats it as a saved link.
+* - A YouTube channel resolves to YouTube's own channel feed; a Xiaoyuzhou
+*   podcast page becomes an RSS document (`xiaoyuzhou.ts`).
+* - A video's transcript comes from the platform's captions via yt-dlp,
+*   merged into timed paragraphs (`captions.ts`). Whether a video has
+*   captions is remembered in `media.json`, so a caption-less video does not
+*   cost a yt-dlp run on every open.
+*
+* @module @khorsheed/dsh-reader/media-host
+*/
+/** Escape text for HTML content and attributes. */
+function escapeHtml(text) {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+/** A plain-text description as paragraphs. */
+function paragraphs(text) {
+	return text.split(/\n{2,}/).map((block) => block.trim()).filter((block) => block !== "").map((block) => `<p>${escapeHtml(block).replace(/\n/g, "<br>")}</p>`).join("\n");
+}
+/**
+* The synthetic page a media link is stored as.
+*
+* @param page - what the page says.
+*/
+function syntheticPage(page) {
+	const body = page.descriptionHtml ?? (page.descriptionText === void 0 ? "" : paragraphs(page.descriptionText));
+	const plain = (page.descriptionText ?? page.descriptionHtml?.replace(/<[^>]+>/g, " ") ?? "").replace(/\s+/g, " ").trim().slice(0, 300);
+	return [
+		"<!doctype html><html><head><meta charset=\"utf-8\">",
+		`<title>${escapeHtml(page.title)}</title>`,
+		`<meta property="og:title" content="${escapeHtml(page.title)}">`,
+		plain === "" ? "" : `<meta name="description" content="${escapeHtml(plain)}">`,
+		page.media.thumbnail === void 0 ? "" : `<meta property="og:image" content="${escapeHtml(page.media.thumbnail)}">`,
+		page.author === void 0 ? "" : `<meta name="author" content="${escapeHtml(page.author)}">`,
+		page.publishedAt === void 0 ? "" : `<meta property="article:published_time" content="${escapeHtml(page.publishedAt)}">`,
+		`<meta name="${MEDIA_META_NAME}" content="${escapeHtml(JSON.stringify(page.media))}">`,
+		"</head><body><article>",
+		`<h1>${escapeHtml(page.title)}</h1>`,
+		body,
+		"</article></body></html>"
+	].filter((line) => line !== "").join("\n");
+}
+/** A yt-dlp `upload_date` (`YYYYMMDD`) or timestamp as ISO-8601. */
+function publishedOf(info) {
+	if (typeof info.timestamp === "number") return (/* @__PURE__ */ new Date(info.timestamp * 1e3)).toISOString();
+	const day = /^(\d{4})(\d{2})(\d{2})$/.exec(info.upload_date ?? "");
+	return day === null ? void 0 : `${day[1]}-${day[2]}-${day[3]}T00:00:00.000Z`;
+}
+/**
+* A video's synthetic page from its yt-dlp metadata.
+*
+* @param info - the metadata.
+* @param provider - which platform.
+* @param id - the platform's video id.
+*/
+function videoPage(info, provider, id) {
+	const published = publishedOf(info);
+	const author = info.uploader ?? info.channel;
+	return syntheticPage({
+		title: info.title ?? id,
+		media: {
+			kind: "video",
+			provider,
+			ref: id,
+			...typeof info.duration === "number" ? { durationSec: Math.round(info.duration) } : {},
+			...info.thumbnail === void 0 ? {} : { thumbnail: info.thumbnail }
+		},
+		...info.description === void 0 ? {} : { descriptionText: info.description },
+		...author === void 0 ? {} : { author },
+		...published === void 0 ? {} : { publishedAt: published }
+	});
+}
+/**
+* A Xiaoyuzhou episode's synthetic page.
+*
+* @param episode - the parsed episode.
+*/
+function episodePage(episode) {
+	return syntheticPage({
+		title: episode.title,
+		media: {
+			kind: "audio",
+			provider: "xiaoyuzhou",
+			ref: episode.audio,
+			...episode.durationSec === void 0 ? {} : { durationSec: episode.durationSec },
+			...episode.image === void 0 ? {} : { thumbnail: episode.image }
+		},
+		...episode.notesHtml === void 0 ? {} : { descriptionHtml: episode.notesHtml },
+		...episode.podcastTitle === void 0 ? {} : { author: episode.podcastTitle },
+		...episode.publishedAt === void 0 ? {} : { publishedAt: episode.publishedAt }
+	});
+}
+/** Escape text for XML. */
+function xml$1(text) {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+/**
+* A YouTube channel's newest videos as an RSS document (YouTube's own channel
+* feed answers 404 — measured 2026-10-20). Each item links the watch page, so
+* the browser half reads it as a video; the thumbnail rides `media:thumbnail`.
+*
+* @param channel - the yt-dlp flat listing.
+* @param pageUrl - the channel URL.
+*/
+function channelRss(channel, pageUrl) {
+	const items = channel.entries.flatMap((entry) => {
+		if (entry.id === void 0 || entry.title === void 0) return [];
+		const published = publishedOf(entry);
+		return [[
+			"<item>",
+			`<title>${xml$1(entry.title)}</title>`,
+			`<link>https://www.youtube.com/watch?v=${xml$1(entry.id)}</link>`,
+			`<guid isPermaLink="false">yt:video:${xml$1(entry.id)}</guid>`,
+			published === void 0 ? "" : `<pubDate>${new Date(published).toUTCString()}</pubDate>`,
+			entry.thumbnail === void 0 ? "" : `<media:thumbnail url="${xml$1(entry.thumbnail)}"/>`,
+			"</item>"
+		].filter((line) => line !== "").join("")];
+	});
+	return [
+		"<?xml version=\"1.0\" encoding=\"UTF-8\"?>",
+		"<rss version=\"2.0\" xmlns:media=\"http://search.yahoo.com/mrss/\"><channel>",
+		`<title>${xml$1(channel.title ?? pageUrl)}</title>`,
+		`<link>${xml$1(pageUrl)}</link>`,
+		...items,
+		"</channel></rss>"
+	].join("\n");
+}
+/** A synthetic page's display name for the source: its author (the channel / podcast), else its title. */
+function syntheticLabel(raw) {
+	const author = /<meta name="author" content="([^"]*)"/.exec(raw)?.[1];
+	const title = /<title>([^<]*)<\/title>/.exec(raw)?.[1];
+	const value = author ?? title;
+	return value === void 0 ? void 0 : value.replace(/&quot;/g, "\"").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+}
+/**
+* Where a share short link leads (b23.tv → bilibili.com/video/BV…). curl
+* follows the redirect chain and honors the deployment's proxy environment.
+*
+* @param url - the short link.
+*/
+function resolveShortLink(url) {
+	return new Promise((resolve, reject) => {
+		execFile("curl", [
+			"-sL",
+			"-m",
+			"20",
+			"-A",
+			"Mozilla/5.0",
+			"-o",
+			"/dev/null",
+			"-w",
+			"%{url_effective}",
+			url
+		], {
+			timeout: 3e4,
+			env: process.env
+		}, (error, stdout) => {
+			if (error !== null) {
+				reject(error);
+				return;
+			}
+			resolve(String(stdout).trim());
+		});
+	});
+}
+/** The host's media helper: yt-dlp plus the caption record. */
+var ReaderMediaHost = class {
+	stateRoot;
+	ytdlp;
+	file;
+	records;
+	/**
+	* @param stateRoot - the reader's state root.
+	* @param ytdlpPath - a deployment-configured yt-dlp, which wins over the managed one.
+	*/
+	constructor(stateRoot, ytdlpPath) {
+		this.stateRoot = stateRoot;
+		this.ytdlp = new YtDlp(stateRoot, ytdlpPath);
+		this.file = join(stateRoot, "media.json");
+	}
+	/** The caption records, read once. */
+	load() {
+		if (this.records !== void 0) return this.records;
+		try {
+			this.records = JSON.parse(readFileSync(this.file, "utf8"));
+		} catch {
+			this.records = {};
+		}
+		return this.records;
+	}
+	/** What is known about an entry's captions. */
+	captions(entryId) {
+		return this.load()[entryId];
+	}
+	/** Remember what an entry's captions came to. */
+	remember(entryId, record) {
+		const records = {
+			...this.load(),
+			[entryId]: record
+		};
+		this.records = records;
+		try {
+			mkdirSync(this.stateRoot, { recursive: true });
+			const temporary = `${this.file}.${process.pid}.tmp`;
+			writeFileSync(temporary, `${JSON.stringify(records, null, 2)}\n`);
+			renameSync(temporary, this.file);
+		} catch {
+			rmSync(`${this.file}.${process.pid}.tmp`, { force: true });
+		}
+	}
+	/**
+	* A video's transcript from its platform captions.
+	*
+	* @param url - the video page.
+	* @returns the transcript markup and its language, or `none` when the video has no captions.
+	*/
+	async transcript(url) {
+		const track = chooseCaptionTrack(await this.ytdlp.info(url));
+		if (track === void 0) return "none";
+		const segments = mergeCues(await this.ytdlp.captions(url, track));
+		if (segments.length === 0) return "none";
+		return {
+			html: renderTranscript(segments),
+			language: track.lang.replace(/-orig$/, "")
+		};
+	}
+};
+//#endregion
+//#region lib/types/xiaoyuzhou.js
+/**
+* Xiaoyuzhou (小宇宙): episode and podcast pages → what the reader stores.
+*
+* Xiaoyuzhou publishes no RSS. Its pages do carry their data as Next.js
+* `__NEXT_DATA__` JSON (measured 2026-10-20): an episode page has
+* `props.pageProps.episode` with the audio enclosure, duration, shownotes and
+* podcast; a podcast page has `props.pageProps.podcast.episodes[]`. A podcast
+* page is turned into an RSS document on the host, so subscribing to it is an
+* ordinary feed subscription for every other part of the reader.
+*
+* Pure: the host fetches the page and hands over its text.
+*
+* @module @khorsheed/dsh-reader/xiaoyuzhou
+*/
+/** The page's Next.js data, or `undefined` when the page has none. */
+function nextData(html) {
+	const match = /<script id="__NEXT_DATA__"[^>]*>([\s\S]*?)<\/script>/.exec(html);
+	if (match === null) return void 0;
+	try {
+		return JSON.parse(match[1]);
+	} catch {
+		return;
+	}
+}
+/** A nested record field, tolerantly. */
+function field(value, ...path) {
+	let current = value;
+	for (const key of path) {
+		if (typeof current !== "object" || current === null) return void 0;
+		current = current[key];
+	}
+	return current;
+}
+/** A string field, or `undefined`. */
+function str(value) {
+	return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+/** One episode record → the reader's shape. */
+function readEpisode(record, podcastTitle) {
+	const id = str(field(record, "eid"));
+	const title = str(field(record, "title"));
+	const audio = str(field(record, "enclosure", "url")) ?? str(field(record, "media", "source", "url"));
+	if (id === void 0 || title === void 0 || audio === void 0) return void 0;
+	const duration = Number(field(record, "duration"));
+	const notes = str(field(record, "shownotes")) ?? str(field(record, "description"));
+	const image = str(field(record, "image", "picUrl")) ?? str(field(record, "podcast", "image", "picUrl"));
+	const podcast = podcastTitle ?? str(field(record, "podcast", "title"));
+	const publishedAt = str(field(record, "pubDate"));
+	return {
+		id,
+		title,
+		audio,
+		...Number.isFinite(duration) && duration > 0 ? { durationSec: duration } : {},
+		...publishedAt === void 0 ? {} : { publishedAt },
+		...notes === void 0 ? {} : { notesHtml: notes },
+		...image === void 0 ? {} : { image },
+		...podcast === void 0 ? {} : { podcastTitle: podcast }
+	};
+}
+/**
+* Read an episode page.
+*
+* @param html - the page's HTML.
+* @returns the episode, or `undefined` when the page carries none.
+*/
+function readEpisodePage(html) {
+	return readEpisode(field(nextData(html), "props", "pageProps", "episode"));
+}
+/** Escape text for XML content and attributes. */
+function xml(text) {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+/** CDATA, safe against a literal `]]>` in the content. */
+function cdata(text) {
+	return `<![CDATA[${text.replace(/]]>/g, "]]]]><![CDATA[>")}]]>`;
+}
+/** The MIME type an audio URL most likely has. */
+function audioType(url) {
+	const path = url.toLowerCase().split("?")[0] ?? "";
+	if (path.endsWith(".m4a") || path.endsWith(".mp4")) return "audio/mp4";
+	return "audio/mpeg";
+}
+/**
+* Turn a podcast page into an RSS document the reader subscribes to like any
+* other feed.
+*
+* @param html - the podcast page's HTML.
+* @param pageUrl - the page's URL (the channel link).
+* @returns the RSS text, or `undefined` when the page carries no podcast.
+*/
+function podcastPageToRss(html, pageUrl) {
+	const podcast = field(nextData(html), "props", "pageProps", "podcast");
+	const title = str(field(podcast, "title"));
+	if (title === void 0) return void 0;
+	const items = (Array.isArray(field(podcast, "episodes")) ? field(podcast, "episodes") : []).flatMap((record) => {
+		const episode = readEpisode(record, title);
+		if (episode === void 0) return [];
+		const date = episode.publishedAt === void 0 ? void 0 : new Date(episode.publishedAt);
+		return [[
+			"<item>",
+			`<title>${xml(episode.title)}</title>`,
+			`<link>https://www.xiaoyuzhoufm.com/episode/${episode.id}</link>`,
+			`<guid isPermaLink="false">xiaoyuzhou:${episode.id}</guid>`,
+			date === void 0 || Number.isNaN(date.getTime()) ? "" : `<pubDate>${date.toUTCString()}</pubDate>`,
+			episode.notesHtml === void 0 ? "" : `<description>${cdata(episode.notesHtml)}</description>`,
+			`<enclosure url="${xml(episode.audio)}" type="${audioType(episode.audio)}" length="0"/>`,
+			episode.durationSec === void 0 ? "" : `<itunes:duration>${String(episode.durationSec)}</itunes:duration>`,
+			episode.image === void 0 ? "" : `<itunes:image href="${xml(episode.image)}"/>`,
+			"</item>"
+		].filter((line) => line !== "").join("")];
+	});
+	const description = str(field(podcast, "description"));
+	const image = str(field(podcast, "image", "picUrl"));
+	return [
+		"<?xml version=\"1.0\" encoding=\"UTF-8\"?>",
+		"<rss version=\"2.0\" xmlns:itunes=\"http://www.itunes.com/dtds/podcast-1.0.dtd\">",
+		"<channel>",
+		`<title>${xml(title)}</title>`,
+		`<link>${xml(pageUrl)}</link>`,
+		description === void 0 ? "" : `<description>${xml(description)}</description>`,
+		image === void 0 ? "" : `<image><url>${xml(image)}</url><title>${xml(title)}</title><link>${xml(pageUrl)}</link></image>`,
+		...items,
+		"</channel>",
+		"</rss>"
+	].filter((line) => line !== "").join("\n");
+}
+/** Cross-origin redirect hops the service will follow before giving up. */
+const MAX_REDIRECT_HOPS = 3;
+/** Upper bound on summaries handed to the browser in one call. */
+const SUMMARY_LIMIT = 500;
+/** How many sentence hashes one memory-slice read answers (the table never crosses). */
+const TRANSLATION_SLICE_LIMIT = 2e3;
+/** How many sentences one write batch may carry (a long article is ~500). */
+const TRANSLATION_WRITE_LIMIT = 2e3;
+/** One sentence's source or translation is never longer than a few paragraphs. */
+const TRANSLATION_TEXT_LIMIT = 4e3;
+/** Thrown when a payload cannot become a source. */
+var UnsupportedContent = class extends Error {};
+/**
+* Whether a failed fetch is the HTML endpoint's "this paper has no HTML
+* version" — a bare 404 from the content fetch, and nothing else. A refusal
+* (403/401) or a transport error is a fact about the REQUEST, not about which
+* face of the paper exists, and must not silently reroute to another page.
+*/
+function isNoHtmlVersion(error) {
+	return error instanceof UnsupportedContent && error.message === "HTTP 404";
+}
+/**
+* Classify a fetched payload as a feed or an article page.
+*
+* The decision comes from the CONTENT, not from asking the user: nobody pasting
+* a URL can be expected to know whether it is a feed, and guessing wrong used
+* to mean silently creating an empty subscription.
+*
+* @param raw - the decoded payload.
+* @returns which kind of source this payload can become.
+*/
+function classifyPayload(raw) {
+	const head = raw.slice(0, 512).trimStart().toLowerCase();
+	if (head.startsWith("<?xml")) return "feed";
+	if (/^<rss[\s>]/.test(head)) return "feed";
+	if (/^<feed[\s>]/.test(head)) return "feed";
+	if (/^<rdf:rdf[\s>]/.test(head)) return "feed";
+	return "page";
+}
+/** The reader service. */
+var ReaderService = class {
+	store;
+	/** Video and audio entries: synthetic pages, channel feeds, transcripts. */
+	media;
+	/** Local transcription of entries without captions (the optional `transcribe` engine). */
+	local;
+	ctx;
+	timer;
+	disposed = false;
+	/** The document of record when no filesystem is mounted. */
+	memoryDoc;
+	/** Rescued images, by URL — a pane remount re-fails every blocked image, and this is what keeps that a memory read. */
+	imageCache = new ImageFetchCache();
+	/** Feeds and pages, as the origin served them (see `document-fetch.ts`). */
+	documents;
+	/**
+	* @param ctx - owning context.
+	* @param config - optional state-root override.
+	*/
+	constructor(ctx, config = {}) {
+		this.ctx = ctx;
+		this.documents = new DocumentFetch(() => this.ctx.get("web"), config.fetchLimits);
+		this.store = new ReaderStore(config);
+		const stateRoot = resolveReaderStateRoot(config.stateRoot);
+		this.media = new ReaderMediaHost(stateRoot, config.ytdlpPath);
+		this.local = new LocalTranscriber({
+			engine: () => ctx.get("transcribe"),
+			tmpRoot: join(stateRoot, "tmp"),
+			videoAudio: (url, dir, options) => this.media.ytdlp.audio(url, dir, options),
+			store: async (entryId, url, html, language, speakers) => {
+				await this.storeEntryBody({
+					entryId,
+					url,
+					html,
+					keep: true
+				});
+				const before = this.media.captions(entryId);
+				const names = before?.names !== void 0 && (speakers === void 0 || speakers === before.speakers) ? before.names : void 0;
+				const count = speakers ?? before?.speakers;
+				this.media.remember(entryId, {
+					state: "local",
+					...language === void 0 ? {} : { language },
+					checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+					...count === void 0 ? {} : { speakers: count },
+					...names === void 0 ? {} : { names }
+				});
+			}
+		});
+		ctx.effect(() => () => {
+			this.disposed = true;
+			this.local.dispose();
+			if (this.timer !== void 0) clearTimeout(this.timer);
+		}, "reader: daily refresh");
+		this.armSchedule();
+	}
+	/** Capabilities the browser may rely on. */
+	async capabilities() {
+		const doc = await this.currentDoc();
+		return {
+			protocolVersion: 1,
+			hasFs: this.store.available,
+			...doc.lastRefreshAt === void 0 ? {} : { lastRefreshAt: doc.lastRefreshAt },
+			hasSideChat: this.sideChat() !== void 0,
+			...doc.refresh.enabled ? { nextRefreshAt: new Date(Date.now() + delayUntilNext(/* @__PURE__ */ new Date(), doc.refresh.timeOfDay)).toISOString() } : {}
+		};
+	}
+	/** The source list, without payloads. */
+	async listSources() {
+		return { sources: (await this.currentDoc()).sources.slice(0, SUMMARY_LIMIT).map(summarize$1) };
+	}
+	/**
+	* Add a source, deciding what it is from what comes back.
+	*
+	* The one rule this method exists to enforce: **a URL the reader pasted is
+	* never thrown away.** A fetch that fails, a bot challenge, a login wall and
+	* a PDF all end the same way — a `link` source that exists, carries the
+	* reason it has no previewable body, and can be opened, tagged, refreshed
+	* manually or deleted. Only a URL that cannot be a source at all
+	* (`invalid-url`) or one already present (`duplicate`) is refused.
+	*
+	* @param request - the pasted URL and an optional label.
+	* @returns the decision, or a domain refusal.
+	*/
+	async addSource(request) {
+		const url = normalizeUrl(request.url);
+		if (url === void 0) return "invalid-url";
+		const doc = await this.currentDoc();
+		if (doc.sources.some((source) => sameTarget(source.url, url))) return "duplicate";
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const resolution = await this.resolvePaper(url);
 		if (resolution?.kind === "link-only") return await this.saveLinkOnly({
 			url,
 			...request.label === void 0 ? {} : { label: request.label }
@@ -1949,7 +3647,7 @@ var ReaderService = class {
 		if (upgrade !== void 0 && doc.sources.some((source) => sameTarget(source.url, upgrade))) return "duplicate";
 		let fetched;
 		try {
-			fetched = await this.fetchFollowing(upgrade ?? url);
+			fetched = await this.fetchSource(upgrade ?? url);
 		} catch (error) {
 			if (upgrade !== void 0 && isNoHtmlVersion(error)) try {
 				fetched = await this.fetchFollowing(fallbackUrl);
@@ -1967,10 +3665,10 @@ var ReaderService = class {
 			}, classifyFetchFailure(error, now), now);
 		}
 		const feed = classifyPayload(fetched.raw) === "feed";
-		if (!feed) {
+		if (!feed && fetched.media !== true) {
 			const problem = inspectPreview(fetched.raw, fetched.url, upgrade ?? url);
 			if (problem !== void 0) return await this.saveLinkOnly({
-				url: fetched.url,
+				url,
 				...request.label === void 0 ? {} : { label: request.label },
 				...resolvedFrom === void 0 ? {} : { resolvedFrom }
 			}, {
@@ -1979,7 +3677,7 @@ var ReaderService = class {
 				at: now
 			}, now);
 		}
-		const label = request.label ?? (resolution?.kind === "arxiv" ? resolution.title : void 0) ?? defaultSourceLabel(fetched.url);
+		const label = request.label ?? (resolution?.kind === "arxiv" ? resolution.title : void 0) ?? (fetched.media === true ? syntheticLabel(fetched.raw) : void 0) ?? defaultSourceLabel(fetched.url);
 		const source = {
 			id: `${feed ? "rss" : "link"}-${hash(fetched.url)}`,
 			kind: feed ? "rss" : "link",
@@ -1993,10 +3691,7 @@ var ReaderService = class {
 			...resolvedFrom === void 0 ? {} : { resolvedFrom },
 			raw: fetched.raw
 		};
-		await this.commit((current) => ({
-			...current,
-			sources: [source, ...current.sources]
-		}));
+		await this.commit((current) => withNewSource(current, source));
 		return {
 			outcome: feed ? "subscribed" : "saved-link",
 			kind: source.kind,
@@ -2034,10 +3729,7 @@ var ReaderService = class {
 			failure,
 			...request.resolvedFrom === void 0 ? {} : { resolvedFrom: request.resolvedFrom }
 		};
-		await this.commit((current) => ({
-			...current,
-			sources: [source, ...current.sources]
-		}));
+		await this.commit((current) => withNewSource(current, source));
 		await this.recordFetchFailure(linkEntryId(source.id), failure.message);
 		return {
 			outcome: "saved-link",
@@ -2132,66 +3824,79 @@ var ReaderService = class {
 		const results = [];
 		const patches = /* @__PURE__ */ new Map();
 		const base = new Map(doc.sources.map((source) => [source.id, source]));
-		for (const source of wanted) {
-			const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
-			try {
-				const fetched = await this.fetchFollowing(source.url);
-				const problem = source.kind === "link" ? inspectPreview(fetched.raw, fetched.url, source.url) : void 0;
-				if (problem !== void 0) {
-					const failure = {
-						code: problem.code,
-						message: problem.message,
-						at: fetchedAt
-					};
+		/**
+		* Failures to record AFTER the pool: the workers below run concurrently,
+		* but every document write (a failure record is its own commit) stays
+		* single-filed here — the store's commit is a read-modify-write, and two
+		* in flight at once is how a lost update happens.
+		*/
+		const failures = [];
+		const queue = [...wanted];
+		const workers = Array.from({ length: Math.min(3, queue.length) }, async () => {
+			for (;;) {
+				const source = queue.shift();
+				if (source === void 0) return;
+				const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+				try {
+					const fetched = await this.fetchSource(source.url);
+					const problem = source.kind === "link" && fetched.media !== true ? inspectPreview(fetched.raw, fetched.url, source.url) : void 0;
+					if (problem !== void 0) {
+						const failure = {
+							code: problem.code,
+							message: problem.message,
+							at: fetchedAt
+						};
+						patches.set(source.id, {
+							...withoutFailure(source),
+							fetchedAt,
+							status: "error",
+							error: failure.message,
+							failure
+						});
+						failures.push({
+							entryId: linkEntryId(source.id),
+							message: failure.message
+						});
+						results.push({
+							id: source.id,
+							status: "unavailable",
+							message: failure.message
+						});
+						continue;
+					}
 					patches.set(source.id, {
-						...withoutFailure({
-							...source,
-							url: fetched.url,
-							...source.raw === void 0 ? {} : { raw: source.raw }
-						}),
+						...withoutFailure(source),
+						url: fetched.url,
+						raw: fetched.raw,
+						fetchedAt,
+						status: "ok",
+						truncated: fetched.truncated
+					});
+					results.push({
+						id: source.id,
+						status: fetched.truncated ? "truncated" : "ok",
+						...fetched.truncated ? { message: "payload hit the fetch seam's size cap" } : {}
+					});
+				} catch (error) {
+					const failure = classifyFetchFailure(error, fetchedAt);
+					const previous = base.get(source.id);
+					patches.set(source.id, {
+						...previous ?? source,
 						fetchedAt,
 						status: "error",
 						error: failure.message,
 						failure
 					});
-					await this.recordFetchFailure(linkEntryId(source.id), failure.message);
 					results.push({
 						id: source.id,
-						status: "unavailable",
+						status: error instanceof UnsupportedContent ? "unavailable" : "fetch-failed",
 						message: failure.message
 					});
-					continue;
 				}
-				patches.set(source.id, {
-					...withoutFailure(source),
-					url: fetched.url,
-					raw: fetched.raw,
-					fetchedAt,
-					status: "ok",
-					truncated: fetched.truncated
-				});
-				results.push({
-					id: source.id,
-					status: fetched.truncated ? "truncated" : "ok",
-					...fetched.truncated ? { message: "payload hit the fetch seam's size cap" } : {}
-				});
-			} catch (error) {
-				const failure = classifyFetchFailure(error, fetchedAt);
-				const previous = base.get(source.id);
-				patches.set(source.id, {
-					...previous ?? source,
-					fetchedAt,
-					status: "error",
-					error: failure.message,
-					failure
-				});
-				results.push({
-					id: source.id,
-					status: error instanceof UnsupportedContent ? "unavailable" : "fetch-failed",
-					message: failure.message
-				});
 			}
-		}
+		});
+		await Promise.all(workers);
+		for (const failure of failures) await this.recordFetchFailure(failure.entryId, failure.message);
 		if (patches.size > 0) await this.commit((current) => ({
 			...current,
 			lastRefreshAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -2329,6 +4034,14 @@ var ReaderService = class {
 		await this.markFetching(request.entryId);
 		try {
 			const fetched = await this.fetchFollowing(url);
+			const wall = inspectPreview(fetched.raw, fetched.url, url);
+			if (wall?.code === "blocked") {
+				await this.recordFetchFailure(request.entryId, wall.message, wall.code);
+				return {
+					entryId: request.entryId,
+					error: wall.message
+				};
+			}
 			const rawFile = await this.storeRaw(request.entryId, fetched.raw, fetched.url, fetched.truncated);
 			return {
 				entryId: request.entryId,
@@ -2546,7 +4259,7 @@ var ReaderService = class {
 				chars: html.length
 			},
 			fetchedAt: now.toISOString(),
-			expiresAt: ttlHours === 0 ? new Date(now.getTime() + 31536e8).toISOString() : new Date(now.getTime() + ttlHours * 60 * 60 * 1e3).toISOString(),
+			expiresAt: ttlHours === 0 || request.keep === true ? new Date(now.getTime() + 31536e8).toISOString() : new Date(now.getTime() + ttlHours * 60 * 60 * 1e3).toISOString(),
 			url: request.url,
 			...request.truncated === true ? { truncated: true } : {},
 			...request.scriptFigures === void 0 ? {} : { scriptFigures: request.scriptFigures },
@@ -2604,6 +4317,7 @@ var ReaderService = class {
 		for (const entry of request.entries) {
 			if (entry.url === "") continue;
 			if (entry.hasBody) continue;
+			if (mediaLink(entry.url) !== void 0) continue;
 			const source = doc.sources.find((item) => item.kind === "link" && sameTarget(item.url, entry.url));
 			if (source?.failure !== void 0 && !isRetryablePreviewFailure(source.failure.code)) continue;
 			const annotation = doc.annotations?.[entry.entryId];
@@ -3119,7 +4833,7 @@ var ReaderService = class {
 	* known-unreadable verdict) still answers.
 	*/
 	async resolvePaper(url) {
-		const web = this.web();
+		const web = await this.documents.current();
 		const fetch = async (target) => {
 			if (web === void 0) throw new UnsupportedContent("no web capability is mounted");
 			const result = await web.fetch({ url: target });
@@ -3134,10 +4848,6 @@ var ReaderService = class {
 			return null;
 		}
 	}
-	/** The probed web seam (no host import, no boot-time dependency). */
-	web() {
-		return this.ctx.get("web");
-	}
 	/** The probed side-chat service. */
 	sideChat() {
 		return this.ctx.get("sideChat");
@@ -3188,7 +4898,7 @@ var ReaderService = class {
 	* @returns the final URL and its decoded payload.
 	*/
 	async fetchFollowing(url) {
-		const web = this.web();
+		const web = await this.documents.current();
 		if (web === void 0) throw new UnsupportedContent("no web capability is mounted");
 		let current = url;
 		for (let hop = 0; hop <= MAX_REDIRECT_HOPS; hop++) try {
@@ -3204,7 +4914,169 @@ var ReaderService = class {
 			if (target === void 0) throw error;
 			current = target;
 		}
-		throw new UnsupportedContent(`more than ${MAX_REDIRECT_HOPS} cross-origin redirects`);
+		throw new UnsupportedContent(`more than ${MAX_REDIRECT_HOPS} cross-origin redirects`);
+	}
+	/**
+	* Fetch a source's payload, media-aware (media-host.ts).
+	*
+	* A YouTube channel is fetched as YouTube's own channel feed; a Xiaoyuzhou
+	* podcast page as the RSS document it is turned into; a single video or
+	* Xiaoyuzhou episode as a synthetic page carrying its media description.
+	* Everything else is the ordinary {@link fetchFollowing}.
+	*
+	* @param url - the source URL.
+	*/
+	async fetchSource(url) {
+		if (isShortMediaLink(url)) {
+			const target = await resolveShortLink(url);
+			if (target === "" || isShortMediaLink(target)) throw new UnsupportedContent("the short link leads nowhere");
+			return this.fetchSource(canonicalMediaUrl(target) ?? target);
+		}
+		const link = mediaLink(url);
+		if (link === void 0) return this.fetchFollowing(url);
+		if (link.provider === "youtube" && link.kind === "channel") return {
+			url,
+			raw: channelRss(await this.media.ytdlp.channel(url), url),
+			truncated: false
+		};
+		if (link.provider === "xiaoyuzhou") {
+			const page = await this.fetchFollowing(url);
+			if (link.kind === "podcast") {
+				const rss = podcastPageToRss(page.raw, url);
+				if (rss === void 0) throw new UnsupportedContent("the podcast page carries no episodes");
+				return {
+					url,
+					raw: rss,
+					truncated: false
+				};
+			}
+			const episode = readEpisodePage(page.raw);
+			if (episode === void 0) throw new UnsupportedContent("the episode page carries no audio");
+			return {
+				url,
+				raw: episodePage(episode),
+				truncated: false,
+				media: true
+			};
+		}
+		if (link.kind === "video" && (link.provider === "youtube" || link.provider === "bilibili")) {
+			const clean = canonicalMediaUrl(url) ?? url;
+			return {
+				url: clean,
+				raw: videoPage(await this.media.ytdlp.info(clean), link.provider, link.id),
+				truncated: false,
+				media: true
+			};
+		}
+		return this.fetchFollowing(url);
+	}
+	/**
+	* A video entry's transcript: the stored one, else the platform captions
+	* fetched now and kept (no TTL — it costs a yt-dlp run). A video known to
+	* have no captions answers so without running yt-dlp again.
+	*
+	* @param request - the entry and its video page URL.
+	* @returns the transcript markup, `none`, or why it failed.
+	*/
+	async mediaTranscript(request) {
+		const known = this.media.captions(request.entryId);
+		if (known?.state === "none" || known?.state === "local") return {
+			entryId: request.entryId,
+			captions: "none"
+		};
+		const link = mediaLink(request.url);
+		if (link?.kind !== "video" || link.provider !== "youtube" && link.provider !== "bilibili") return {
+			entryId: request.entryId,
+			captions: "none"
+		};
+		try {
+			const transcript = await this.media.transcript(request.url);
+			if (transcript === "none") {
+				this.media.remember(request.entryId, {
+					state: "none",
+					checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+				});
+				return {
+					entryId: request.entryId,
+					captions: "none"
+				};
+			}
+			const stored = await this.storeEntryBody({
+				entryId: request.entryId,
+				url: request.url,
+				html: transcript.html,
+				keep: true
+			});
+			this.media.remember(request.entryId, {
+				state: "platform",
+				language: transcript.language,
+				checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			return {
+				entryId: request.entryId,
+				captions: "platform",
+				language: transcript.language,
+				...stored.html === void 0 ? {} : { html: stored.html }
+			};
+		} catch (error) {
+			return {
+				entryId: request.entryId,
+				captions: "failed",
+				error: error instanceof Error ? error.message : String(error)
+			};
+		}
+	}
+	/** The reader's names for an entry's speakers, by index. */
+	speakerNames(request) {
+		return { ...this.media.captions(request.entryId)?.names ?? {} };
+	}
+	/**
+	* Name one speaker of an entry's transcript (an empty name restores the default).
+	*
+	* @param request - the entry, the speaker's index, the name.
+	*/
+	nameSpeaker(request) {
+		const record = this.media.captions(request.entryId);
+		if (record === void 0) return {};
+		const names = { ...record.names ?? {} };
+		const name = request.name.trim().slice(0, 40);
+		if (name === "") delete names[String(request.speaker)];
+		else names[String(request.speaker)] = name;
+		this.media.remember(request.entryId, {
+			...record,
+			names
+		});
+		return names;
+	}
+	/**
+	* The wall's media cards: a live local job first, else what the captions
+	* record says (platform captions, a stored local transcript, none).
+	*
+	* @param request - the card ids on screen.
+	*/
+	mediaStates(request) {
+		const states = {};
+		for (const entryId of request.entryIds) {
+			const job = this.local.status(entryId);
+			if (job.state === "fetching" || job.state === "queued" || job.state === "transcribing") {
+				states[entryId] = {
+					state: job.state,
+					...job.progress === void 0 ? {} : { progress: job.progress },
+					...job.ahead === void 0 ? {} : { ahead: job.ahead }
+				};
+				continue;
+			}
+			if (job.state === "failed") {
+				states[entryId] = { state: "failed" };
+				continue;
+			}
+			const record = this.media.captions(entryId);
+			if (record !== void 0) states[entryId] = { state: record.state };
+		}
+		return {
+			engine: this.local.engineAvailable(),
+			states
+		};
 	}
 	/** Arm (or re-arm) the daily refresh timer against the current document. */
 	async armSchedule() {
@@ -3240,6 +5112,27 @@ function normalizeUrl(input) {
 	}
 }
 /** Whether two URLs point at the same target, ignoring a trailing slash. */
+/**
+* The document with `source` added, unless an add that raced this one already
+* filed it.
+*
+* `addSource` checks for a duplicate BEFORE its fetch, which takes long enough
+* (hundreds of ms to seconds) for a second click on 「添加」 to pass the same
+* check; both then committed, and the reader saw the card twice under one id
+* (measured on 3080, 2026-10-04: two `link-1v6imqy` rows 0.7 s apart). The
+* re-check inside the commit is what makes the add idempotent.
+*
+* @param doc - the current document.
+* @param source - the source to file.
+* @returns the document, with the source prepended when it is new.
+*/
+function withNewSource(doc, source) {
+	if (doc.sources.some((existing) => existing.id === source.id || sameTarget(existing.url, source.url))) return doc;
+	return {
+		...doc,
+		sources: [source, ...doc.sources]
+	};
+}
 function sameTarget(a, b) {
 	const strip = (value) => value.replace(/\/+$/, "");
 	return strip(a) === strip(b);
@@ -3299,7 +5192,7 @@ function errorCode(error) {
 	return typeof code === "string" ? code : void 0;
 }
 /** Marker words a bot wall leaves on an otherwise empty page. */
-const BOT_WALL_PATTERN = /just a moment|checking your browser|cf-chl|cf_chl|attention required|unusual traffic|captcha|verifying you are human|enable javascript and cookies|access denied|are you a robot|验证码|人机验证|访问验证|安全验证/;
+const BOT_WALL_PATTERN = /just a moment|checking your browser|cf-chl|cf_chl|attention required|unusual traffic|captcha|verifying you are human|enable javascript and cookies|access denied|are you a robot|验证码|人机验证|访问验证|安全验证|环境异常|完成验证后/;
 /** Marker words an authentication interstitial leaves behind. */
 const LOGIN_WALL_PATTERN = /cookie required|requires? cookies|sign in|sign-in|log in|login|please log|single sign|sso|qurl=|ezproxy|shibboleth|访问权限|请登录|登录后/;
 /** Hosts whose NAME alone says the hop is an authentication wall. */
@@ -3326,188 +5219,1121 @@ function inspectPreview(raw, finalUrl, requestedUrl) {
 		code: "blocked",
 		message: `the site answered a bot challenge instead of the page (${finalUrl})`
 	};
-	if (LOGIN_WALL_PATTERN.test(haystack) || LOGIN_HOST_PATTERN.test(host)) return {
-		code: "login",
-		message: `the page is an authentication interstitial (${finalUrl})`
+	if (LOGIN_WALL_PATTERN.test(haystack) || LOGIN_HOST_PATTERN.test(host)) return {
+		code: "login",
+		message: `the page is an authentication interstitial (${finalUrl})`
+	};
+	if (hostOf(requestedUrl) !== host) return {
+		code: "redirected",
+		message: `the address redirected to ${finalUrl}, which yielded no readable page`
+	};
+	return {
+		code: "empty",
+		message: `the page yielded ${text} characters of text (${finalUrl})`
+	};
+}
+/**
+* Classify a thrown fetch failure into the reason the reader sees.
+*
+* Everything here is per-case diagnosable: the seam's own message is kept
+* verbatim, and only the CODE decides which sentence the browser shows and
+* whether an automatic retry is allowed.
+*
+* @param error - the value the fetch threw.
+* @param at - the failure instant (ISO-8601).
+* @returns the recorded failure.
+*/
+function classifyFetchFailure(error, at) {
+	const message = errorMessage(error);
+	const code = errorCode(error);
+	if (code === "WEB_UNSUPPORTED_CONTENT_TYPE" || /unsupported content type/i.test(message)) return {
+		code: "unsupported-type",
+		message,
+		at
+	};
+	if (code === "WEB_REDIRECT_BLOCKED" || /cross-origin redirect/i.test(message)) {
+		if (isCookieHandshake(message)) return {
+			code: "blocked",
+			message,
+			at
+		};
+		const origin = /cross-origin redirect to (\S+)/i.exec(message)?.[1];
+		return {
+			code: origin !== void 0 && LOGIN_HOST_PATTERN.test(hostOf(origin)) ? "login" : "redirected",
+			message,
+			at
+		};
+	}
+	const status = /\bHTTP (\d{3})\b/.exec(message)?.[1];
+	if (status === "401" || status === "403") return {
+		code: "blocked",
+		message,
+		at
+	};
+	if (status !== void 0) return {
+		code: "http",
+		message,
+		at
+	};
+	return {
+		code: "unreachable",
+		message,
+		at
+	};
+}
+/** The host of a URL, or an empty string when it cannot be parsed. */
+function hostOf(url) {
+	try {
+		return new URL(url).hostname.toLowerCase();
+	} catch {
+		return "";
+	}
+}
+/**
+* How much visible text a payload carries.
+*
+* Script, style and markup are stripped; entities collapse to a single space.
+* This is a measurement, not a parser: its only job is to separate "a page"
+* from "an interstitial that is technically HTML".
+*
+* @param raw - the decoded payload.
+* @returns the visible character count.
+*/
+function visibleTextLength(raw) {
+	return raw.replace(/<script[\s\S]*?<\/script\s*>/gi, " ").replace(/<style[\s\S]*?<\/style\s*>/gi, " ").replace(/<[^>]*>/g, " ").replace(/&[a-z#0-9]+;/gi, " ").replace(/\s+/g, " ").trim().length;
+}
+/** The same source with any recorded preview failure removed. */
+function withoutFailure(source) {
+	const { failure: _removed, ...rest } = source;
+	return rest;
+}
+/** Project one source into the browser-facing summary. */
+function summarize$1(source) {
+	return {
+		id: source.id,
+		kind: source.kind,
+		url: source.url,
+		label: source.label ?? defaultSourceLabel(source.url),
+		enabled: source.enabled,
+		addedAt: source.addedAt,
+		hasBody: source.raw !== void 0,
+		...source.fetchedAt !== void 0 ? { fetchedAt: source.fetchedAt } : {},
+		...source.status !== void 0 ? { status: source.status } : {},
+		...source.error !== void 0 ? { error: source.error } : {},
+		...source.truncated === true ? { truncated: true } : {},
+		...source.failure === void 0 ? {} : { failure: {
+			code: source.failure.code,
+			message: source.failure.message
+		} },
+		...source.resolvedFrom === void 0 ? {} : { resolvedFrom: source.resolvedFrom }
+	};
+}
+/**
+* The same annotation with no `tagIds` key at all.
+*
+* Under `exactOptionalPropertyTypes` an explicit `undefined` is not the same as
+* an absent optional field, and this document is serialized straight to disk —
+* so an empty tag list must be an ABSENT key, not a null one.
+*
+* @param entry - the annotation to strip.
+* @returns the annotation without its tag list.
+*/
+function withoutTags(entry) {
+	const { tagIds: _removed, ...rest } = entry;
+	return rest;
+}
+/**
+* Drop annotations that carry nothing, so the document does not accumulate
+* empty objects as tags are removed.
+*
+* @param annotations - the table to clean.
+* @returns the table with empty entries removed.
+*/
+function cleanupAnnotations(annotations) {
+	const out = {};
+	for (const [entryId, entry] of Object.entries(annotations)) {
+		if (entry.body === void 0 && (entry.tagIds ?? []).length === 0 && entry.error === void 0 && entry.fetch === void 0 && entry.translation === void 0 && entry.title === void 0 && entry.excerpt === void 0) continue;
+		out[entryId] = (entry.tagIds ?? []).length > 0 ? entry : withoutTags(entry);
+	}
+	return out;
+}
+/**
+* Parse a translation sidecar's segment map, tolerating a damaged file.
+*
+* @param raw - the file's content, or `undefined` when it is gone.
+* @returns the map, or `undefined` when the file holds none.
+*/
+function readSegmentsFile(raw) {
+	if (raw === void 0) return void 0;
+	try {
+		const parsed = JSON.parse(raw);
+		if (typeof parsed !== "object" || parsed === null) return void 0;
+		return Object.fromEntries(Object.entries(parsed).filter(([, target]) => typeof target === "string"));
+	} catch {
+		return;
+	}
+}
+/**
+* Coerce one batch of learned sentences: bounded in count and in size, each
+* carrying its hash and both texts.
+*
+* @param entries - the client's batch.
+* @returns the entries worth storing.
+*/
+function normalizeLearns(entries) {
+	const out = [];
+	for (const entry of entries.slice(0, TRANSLATION_WRITE_LIMIT)) {
+		if (typeof entry.hash !== "string" || entry.hash.length === 0 || entry.hash.length > 64) continue;
+		if (typeof entry.source !== "string" || typeof entry.target !== "string") continue;
+		if (entry.source.length === 0 || entry.target.length === 0) continue;
+		out.push({
+			hash: entry.hash,
+			source: entry.source.slice(0, TRANSLATION_TEXT_LIMIT),
+			target: entry.target.slice(0, TRANSLATION_TEXT_LIMIT)
+		});
+	}
+	return out;
+}
+/** How old a `fetching` record may be before it is treated as abandoned. */
+const FETCH_STALE_MS = 6e5;
+/** Whether an ISO instant is recent enough to still mean "in flight". */
+function isRecent(iso, now, windowMs) {
+	const at = new Date(iso).getTime();
+	return Number.isFinite(at) && now - at <= windowMs;
+}
+/** Whether a cache deadline is still in the future. */
+function isFresh(expiresAt) {
+	const deadline = new Date(expiresAt).getTime();
+	return Number.isFinite(deadline) && deadline > Date.now();
+}
+//#endregion
+//#region lib/types/polish.js
+/**
+* The 润色 layer: an agent's paragraph-by-paragraph translation of an
+* article, written back through `reader_translate` and shown in place of the
+* browser's sentence-by-sentence machine translation.
+*
+* Keyed to the article's text as the model read it (the snapshot): a
+* re-transcription changes the text and so drops the layer; renaming a
+* speaker only changes the "[mm:ss] 名字：" prefixes and keeps it.
+*
+* One JSON file per article under `<state>/polish/`, memory-only when the
+* state root cannot be written.
+*
+* @module @khorsheed/dsh-reader/polish
+*/
+/** The time / speaker prefix of a transcript paragraph in the snapshot. */
+const PREFIX = /^\[\d+(?::\d+){1,2}\]\s*(?:[^：\n]{1,40}：)?/;
+/**
+* What a layer belongs to: the paragraphs' text without their time and
+* speaker prefixes, hashed.
+*/
+function sourceKey(paragraphs) {
+	const hash = createHash("sha1");
+	hash.update(String(paragraphs.length));
+	for (const paragraph of paragraphs) hash.update(`\n${paragraph.replace(PREFIX, "")}`);
+	return hash.digest("hex").slice(0, 24);
+}
+/** The per-article 润色 layers. */
+var ReaderPolishStore = class {
+	dir;
+	memory = /* @__PURE__ */ new Map();
+	constructor(stateRoot) {
+		this.dir = join(stateRoot, "polish");
+	}
+	fileOf(entryId) {
+		return join(this.dir, `${createHash("sha1").update(entryId).digest("hex").slice(0, 32)}.json`);
+	}
+	load(entryId) {
+		const cached = this.memory.get(entryId);
+		if (cached !== void 0) return cached;
+		try {
+			const parsed = JSON.parse(readFileSync(this.fileOf(entryId), "utf8"));
+			if (parsed.entryId !== entryId) return void 0;
+			this.memory.set(entryId, parsed);
+			return parsed;
+		} catch {
+			return;
+		}
+	}
+	save(file) {
+		this.memory.set(file.entryId, file);
+		try {
+			mkdirSync(this.dir, { recursive: true });
+			const target = this.fileOf(file.entryId);
+			writeFileSync(`${target}.tmp`, JSON.stringify(file));
+			renameSync(`${target}.tmp`, target);
+		} catch {}
+	}
+	/**
+	* An article's layer, when it belongs to the text now captured.
+	*
+	* @param entryId - the article.
+	* @param key - the current text's {@link sourceKey}.
+	*/
+	view(entryId, key) {
+		const file = this.load(entryId);
+		if (file === void 0 || key === void 0 || file.sourceKey !== key) return void 0;
+		const done = Object.keys(file.paragraphs).length;
+		return {
+			total: file.total,
+			done,
+			paragraphs: { ...file.paragraphs },
+			off: [...file.off],
+			updatedAt: file.updatedAt,
+			complete: done >= file.total
+		};
+	}
+	/**
+	* Merge the model's translations into the layer (a different text starts a
+	* fresh one).
+	*
+	* @returns the layer after the write.
+	*/
+	write(entryId, key, total, updates) {
+		const before = this.load(entryId);
+		const fresh = before === void 0 || before.sourceKey !== key;
+		const paragraphs = fresh ? {} : { ...before.paragraphs };
+		for (const [index, value] of updates) if (index >= 1 && index <= total) paragraphs[String(index)] = value;
+		const file = {
+			entryId,
+			sourceKey: key,
+			total,
+			paragraphs,
+			off: fresh ? [] : before.off,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		this.save(file);
+		return this.view(entryId, key);
+	}
+	/** Turn one paragraph back to (or away from) the machine translation. */
+	setOff(entryId, key, paragraph, off) {
+		const file = this.load(entryId);
+		if (file === void 0 || key === void 0 || file.sourceKey !== key) return void 0;
+		const rest = file.off.filter((item) => item !== paragraph);
+		this.save({
+			...file,
+			off: off ? [...rest, paragraph] : rest
+		});
+		return this.view(entryId, key);
+	}
+	/** Forget an article's layer. */
+	drop(entryId) {
+		this.memory.delete(entryId);
+		rmSync(this.fileOf(entryId), { force: true });
+	}
+};
+//#endregion
+//#region lib/types/notes.js
+/**
+* The reader's notes: excerpts the reader kept from an article, the comment on
+* each, which conversations discussed the article, and the article text the
+* model reads when it does.
+*
+* Notes are what the reader OWNS, so they live on the host next to the rest of
+* the reader's state (the state-boundaries note, rule 1) — but in their own
+* file, `notes.json`, not inside `state.json`'s per-entry annotations. An
+* annotation is shaped around the body cache: `boundAnnotations` evicts by
+* body, `normalizeAnnotations` drops entries that carry nothing it knows. A
+* note must outlive every one of those (the excerpt carries its own text), and
+* keeping it out of that machinery is what makes "the body was evicted" and
+* "the note is gone" two unrelated events.
+*
+* The article text is a second, separate concern: the host never parses an
+* article (the browser half does), and a feed entry's text never reaches the
+* host at all. So the browser hands over a SNAPSHOT — the article's original
+* prose, one string per top-level block, numbered the way the pane numbers its
+* blocks — and the model reads that. Snapshots are capped and pruned; notes
+* are never pruned.
+*
+* Persistence mirrors `store.ts`: native fs at the deployment's state root,
+* atomic temp-file-and-rename writes, and an in-memory document when the root
+* is not writable. Writes are serialized through one promise chain, so two
+* gestures landing together never read the same version and lose one.
+*
+* @module @khorsheed/dsh-reader/notes
+*/
+/** The notes document's file name inside the state root. */
+const READER_NOTES_FILE_NAME = "notes.json";
+/** Where article snapshots live, inside the state root. */
+const READER_SNAPSHOTS_DIR = "snapshots";
+/** Most notes one article keeps (a cap against a runaway client, not a quota anyone reaches). */
+const MAX_NOTES_PER_ENTRY = 500;
+/** Most conversations one article remembers. */
+const MAX_SESSIONS_PER_ENTRY = 50;
+/** Snapshots kept for articles with no notes and no discussions (the most recent ones). */
+const MAX_LOOSE_SNAPSHOTS = 30;
+/** The cap on one snapshot's total characters (a long paper fits; a book does not). */
+const MAX_SNAPSHOT_CHARS = 4e5;
+/** Most lines under one note. */
+const MAX_REPLIES_PER_NOTE = 50;
+/** Most discussion notes one article keeps (the oldest go first). */
+const MAX_DISCUSSIONS_PER_ENTRY = 100;
+/** Most points in one discussion note. */
+const MAX_POINTS = 30;
+/** The cap on one reply or one discussion point. */
+const MAX_POINT_CHARS = 4e3;
+/** The cap on one excerpt. */
+const MAX_QUOTE_CHARS = 2e3;
+/** The cap on one comment. */
+const MAX_COMMENT_CHARS = 4e3;
+/** The empty document. */
+function emptyNotesDoc() {
+	return {
+		version: 1,
+		entries: {},
+		snapshots: {}
+	};
+}
+/** A string field, trimmed and capped, or `undefined` when empty. */
+function text(value, cap) {
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	return trimmed.length === 0 ? void 0 : trimmed.slice(0, cap);
+}
+/** A timestamp field, or the epoch when it is missing. */
+function stamp(value) {
+	return typeof value === "string" && value.length > 0 ? value : (/* @__PURE__ */ new Date(0)).toISOString();
+}
+/** One note, when it carries an id and an excerpt. */
+function normalizeNote(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const record = value;
+	const id = text(record.id, 20);
+	const anchor = record.anchor;
+	const quote = text(anchor?.quote, MAX_QUOTE_CHARS);
+	if (id === void 0 || quote === void 0) return void 0;
+	const block = typeof anchor?.block === "number" && Number.isInteger(anchor.block) && anchor.block >= 0 ? anchor.block : 0;
+	const start = typeof anchor?.start === "number" && Number.isInteger(anchor.start) && anchor.start >= 0 ? anchor.start : void 0;
+	const translated = text(anchor?.translated, MAX_QUOTE_CHARS);
+	const time = typeof anchor?.time === "number" && Number.isFinite(anchor.time) && anchor.time >= 0 ? anchor.time : void 0;
+	const comment = text(record.comment, MAX_COMMENT_CHARS);
+	const replies = Array.isArray(record.replies) ? record.replies.map(normalizeReply).filter((reply) => reply !== void 0).slice(-50) : [];
+	return {
+		id,
+		anchor: {
+			block,
+			...start === void 0 ? {} : { start },
+			quote,
+			...translated === void 0 ? {} : { translated },
+			...time === void 0 ? {} : { time }
+		},
+		...comment === void 0 ? {} : { comment },
+		...replies.length === 0 ? {} : { replies },
+		...normalizeSynced(record.syncedTo).length === 0 ? {} : { syncedTo: normalizeSynced(record.syncedTo) },
+		createdAt: stamp(record.createdAt),
+		updatedAt: stamp(record.updatedAt ?? record.createdAt)
+	};
+}
+/** The canvas cards an item was synced to (bounded, malformed rows dropped). */
+function normalizeSynced(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((item) => {
+		if (typeof item !== "object" || item === null) return [];
+		const record = item;
+		const canvasId = text(record.canvasId, 200);
+		const cardId = text(record.cardId, 200);
+		if (canvasId === void 0 || cardId === void 0) return [];
+		return [{
+			canvasId,
+			cardId,
+			canvasTitle: text(record.canvasTitle, 200) ?? canvasId,
+			at: stamp(record.at)
+		}];
+	}).slice(-20);
+}
+/** One line under a note, when it has text. */
+function normalizeReply(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const record = value;
+	const body = text(record.text, MAX_POINT_CHARS);
+	if (body === void 0) return void 0;
+	const sessionId = text(record.sessionId, 200);
+	return {
+		by: record.by === "agent" ? "agent" : "user",
+		text: body,
+		...sessionId === void 0 ? {} : { sessionId },
+		...record.editedFrom === "agent" ? { editedFrom: "agent" } : {},
+		at: stamp(record.at)
 	};
-	if (hostOf(requestedUrl) !== host) return {
-		code: "redirected",
-		message: `the address redirected to ${finalUrl}, which yielded no readable page`
+}
+/** Bound a discussion's points: trimmed, capped, ¶ kept only when it is a positive integer. */
+function boundPoints(points) {
+	const out = [];
+	for (const item of points) {
+		if (typeof item !== "object" || item === null) continue;
+		const record = item;
+		const body = text(record.text, MAX_POINT_CHARS);
+		if (body === void 0) continue;
+		const para = typeof record.para === "number" && Number.isInteger(record.para) && record.para > 0 ? record.para : void 0;
+		out.push({
+			text: body,
+			...para === void 0 ? {} : { para }
+		});
+		if (out.length >= 30) break;
+	}
+	return out;
+}
+/** One discussion note, when it has an id and at least one point. */
+function normalizeDiscussion(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const record = value;
+	const id = text(record.id, 20);
+	const points = Array.isArray(record.points) ? boundPoints(record.points) : [];
+	if (id === void 0 || points.length === 0) return void 0;
+	const sessionId = text(record.sessionId, 200);
+	const aside = text(record.aside, 300);
+	return {
+		id,
+		kind: record.kind === "check" ? "check" : "discussion",
+		...sessionId === void 0 ? {} : { sessionId },
+		title: text(record.title, 200) ?? "",
+		points,
+		...aside === void 0 ? {} : { aside },
+		...normalizeSynced(record.syncedTo).length === 0 ? {} : { syncedTo: normalizeSynced(record.syncedTo) },
+		createdAt: stamp(record.createdAt)
 	};
+}
+/** One article's notes, when it has an id and a title. */
+function normalizeEntry(entryId, value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const record = value;
+	const title = text(record.title, 300) ?? entryId;
+	const notes = Array.isArray(record.notes) ? record.notes.map(normalizeNote).filter((note) => note !== void 0).slice(0, 500) : [];
+	const sessions = Array.isArray(record.sessions) ? record.sessions.flatMap((item) => {
+		if (typeof item !== "object" || item === null) return [];
+		const row = item;
+		const sessionId = text(row.sessionId, 200);
+		if (sessionId === void 0) return [];
+		const sessionTitle = text(row.title, 200);
+		return [{
+			sessionId,
+			...sessionTitle === void 0 ? {} : { title: sessionTitle },
+			lastAt: stamp(row.lastAt)
+		}];
+	}).slice(0, 50) : [];
+	const discussions = Array.isArray(record.discussions) ? record.discussions.map(normalizeDiscussion).filter((item) => item !== void 0).slice(0, 100) : [];
+	if (notes.length === 0 && sessions.length === 0 && discussions.length === 0) return void 0;
+	const highest = notes.reduce((max, note) => Math.max(max, Number(/^n(\d+)$/.exec(note.id)?.[1] ?? 0)), 0);
+	const stored = typeof record.nextNote === "number" && Number.isInteger(record.nextNote) ? record.nextNote : 1;
+	const highestDiscussion = discussions.reduce((max, item) => Math.max(max, Number(/^d(\d+)$/.exec(item.id)?.[1] ?? 0)), 0);
+	const storedDiscussion = typeof record.nextDiscussion === "number" && Number.isInteger(record.nextDiscussion) ? record.nextDiscussion : 1;
+	const url = text(record.url, 2e3);
+	const source = text(record.source, 200);
 	return {
-		code: "empty",
-		message: `the page yielded ${text} characters of text (${finalUrl})`
+		entryId,
+		title,
+		...url === void 0 ? {} : { url },
+		...source === void 0 ? {} : { source },
+		notes,
+		sessions,
+		...discussions.length === 0 ? {} : { discussions },
+		nextNote: Math.max(stored, highest + 1),
+		nextDiscussion: Math.max(storedDiscussion, highestDiscussion + 1),
+		updatedAt: stamp(record.updatedAt)
 	};
 }
 /**
-* Classify a thrown fetch failure into the reason the reader sees.
-*
-* Everything here is per-case diagnosable: the seam's own message is kept
-* verbatim, and only the CODE decides which sentence the browser shows and
-* whether an automatic retry is allowed.
+* Coerce a parsed value into a notes document, dropping what it cannot read.
 *
-* @param error - the value the fetch threw.
-* @param at - the failure instant (ISO-8601).
-* @returns the recorded failure.
+* @param value - the parsed file.
+* @returns the document.
 */
-function classifyFetchFailure(error, at) {
-	const message = errorMessage(error);
-	const code = errorCode(error);
-	if (code === "WEB_UNSUPPORTED_CONTENT_TYPE" || /unsupported content type/i.test(message)) return {
-		code: "unsupported-type",
-		message,
-		at
-	};
-	if (code === "WEB_REDIRECT_BLOCKED" || /cross-origin redirect/i.test(message)) {
-		const origin = /cross-origin redirect to (\S+)/i.exec(message)?.[1];
-		return {
-			code: origin !== void 0 && LOGIN_HOST_PATTERN.test(hostOf(origin)) ? "login" : "redirected",
-			message,
-			at
+function normalizeNotesDoc(value) {
+	if (typeof value !== "object" || value === null) return emptyNotesDoc();
+	const record = value;
+	const entries = {};
+	if (typeof record.entries === "object" && record.entries !== null) for (const [entryId, entry] of Object.entries(record.entries)) {
+		if (entryId.length === 0) continue;
+		const normalized = normalizeEntry(entryId, entry);
+		if (normalized !== void 0) entries[entryId] = normalized;
+	}
+	const snapshots = {};
+	if (typeof record.snapshots === "object" && record.snapshots !== null) for (const [entryId, row] of Object.entries(record.snapshots)) {
+		if (typeof row !== "object" || row === null) continue;
+		const item = row;
+		const file = typeof item.file === "string" && /^[0-9a-f]{32}\.json$/.test(item.file) ? item.file : void 0;
+		if (file === void 0) continue;
+		snapshots[entryId] = {
+			file,
+			chars: typeof item.chars === "number" && Number.isFinite(item.chars) ? item.chars : 0,
+			capturedAt: stamp(item.capturedAt)
 		};
 	}
-	const status = /\bHTTP (\d{3})\b/.exec(message)?.[1];
-	if (status === "401" || status === "403") return {
-		code: "blocked",
-		message,
-		at
-	};
-	if (status !== void 0) return {
-		code: "http",
-		message,
-		at
-	};
 	return {
-		code: "unreachable",
-		message,
-		at
+		version: 1,
+		entries,
+		snapshots
 	};
 }
-/** The host of a URL, or an empty string when it cannot be parsed. */
-function hostOf(url) {
-	try {
-		return new URL(url).hostname.toLowerCase();
-	} catch {
-		return "";
-	}
-}
 /**
-* How much visible text a payload carries.
-*
-* Script, style and markup are stripped; entities collapse to a single space.
-* This is a measurement, not a parser: its only job is to separate "a page"
-* from "an interstitial that is technically HTML".
+* Bound a snapshot's paragraphs: whitespace collapsed, empty blocks kept as
+* empty strings (so ¶ numbers stay aligned with the pane's blocks), and the
+* whole capped — cut at a paragraph boundary, with the cut reported.
 *
-* @param raw - the decoded payload.
-* @returns the visible character count.
+* @param paragraphs - the blocks' original text.
+* @returns the bounded paragraphs and whether anything was dropped.
 */
-function visibleTextLength(raw) {
-	return raw.replace(/<script[\s\S]*?<\/script\s*>/gi, " ").replace(/<style[\s\S]*?<\/style\s*>/gi, " ").replace(/<[^>]*>/g, " ").replace(/&[a-z#0-9]+;/gi, " ").replace(/\s+/g, " ").trim().length;
+function boundParagraphs(paragraphs) {
+	const out = [];
+	let total = 0;
+	for (const raw of paragraphs) {
+		const block = typeof raw === "string" ? raw.replace(/\s+/g, " ").trim() : "";
+		if (total + block.length > 4e5) return {
+			paragraphs: out,
+			truncated: true
+		};
+		out.push(block);
+		total += block.length;
+	}
+	return {
+		paragraphs: out,
+		truncated: false
+	};
 }
-/** The same source with any recorded preview failure removed. */
-function withoutFailure(source) {
-	const { failure: _removed, ...rest } = source;
-	return rest;
+/** The bare file name one entry's snapshot lives under. */
+function snapshotFileName(entryId) {
+	return `${createHash("sha1").update(entryId).digest("hex").slice(0, 32)}.json`;
 }
-/** Project one source into the browser-facing summary. */
-function summarize$1(source) {
+/** A native fs failure's message, with its code. */
+function errorMessage$1(error) {
+	const code = error?.code;
+	const message = error instanceof Error ? error.message : String(error);
+	return code === void 0 ? message : `${code}: ${message}`;
+}
+/** Write a file atomically (temp file, then rename). */
+function writeAtomic(target, content) {
+	const temporary = `${target}.${process.pid}.tmp`;
+	try {
+		writeFileSync(temporary, content);
+		renameSync(temporary, target);
+	} catch (error) {
+		rmSync(temporary, { force: true });
+		throw new Error(`reader: ${target} could not be written — ${errorMessage$1(error)}`);
+	}
+}
+/** The entry row a write lands on: the existing one refreshed with the latest identity, or a new one. */
+function entryFor(doc, identity, now) {
+	const existing = doc.entries[identity.entryId];
+	const title = identity.title.trim().slice(0, 300) || existing?.title || identity.entryId;
+	const url = identity.url ?? existing?.url;
+	const source = identity.source ?? existing?.source;
 	return {
-		id: source.id,
-		kind: source.kind,
-		url: source.url,
-		label: source.label ?? defaultSourceLabel(source.url),
-		enabled: source.enabled,
-		addedAt: source.addedAt,
-		hasBody: source.raw !== void 0,
-		...source.fetchedAt !== void 0 ? { fetchedAt: source.fetchedAt } : {},
-		...source.status !== void 0 ? { status: source.status } : {},
-		...source.error !== void 0 ? { error: source.error } : {},
-		...source.truncated === true ? { truncated: true } : {},
-		...source.failure === void 0 ? {} : { failure: {
-			code: source.failure.code,
-			message: source.failure.message
-		} },
-		...source.resolvedFrom === void 0 ? {} : { resolvedFrom: source.resolvedFrom }
+		entryId: identity.entryId,
+		title,
+		...url === void 0 || url === "" ? {} : { url },
+		...source === void 0 || source === "" ? {} : { source },
+		notes: existing?.notes ?? [],
+		sessions: existing?.sessions ?? [],
+		...existing?.discussions === void 0 ? {} : { discussions: existing.discussions },
+		nextNote: existing?.nextNote ?? 1,
+		nextDiscussion: existing?.nextDiscussion ?? 1,
+		updatedAt: now
 	};
 }
-/**
-* The same annotation with no `tagIds` key at all.
-*
-* Under `exactOptionalPropertyTypes` an explicit `undefined` is not the same as
-* an absent optional field, and this document is serialized straight to disk —
-* so an empty tag list must be an ABSENT key, not a null one.
-*
-* @param entry - the annotation to strip.
-* @returns the annotation without its tag list.
-*/
-function withoutTags(entry) {
-	const { tagIds: _removed, ...rest } = entry;
-	return rest;
+/** The document with one entry replaced (or removed, when it no longer carries anything). */
+function withEntry(doc, entry) {
+	const { [entry.entryId]: _previous, ...rest } = doc.entries;
+	return entry.notes.length === 0 && entry.sessions.length === 0 && (entry.discussions ?? []).length === 0 ? {
+		...doc,
+		entries: rest
+	} : {
+		...doc,
+		entries: {
+			...rest,
+			[entry.entryId]: entry
+		}
+	};
 }
-/**
-* Drop annotations that carry nothing, so the document does not accumulate
-* empty objects as tags are removed.
-*
-* @param annotations - the table to clean.
-* @returns the table with empty entries removed.
-*/
-function cleanupAnnotations(annotations) {
-	const out = {};
-	for (const [entryId, entry] of Object.entries(annotations)) {
-		if (entry.body === void 0 && (entry.tagIds ?? []).length === 0 && entry.error === void 0 && entry.fetch === void 0 && entry.translation === void 0 && entry.title === void 0 && entry.excerpt === void 0) continue;
-		out[entryId] = (entry.tagIds ?? []).length > 0 ? entry : withoutTags(entry);
+/** The reader's notes store. */
+var ReaderNotesStore = class {
+	root;
+	file;
+	snapshotsDir;
+	unwritable;
+	/** The document of record when the root is not writable. */
+	memoryDoc;
+	/** Snapshots kept in memory when the root is not writable. */
+	memorySnapshots = /* @__PURE__ */ new Map();
+	/** The write queue: every mutation runs after the previous one settled. */
+	queue = Promise.resolve();
+	/** The agent's 润色 translations, per article (keyed to the snapshot's text). */
+	polish;
+	/**
+	* @param config - the same state-root override the reader's main store takes.
+	*/
+	constructor(config = {}) {
+		this.root = resolveReaderStateRoot(config.stateRoot);
+		this.file = join(this.root, READER_NOTES_FILE_NAME);
+		this.snapshotsDir = join(this.root, READER_SNAPSHOTS_DIR);
+		this.polish = new ReaderPolishStore(this.root);
+	}
+	/** An article's 润色 layer, when it belongs to the text captured now. */
+	polishView(entryId) {
+		const snapshot = this.readSnapshot(entryId);
+		return this.polish.view(entryId, snapshot === void 0 ? void 0 : sourceKey(snapshot.paragraphs));
+	}
+	/** Turn one paragraph back to the machine translation, or to the 润色 again. */
+	setPolishOff(entryId, paragraph, off) {
+		const snapshot = this.readSnapshot(entryId);
+		return this.polish.setOff(entryId, snapshot === void 0 ? void 0 : sourceKey(snapshot.paragraphs), paragraph, off);
+	}
+	/** Whether the notes persist (false means memory-only, for this process). */
+	get available() {
+		if (this.unwritable !== void 0) return false;
+		try {
+			mkdirSync(this.root, { recursive: true });
+			return true;
+		} catch (error) {
+			this.unwritable = `${this.root}: ${errorMessage$1(error)}`;
+			return false;
+		}
+	}
+	/** Read the document; a missing or unreadable file reads as empty. */
+	read() {
+		if (!this.available) return this.memoryDoc ?? emptyNotesDoc();
+		try {
+			return normalizeNotesDoc(JSON.parse(readFileSync(this.file, "utf8")));
+		} catch (error) {
+			if (error.code === "ENOENT") return emptyNotesDoc();
+			throw new Error(`reader: ${this.file} does not parse — fix or remove it by hand`);
+		}
+	}
+	/** Run one read-modify-write after every earlier one. */
+	update(mutate) {
+		const run = this.queue.then(() => {
+			const { doc, result } = mutate(this.read());
+			if (this.available) writeAtomic(this.file, `${JSON.stringify(doc, null, 2)}\n`);
+			else this.memoryDoc = doc;
+			return result;
+		});
+		this.queue = run.catch(() => void 0);
+		return run;
+	}
+	/** One article's notes and discussions, oldest note first. */
+	entry(entryId) {
+		return this.read().entries[entryId];
+	}
+	/** Every article that carries notes or discussions. */
+	entries() {
+		return Object.values(this.read().entries);
+	}
+	/** How many notes each article carries (the wall's badge). */
+	counts() {
+		const counts = {};
+		for (const entry of Object.values(this.read().entries)) if (entry.notes.length > 0) counts[entry.entryId] = entry.notes.length;
+		return counts;
+	}
+	/**
+	* Keep one excerpt.
+	*
+	* @param input - the article, the excerpt and where it sits, and the comment.
+	* @returns the new note, or why none was kept.
+	*/
+	addNote(input) {
+		const quote = input.quote.replace(/\s+/g, " ").trim().slice(0, MAX_QUOTE_CHARS);
+		if (quote.length === 0 || input.entryId.length === 0) return Promise.resolve("empty");
+		return this.update((doc) => {
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const entry = entryFor(doc, input, now);
+			if (entry.notes.length >= 500) return {
+				doc,
+				result: "full"
+			};
+			const translated = input.translated?.replace(/\s+/g, " ").trim().slice(0, MAX_QUOTE_CHARS);
+			const comment = input.comment?.trim().slice(0, MAX_COMMENT_CHARS);
+			const note = {
+				id: `n${String(entry.nextNote)}`,
+				anchor: {
+					block: Number.isInteger(input.block) && input.block >= 0 ? input.block : 0,
+					...input.start !== void 0 && Number.isInteger(input.start) && input.start >= 0 ? { start: input.start } : {},
+					quote,
+					...translated === void 0 || translated === "" ? {} : { translated },
+					...input.time !== void 0 && Number.isFinite(input.time) && input.time >= 0 ? { time: input.time } : {}
+				},
+				...comment === void 0 || comment === "" ? {} : { comment },
+				createdAt: now,
+				updatedAt: now
+			};
+			const notes = [...entry.notes, note].sort((left, right) => left.anchor.block - right.anchor.block || (left.anchor.start ?? 0) - (right.anchor.start ?? 0));
+			return {
+				doc: withEntry(doc, {
+					...entry,
+					notes,
+					nextNote: entry.nextNote + 1
+				}),
+				result: note
+			};
+		});
+	}
+	/** Change (or clear) one note's comment. */
+	updateNote(request) {
+		return this.update((doc) => {
+			const entry = doc.entries[request.entryId];
+			const note = entry?.notes.find((item) => item.id === request.noteId);
+			if (entry === void 0 || note === void 0) return {
+				doc,
+				result: "not-found"
+			};
+			const comment = request.comment.trim().slice(0, MAX_COMMENT_CHARS);
+			const { comment: _old, ...rest } = note;
+			const next = {
+				...rest,
+				...comment === "" ? {} : { comment },
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			const notes = entry.notes.map((item) => item.id === note.id ? next : item);
+			return {
+				doc: withEntry(doc, {
+					...entry,
+					notes,
+					updatedAt: next.updatedAt
+				}),
+				result: "ok"
+			};
+		});
+	}
+	/** Delete one note (its id is not handed out again). */
+	deleteNote(request) {
+		return this.update((doc) => {
+			const entry = doc.entries[request.entryId];
+			if (entry === void 0 || !entry.notes.some((item) => item.id === request.noteId)) return {
+				doc,
+				result: "not-found"
+			};
+			const notes = entry.notes.filter((item) => item.id !== request.noteId);
+			return {
+				doc: withEntry(doc, {
+					...entry,
+					notes,
+					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				}),
+				result: "ok"
+			};
+		});
+	}
+	/**
+	* Add one line under a note: a conclusion (by the model, when the reader asked
+	* for it) or the reader's own addition.
+	*
+	* @param request - the article, the note, the line and who wrote it.
+	*/
+	addReply(request) {
+		const body = request.text.trim().slice(0, MAX_POINT_CHARS);
+		if (body.length === 0) return Promise.resolve("empty");
+		return this.update((doc) => {
+			const entry = doc.entries[request.entryId];
+			const note = entry?.notes.find((item) => item.id === request.noteId);
+			if (entry === void 0 || note === void 0) return {
+				doc,
+				result: "not-found"
+			};
+			const replies = note.replies ?? [];
+			if (replies.length >= 50) return {
+				doc,
+				result: "full"
+			};
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const reply = {
+				by: request.by,
+				text: body,
+				...request.sessionId === void 0 || request.sessionId === "" ? {} : { sessionId: request.sessionId },
+				at: now
+			};
+			const notes = entry.notes.map((item) => item.id === note.id ? {
+				...item,
+				replies: [...replies, reply],
+				updatedAt: now
+			} : item);
+			return {
+				doc: withEntry(doc, {
+					...entry,
+					notes,
+					updatedAt: now
+				}),
+				result: "ok"
+			};
+		});
+	}
+	/**
+	* Rewrite (or, with empty text, remove) one line under a note. A line the
+	* model wrote becomes the reader's, marked as rewritten from the model's.
+	*/
+	editReply(request) {
+		return this.update((doc) => {
+			const entry = doc.entries[request.entryId];
+			const note = entry?.notes.find((item) => item.id === request.noteId);
+			const replies = note?.replies ?? [];
+			const old = replies[request.index];
+			if (entry === void 0 || note === void 0 || old === void 0) return {
+				doc,
+				result: "not-found"
+			};
+			const body = request.text.trim().slice(0, MAX_POINT_CHARS);
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const next = body === "" ? replies.filter((_, index) => index !== request.index) : replies.map((item, index) => index !== request.index ? item : {
+				...item,
+				by: "user",
+				text: body,
+				...item.by === "agent" || item.editedFrom === "agent" ? { editedFrom: "agent" } : {},
+				at: now
+			});
+			const { replies: _old, ...rest } = note;
+			const notes = entry.notes.map((item) => item.id === note.id ? {
+				...rest,
+				...next.length === 0 ? {} : { replies: next },
+				updatedAt: now
+			} : item);
+			return {
+				doc: withEntry(doc, {
+					...entry,
+					notes,
+					updatedAt: now
+				}),
+				result: "ok"
+			};
+		});
+	}
+	/**
+	* Keep one discussion note (newest first). The conversation it came from is
+	* remembered on the article too.
+	*
+	* @param input - the article, the kind, the points.
+	* @returns the new discussion note, or why none was kept.
+	*/
+	addDiscussion(input) {
+		const points = boundPoints(input.points);
+		if (points.length === 0 || input.entryId.length === 0) return Promise.resolve("empty");
+		return this.update((doc) => {
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const entry = entryFor(doc, input, now);
+			const number = entry.nextDiscussion ?? 1;
+			const aside = input.aside?.trim().slice(0, 300);
+			const sessionId = input.sessionId?.trim();
+			const discussion = {
+				id: `d${String(number)}`,
+				kind: input.kind === "check" ? "check" : "discussion",
+				...sessionId === void 0 || sessionId === "" ? {} : { sessionId },
+				title: input.heading?.trim().slice(0, 200) ?? "",
+				points,
+				...aside === void 0 || aside === "" ? {} : { aside },
+				createdAt: now
+			};
+			const sessions = sessionId === void 0 || sessionId === "" ? entry.sessions : [entry.sessions.find((item) => item.sessionId === sessionId) === void 0 ? {
+				sessionId,
+				lastAt: now
+			} : {
+				...entry.sessions.find((item) => item.sessionId === sessionId),
+				lastAt: now
+			}, ...entry.sessions.filter((item) => item.sessionId !== sessionId)].slice(0, 50);
+			const discussions = [discussion, ...entry.discussions ?? []].slice(0, 100);
+			return {
+				doc: withEntry(doc, {
+					...entry,
+					sessions,
+					discussions,
+					nextDiscussion: number + 1
+				}),
+				result: discussion
+			};
+		});
+	}
+	/**
+	* Remember that a note (or a discussion note) became a canvas card, so the
+	* notes face can say where it went and not offer the same sync twice blindly.
+	*/
+	markSynced(request) {
+		return this.update((doc) => {
+			const entry = doc.entries[request.entryId];
+			if (entry === void 0) return {
+				doc,
+				result: "not-found"
+			};
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const card = {
+				canvasId: request.canvasId,
+				cardId: request.cardId,
+				canvasTitle: request.canvasTitle.slice(0, 200),
+				at: now
+			};
+			if (request.noteId !== void 0) {
+				if (!entry.notes.some((item) => item.id === request.noteId)) return {
+					doc,
+					result: "not-found"
+				};
+				const notes = entry.notes.map((item) => item.id === request.noteId ? {
+					...item,
+					syncedTo: [...item.syncedTo ?? [], card].slice(-20)
+				} : item);
+				return {
+					doc: withEntry(doc, {
+						...entry,
+						notes
+					}),
+					result: "ok"
+				};
+			}
+			const discussions = entry.discussions ?? [];
+			if (request.discussionId === void 0 || !discussions.some((item) => item.id === request.discussionId)) return {
+				doc,
+				result: "not-found"
+			};
+			const next = discussions.map((item) => item.id === request.discussionId ? {
+				...item,
+				syncedTo: [...item.syncedTo ?? [], card].slice(-20)
+			} : item);
+			return {
+				doc: withEntry(doc, {
+					...entry,
+					discussions: next
+				}),
+				result: "ok"
+			};
+		});
+	}
+	/** Delete one discussion note. */
+	deleteDiscussion(request) {
+		return this.update((doc) => {
+			const entry = doc.entries[request.entryId];
+			if (entry === void 0 || !(entry.discussions ?? []).some((item) => item.id === request.discussionId)) return {
+				doc,
+				result: "not-found"
+			};
+			const discussions = (entry.discussions ?? []).filter((item) => item.id !== request.discussionId);
+			return {
+				doc: withEntry(doc, {
+					...entry,
+					discussions,
+					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				}),
+				result: "ok"
+			};
+		});
 	}
-	return out;
-}
-/**
-* Parse a translation sidecar's segment map, tolerating a damaged file.
-*
-* @param raw - the file's content, or `undefined` when it is gone.
-* @returns the map, or `undefined` when the file holds none.
-*/
-function readSegmentsFile(raw) {
-	if (raw === void 0) return void 0;
-	try {
-		const parsed = JSON.parse(raw);
-		if (typeof parsed !== "object" || parsed === null) return void 0;
-		return Object.fromEntries(Object.entries(parsed).filter(([, target]) => typeof target === "string"));
-	} catch {
-		return;
+	/**
+	* The article this conversation discussed most recently, when there is one —
+	* where a model's write lands when it names no article.
+	*/
+	sessionEntry(sessionId) {
+		let best;
+		for (const entry of Object.values(this.read().entries)) {
+			const row = entry.sessions.find((item) => item.sessionId === sessionId);
+			if (row !== void 0 && (best === void 0 || row.lastAt > best.at)) best = {
+				entryId: entry.entryId,
+				at: row.lastAt
+			};
+		}
+		return best?.entryId;
 	}
-}
-/**
-* Coerce one batch of learned sentences: bounded in count and in size, each
-* carrying its hash and both texts.
-*
-* @param entries - the client's batch.
-* @returns the entries worth storing.
-*/
-function normalizeLearns(entries) {
-	const out = [];
-	for (const entry of entries.slice(0, TRANSLATION_WRITE_LIMIT)) {
-		if (typeof entry.hash !== "string" || entry.hash.length === 0 || entry.hash.length > 64) continue;
-		if (typeof entry.source !== "string" || typeof entry.target !== "string") continue;
-		if (entry.source.length === 0 || entry.target.length === 0) continue;
-		out.push({
-			hash: entry.hash,
-			source: entry.source.slice(0, TRANSLATION_TEXT_LIMIT),
-			target: entry.target.slice(0, TRANSLATION_TEXT_LIMIT)
+	/**
+	* Remember that a conversation discussed this article (most recent first).
+	*
+	* @param request - the article and the conversation.
+	*/
+	recordSession(request) {
+		const sessionId = request.sessionId.trim();
+		if (sessionId.length === 0 || request.entryId.length === 0) return Promise.resolve("empty");
+		return this.update((doc) => {
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const entry = entryFor(doc, request, now);
+			const previous = entry.sessions.find((item) => item.sessionId === sessionId);
+			const title = request.sessionTitle?.trim().slice(0, 200) || previous?.title;
+			const sessions = [{
+				sessionId,
+				...title === void 0 || title === "" ? {} : { title },
+				lastAt: now
+			}, ...entry.sessions.filter((item) => item.sessionId !== sessionId)].slice(0, 50);
+			return {
+				doc: withEntry(doc, {
+					...entry,
+					sessions
+				}),
+				result: "ok"
+			};
 		});
 	}
-	return out;
-}
-/** How old a `fetching` record may be before it is treated as abandoned. */
-const FETCH_STALE_MS = 6e5;
-/** Whether an ISO instant is recent enough to still mean "in flight". */
-function isRecent(iso, now, windowMs) {
-	const at = new Date(iso).getTime();
-	return Number.isFinite(at) && now - at <= windowMs;
-}
-/** Whether a cache deadline is still in the future. */
-function isFresh(expiresAt) {
-	const deadline = new Date(expiresAt).getTime();
-	return Number.isFinite(deadline) && deadline > Date.now();
-}
+	/**
+	* Keep the article's text for the model, replacing the previous snapshot.
+	*
+	* Loose snapshots (articles with no notes and no discussions) are pruned to
+	* the {@link MAX_LOOSE_SNAPSHOTS} most recent; the rest are kept as long as
+	* their article carries anything.
+	*
+	* @param request - the article and its blocks' original text.
+	*/
+	snapshot(request) {
+		const { paragraphs, truncated } = boundParagraphs(request.paragraphs);
+		if (request.entryId.length === 0 || paragraphs.every((item) => item.length === 0)) return Promise.resolve("empty");
+		const snapshot = {
+			entryId: request.entryId,
+			title: request.title.trim().slice(0, 300) || request.entryId,
+			...request.url === void 0 || request.url === "" ? {} : { url: request.url },
+			...request.source === void 0 || request.source === "" ? {} : { source: request.source },
+			paragraphs,
+			...truncated ? { truncated: true } : {},
+			capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		return this.update((doc) => {
+			if (!this.available) {
+				this.memorySnapshots.set(snapshot.entryId, snapshot);
+				return {
+					doc,
+					result: "ok"
+				};
+			}
+			mkdirSync(this.snapshotsDir, { recursive: true });
+			const file = snapshotFileName(snapshot.entryId);
+			writeAtomic(join(this.snapshotsDir, file), `${JSON.stringify(snapshot)}\n`);
+			const chars = paragraphs.reduce((sum, item) => sum + item.length, 0);
+			const snapshots = {
+				...doc.snapshots,
+				[snapshot.entryId]: {
+					file,
+					chars,
+					capturedAt: snapshot.capturedAt
+				}
+			};
+			const loose = Object.entries(snapshots).filter(([entryId]) => doc.entries[entryId] === void 0).sort((left, right) => right[1].capturedAt.localeCompare(left[1].capturedAt));
+			for (const [entryId, row] of loose.slice(30)) {
+				delete snapshots[entryId];
+				rmSync(join(this.snapshotsDir, row.file), { force: true });
+			}
+			return {
+				doc: {
+					...doc,
+					snapshots
+				},
+				result: "ok"
+			};
+		});
+	}
+	/** The article's text as last captured, when there is one. */
+	readSnapshot(entryId) {
+		if (!this.available) return this.memorySnapshots.get(entryId);
+		const row = this.read().snapshots[entryId];
+		if (row === void 0) return void 0;
+		try {
+			const parsed = JSON.parse(readFileSync(join(this.snapshotsDir, row.file), "utf8"));
+			if (!Array.isArray(parsed.paragraphs)) return void 0;
+			return {
+				entryId,
+				title: text(parsed.title, 300) ?? entryId,
+				...typeof parsed.url === "string" && parsed.url !== "" ? { url: parsed.url } : {},
+				...typeof parsed.source === "string" && parsed.source !== "" ? { source: parsed.source } : {},
+				paragraphs: parsed.paragraphs.map((item) => typeof item === "string" ? item : ""),
+				...parsed.truncated === true ? { truncated: true } : {},
+				capturedAt: stamp(parsed.capturedAt)
+			};
+		} catch {
+			return;
+		}
+	}
+	/** Every article with a snapshot, newest capture first. */
+	snapshotIds() {
+		if (!this.available) return [...this.memorySnapshots.keys()].reverse();
+		return Object.entries(this.read().snapshots).sort((left, right) => right[1].capturedAt.localeCompare(left[1].capturedAt)).map(([entryId]) => entryId);
+	}
+};
 //#endregion
 //#region lib/types/remote.js
 var __runInitializers = function(thisArg, initializers, value) {
@@ -3586,6 +6412,26 @@ let ReaderRemoteService = (() => {
 	let _listRecent_decorators;
 	let _clearRecent_decorators;
 	let _quoteToSideChat_decorators;
+	let _entryNotes_decorators;
+	let _noteCounts_decorators;
+	let _addNote_decorators;
+	let _updateNote_decorators;
+	let _deleteNote_decorators;
+	let _recordDiscussion_decorators;
+	let _addReply_decorators;
+	let _editReply_decorators;
+	let _markSynced_decorators;
+	let _deleteDiscussion_decorators;
+	let _mediaTranscript_decorators;
+	let _startLocalTranscript_decorators;
+	let _localTranscript_decorators;
+	let _speakerNames_decorators;
+	let _nameSpeaker_decorators;
+	let _mediaStates_decorators;
+	let _cancelLocalTranscript_decorators;
+	let _polish_decorators;
+	let _setPolishOff_decorators;
+	let _snapshotEntry_decorators;
 	return class ReaderRemoteService extends _classSuper {
 		static {
 			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
@@ -3621,6 +6467,26 @@ let ReaderRemoteService = (() => {
 			_listRecent_decorators = [Remote("listRecent")];
 			_clearRecent_decorators = [Remote("clearRecent")];
 			_quoteToSideChat_decorators = [Remote("quoteToSideChat")];
+			_entryNotes_decorators = [Remote("entryNotes")];
+			_noteCounts_decorators = [Remote("noteCounts")];
+			_addNote_decorators = [Remote("addNote")];
+			_updateNote_decorators = [Remote("updateNote")];
+			_deleteNote_decorators = [Remote("deleteNote")];
+			_recordDiscussion_decorators = [Remote("recordDiscussion")];
+			_addReply_decorators = [Remote("addReply")];
+			_editReply_decorators = [Remote("editReply")];
+			_markSynced_decorators = [Remote("markSynced")];
+			_deleteDiscussion_decorators = [Remote("deleteDiscussion")];
+			_mediaTranscript_decorators = [Remote("mediaTranscript")];
+			_startLocalTranscript_decorators = [Remote("startLocalTranscript")];
+			_localTranscript_decorators = [Remote("localTranscript")];
+			_speakerNames_decorators = [Remote("speakerNames")];
+			_nameSpeaker_decorators = [Remote("nameSpeaker")];
+			_mediaStates_decorators = [Remote("mediaStates")];
+			_cancelLocalTranscript_decorators = [Remote("cancelLocalTranscript")];
+			_polish_decorators = [Remote("polish")];
+			_setPolishOff_decorators = [Remote("setPolishOff")];
+			_snapshotEntry_decorators = [Remote("snapshotEntry")];
 			__esDecorate(this, null, _capabilities_decorators, {
 				kind: "method",
 				name: "capabilities",
@@ -3973,6 +6839,226 @@ let ReaderRemoteService = (() => {
 				},
 				metadata: _metadata
 			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _entryNotes_decorators, {
+				kind: "method",
+				name: "entryNotes",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "entryNotes" in obj,
+					get: (obj) => obj.entryNotes
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _noteCounts_decorators, {
+				kind: "method",
+				name: "noteCounts",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "noteCounts" in obj,
+					get: (obj) => obj.noteCounts
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _addNote_decorators, {
+				kind: "method",
+				name: "addNote",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "addNote" in obj,
+					get: (obj) => obj.addNote
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _updateNote_decorators, {
+				kind: "method",
+				name: "updateNote",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "updateNote" in obj,
+					get: (obj) => obj.updateNote
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _deleteNote_decorators, {
+				kind: "method",
+				name: "deleteNote",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "deleteNote" in obj,
+					get: (obj) => obj.deleteNote
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _recordDiscussion_decorators, {
+				kind: "method",
+				name: "recordDiscussion",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "recordDiscussion" in obj,
+					get: (obj) => obj.recordDiscussion
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _addReply_decorators, {
+				kind: "method",
+				name: "addReply",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "addReply" in obj,
+					get: (obj) => obj.addReply
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _editReply_decorators, {
+				kind: "method",
+				name: "editReply",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "editReply" in obj,
+					get: (obj) => obj.editReply
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _markSynced_decorators, {
+				kind: "method",
+				name: "markSynced",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "markSynced" in obj,
+					get: (obj) => obj.markSynced
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _deleteDiscussion_decorators, {
+				kind: "method",
+				name: "deleteDiscussion",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "deleteDiscussion" in obj,
+					get: (obj) => obj.deleteDiscussion
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _mediaTranscript_decorators, {
+				kind: "method",
+				name: "mediaTranscript",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "mediaTranscript" in obj,
+					get: (obj) => obj.mediaTranscript
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _startLocalTranscript_decorators, {
+				kind: "method",
+				name: "startLocalTranscript",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "startLocalTranscript" in obj,
+					get: (obj) => obj.startLocalTranscript
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _localTranscript_decorators, {
+				kind: "method",
+				name: "localTranscript",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "localTranscript" in obj,
+					get: (obj) => obj.localTranscript
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _speakerNames_decorators, {
+				kind: "method",
+				name: "speakerNames",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "speakerNames" in obj,
+					get: (obj) => obj.speakerNames
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _nameSpeaker_decorators, {
+				kind: "method",
+				name: "nameSpeaker",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "nameSpeaker" in obj,
+					get: (obj) => obj.nameSpeaker
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _mediaStates_decorators, {
+				kind: "method",
+				name: "mediaStates",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "mediaStates" in obj,
+					get: (obj) => obj.mediaStates
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _cancelLocalTranscript_decorators, {
+				kind: "method",
+				name: "cancelLocalTranscript",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "cancelLocalTranscript" in obj,
+					get: (obj) => obj.cancelLocalTranscript
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _polish_decorators, {
+				kind: "method",
+				name: "polish",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "polish" in obj,
+					get: (obj) => obj.polish
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _setPolishOff_decorators, {
+				kind: "method",
+				name: "setPolishOff",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "setPolishOff" in obj,
+					get: (obj) => obj.setPolishOff
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _snapshotEntry_decorators, {
+				kind: "method",
+				name: "snapshotEntry",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "snapshotEntry" in obj,
+					get: (obj) => obj.snapshotEntry
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
 			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
 				enumerable: true,
 				configurable: true,
@@ -3980,7 +7066,7 @@ let ReaderRemoteService = (() => {
 				value: _metadata
 			});
 		}
-		static inject = ["reader"];
+		static inject = ["reader", "readerNotes"];
 		constructor(ctx, _config = {}) {
 			super(ctx, "readerRemote", { namespace: "reader" });
 			__runInitializers(this, _instanceExtraInitializers);
@@ -3989,6 +7075,10 @@ let ReaderRemoteService = (() => {
 		get core() {
 			return this.ctx.reader;
 		}
+		/** The notes store this face delegates to. */
+		get notes() {
+			return this.ctx.readerNotes;
+		}
 		/** Capability handshake: what the browser may rely on in this composition. */
 		capabilities() {
 			return this.core.capabilities();
@@ -4120,6 +7210,94 @@ let ReaderRemoteService = (() => {
 		quoteToSideChat(request) {
 			return this.core.quoteToSideChat(request);
 		}
+		/** One article's notes and the conversations that discussed it. */
+		async entryNotes(request) {
+			const entry = this.notes.entry(request.entryId);
+			return entry === void 0 ? {} : { entry };
+		}
+		/** How many notes each article carries. */
+		async noteCounts() {
+			return { counts: this.notes.counts() };
+		}
+		/** Keep one excerpt (and its comment). */
+		addNote(request) {
+			return this.notes.addNote(request);
+		}
+		/** Change or clear one note's comment. */
+		updateNote(request) {
+			return this.notes.updateNote(request);
+		}
+		/** Delete one note. */
+		deleteNote(request) {
+			return this.notes.deleteNote(request);
+		}
+		/** Remember that a conversation discussed this article. */
+		recordDiscussion(request) {
+			return this.notes.recordSession(request);
+		}
+		/** Add the reader's own line under a note. */
+		addReply(request) {
+			return this.notes.addReply({
+				...request,
+				by: "user"
+			});
+		}
+		/** Rewrite (or, with empty text, remove) one line under a note. */
+		editReply(request) {
+			return this.notes.editReply(request);
+		}
+		/** Remember that a note or a discussion note became a canvas card. */
+		markSynced(request) {
+			return this.notes.markSynced(request);
+		}
+		/** Delete one discussion note. */
+		deleteDiscussion(request) {
+			return this.notes.deleteDiscussion(request);
+		}
+		/** A video entry's transcript from its platform captions (stored; `none` when it has none). */
+		mediaTranscript(request) {
+			return this.core.mediaTranscript(request);
+		}
+		/**
+		* Start (or rejoin) local transcription of an entry without captions.
+		* Answers `unavailable` without the transcription plugin and `needs-models`
+		* until the first model download is confirmed.
+		*/
+		startLocalTranscript(request) {
+			return this.core.local.start(request);
+		}
+		/** Where an entry's local transcription stands, with the transcript so far. */
+		localTranscript(request) {
+			return Promise.resolve(this.core.local.status(request.entryId));
+		}
+		/** The reader's names for a transcript's speakers, by index. */
+		speakerNames(request) {
+			return Promise.resolve(this.core.speakerNames(request));
+		}
+		/** Name one speaker of a transcript (empty: back to 说话人 A…); answers all the names. */
+		nameSpeaker(request) {
+			return Promise.resolve(this.core.nameSpeaker(request));
+		}
+		/** The wall's video / audio cards: what each one's transcript is (captions, local, transcribing…). */
+		mediaStates(request) {
+			return Promise.resolve(this.core.mediaStates(request));
+		}
+		/** Leave (withdraws a queued job) or, with `force`, stop an entry's local transcription. */
+		cancelLocalTranscript(request) {
+			return Promise.resolve(this.core.local.cancel(request.entryId, request.force));
+		}
+		/** The article's 润色 layer (the agent's translation), when there is one for its current text. */
+		polish(request) {
+			return Promise.resolve(this.notes.polishView(request.entryId) ?? null);
+		}
+		/** Show one paragraph's machine translation instead of the 润色 (or back). */
+		setPolishOff(request) {
+			return Promise.resolve(this.notes.setPolishOff(request.entryId, request.paragraph, request.off) ?? null);
+		}
+		/** Hand the host the article's original text, block by block, for the model to read. */
+		snapshotEntry(request) {
+			return this.notes.snapshot(request);
+		}
 	};
 })();
 //#endregion
@@ -4140,7 +7318,8 @@ const name = "reader";
 function apply(ctx, config = {}) {
 	const service = new ReaderService(ctx, config);
 	ctx.provide("reader", service);
+	ctx.provide("readerNotes", new ReaderNotesStore(config));
 	ctx.plugin(ReaderRemoteService, {});
 }
 //#endregion
-export { DAY_MS, DEFAULT_CACHE_POLICY, DEFAULT_REFRESH_TIME, DEFAULT_TRANSLATION_BUDGET_CHARS, INLINE_BODY_MAX_CHARS, MAX_BODY_CHARS_PER_SOURCE, MAX_CACHED_BODIES, MAX_TAGS, MAX_TIMEOUT_MS, MAX_TOTAL_BODY_CHARS, MAX_TRANSLATION_MEMORY_ENTRIES, READER_SOURCE_KINDS, ReaderRemoteService, ReaderService, ReaderStore, ReaderStoreError, STATE_ROOT_SEGMENT, TRANSLATION_STORAGE_VERSION, apply, boundAnnotations, boundPayloads, classifyPayload, defaultSourceLabel, delayUntilNext, emptyStateDoc, errorMessage, isCatchUpDue, isRetryablePreviewFailure, kindQuery, linkEntryId, name, nextOccurrence, normalizeStateDoc, normalizeUrl, parseTimeOfDay, previousOccurrence, pruneOrphanTags, resolveReaderStateRoot, serializeStateDoc, stableEntryId, summarize };
+export { COOKIE_HANDSHAKE_HOSTS, DAY_MS, DEFAULT_CACHE_POLICY, DEFAULT_REFRESH_TIME, DEFAULT_TRANSLATION_BUDGET_CHARS, INLINE_BODY_MAX_CHARS, MAX_BODY_CHARS_PER_SOURCE, MAX_CACHED_BODIES, MAX_COMMENT_CHARS, MAX_DISCUSSIONS_PER_ENTRY, MAX_LOOSE_SNAPSHOTS, MAX_NOTES_PER_ENTRY, MAX_POINTS, MAX_POINT_CHARS, MAX_QUOTE_CHARS, MAX_REPLIES_PER_NOTE, MAX_SESSIONS_PER_ENTRY, MAX_SNAPSHOT_CHARS, MAX_TAGS, MAX_TIMEOUT_MS, MAX_TOTAL_BODY_CHARS, MAX_TRANSLATION_MEMORY_ENTRIES, READER_NOTES_FILE_NAME, READER_SNAPSHOTS_DIR, READER_SOURCE_KINDS, ReaderNotesStore, ReaderRemoteService, ReaderService, ReaderStore, ReaderStoreError, STATE_ROOT_SEGMENT, TRANSLATION_STORAGE_VERSION, apply, boundAnnotations, boundParagraphs, boundPayloads, boundPoints, challengeTarget, classifyPayload, defaultSourceLabel, delayUntilNext, emptyNotesDoc, emptyStateDoc, errorMessage, isCatchUpDue, isCookieHandshake, isRetryablePreviewFailure, kindQuery, linkEntryId, name, nextOccurrence, normalizeNotesDoc, normalizeStateDoc, normalizeUrl, parseTimeOfDay, previousOccurrence, pruneOrphanTags, resolveReaderStateRoot, serializeStateDoc, stableEntryId, summarize };