@khorsheed/dsh-reader 0.2.0

package/lib/index.js

@@ -0,0 +1,3660 @@
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+//#region lib/types/types.js
+/**
+* Shared vocabulary of `@khorsheed/dsh-reader`: the persisted state document,
+* the Remote wire payloads, and the pure helpers both faces share.
+*
+* Two responsibilities are deliberately split across the process boundary:
+*
+* - the HOST half owns the network (the sanctioned `ctx.web` fetch seam) and
+*   the disk (one version-guarded JSON document over `ctx.fs`). It stores the
+*   LAST RAW PAYLOAD per source — feed XML or article HTML — plus fetch
+*   metadata, and never parses either.
+* - the BROWSER half owns parsing. The host runtime has no XML/DOM parser at
+*   all (Node's `globalThis.DOMParser` is absent), so the single parser lives
+*   in the browser where `DOMParser` is native, and its output never needs to
+*   be persisted: entries and extracted article bodies are session state.
+*
+* @module @khorsheed/dsh-reader/types
+*/
+/**
+* Whether an automatic retry is worth the request.
+*
+* Only a transport failure is: a bot wall, a login wall, a PDF and a 404 all
+* answer the same way forever, so retrying them on a timer would be a crawler
+* with a grudge rather than a reader. The manual refresh stays available.
+*
+* @param code - the recorded failure.
+* @returns true when the entry may be retried automatically.
+*/
+function isRetryablePreviewFailure(code) {
+	return code === "unreachable";
+}
+/** The default cache policy: a day, and a few hundred articles. */
+const DEFAULT_CACHE_POLICY = {
+	ttlHours: 24,
+	maxEntries: 500
+};
+/**
+* The schema version of the persisted translation tiers (the global sentence
+* memory's table, and each entry's segment map). A browser Translator model
+* upgrade quietly changes what the same sentence translates to, and a
+* segmentation change here changes what a "sentence" is — bumping this turns
+* every old record into a MISS. Records are evicted LAZILY (the next write or
+* budget pass drops them), never wiped eagerly.
+*/
+const TRANSLATION_STORAGE_VERSION = 1;
+/**
+* The default total budget for both translation tiers, in characters — 64 MB
+* worth of text. Counted in characters, like every other budget in this
+* document (a CJK sentence costs more bytes than that reads; the approximation
+* is the store's existing convention).
+*/
+const DEFAULT_TRANSLATION_BUDGET_CHARS = 67108864;
+/** How many sentences the global memory keeps before its own LRU end is evicted. */
+const MAX_TRANSLATION_MEMORY_ENTRIES = 5e4;
+/** Default state root segment under `$DSH_HOME/state`. */
+const STATE_ROOT_SEGMENT = "dsh-reader";
+/** Default daily refresh time. */
+const DEFAULT_REFRESH_TIME = "10:00";
+/**
+* Per-source raw-payload budget in characters.
+*
+* Sized to the HOST's egress cap rather than below it: a deployment can raise
+* `web-fetch-http`'s `maxBodyChars` (the acceptance instance runs it at
+* 2,000,000), and a per-source budget smaller than what the seam is willing to
+* deliver would silently re-truncate every large feed here — the reader would
+* pay for the fetch and still get half a document, with the note blaming the
+* fetch. The fetch cap is the outer bound; this one must not be the inner one.
+*/
+const MAX_BODY_CHARS_PER_SOURCE = 2097152;
+/** Total raw-payload budget in characters across all sources (newest kept). */
+const MAX_TOTAL_BODY_CHARS = 12582912;
+/**
+* How large an extracted body may be before it lives in its own file.
+*
+* `state.json` is read and rewritten as a whole on every mutation, so a research
+* paper whose figures are inlined as base64 (transformer-circuits.pub's emotions
+* paper is a 41.8 MB HTML document and extracts to tens of megabytes) would make
+* every reader operation pay a multi-megabyte JSON round trip. Above this
+* threshold the body is written to one file under `bodies/` and the document
+* keeps only its metadata — so the cache policy (`ttlHours`, `maxEntries`) still
+* governs it exactly like an inline body, and eviction deletes the file.
+*/
+const INLINE_BODY_MAX_CHARS = 262144;
+/**
+* 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.
+*
+* @param url - the source URL (any string; a malformed one degrades to its own head).
+* @returns a short human label.
+*/
+function defaultSourceLabel(url) {
+	try {
+		const parsed = new URL(url);
+		const host = parsed.hostname.replace(/^www\./, "");
+		const tail = (parsed.pathname.split("/").filter((segment) => segment.length > 0).at(-1) ?? "").replace(/\.(xml|rss|atom|json)$/i, "");
+		return tail.length > 0 ? `${host}/${tail}` : host;
+	} catch {
+		return url.slice(0, 60);
+	}
+}
+/**
+* Build a stable entry id. Feeds are inconsistent about identifiers, so the
+* order is: explicit guid/id, then the entry link, then a hash over title and
+* link together (a feed with neither must still deduplicate across refreshes).
+*
+* @param entry - the identifying fields an entry may carry.
+* @returns an id stable across refreshes of the same feed content.
+*/
+function stableEntryId(entry) {
+	const explicit = entry.guid?.trim();
+	if (explicit !== void 0 && explicit.length > 0) return `g:${explicit}`;
+	const link = entry.link?.trim();
+	if (link !== void 0 && link.length > 0) return `l:${link}`;
+	return `h:${hash32(`${entry.title}\u0000${entry.link ?? ""}`).toString(36)}`;
+}
+/**
+* The entry id a saved link's single entry carries.
+*
+* A `link` source is exactly one entry, so the host must be able to name that
+* entry when it records a per-entry annotation (the fetch failure the detail
+* view reads). Both halves use this one function: a magic string duplicated
+* across the process boundary is a bug waiting for a rename.
+*
+* @param sourceId - the link source's id.
+* @returns the entry id the browser will build for it.
+*/
+function linkEntryId(sourceId) {
+	return `link:${sourceId}`;
+}
+/**
+* The query that selects every entry of one source KIND.
+*
+* The same local-predicate mechanism as a source or tag filter, so a kind
+* narrowing is visible in the search box and can be cleared there. The prefix
+* cannot collide with a real source id: ids are always `<kind>-<hash>`.
+*
+* @param kind - the source kind to select.
+* @returns the query string.
+*/
+function kindQuery(kind) {
+	return `#${kind}`;
+}
+/** The source kinds a kind query can name, for the predicate that reads one. */
+const READER_SOURCE_KINDS = ["rss", "link"];
+/**
+* Shorten a summary for a card, collapsing whitespace so multi-line feed
+* descriptions do not blow up the layout.
+*
+* @param text - the raw summary or content text.
+* @param maxLength - the maximum returned length, ellipsis included.
+* @returns the collapsed, shortened text, or `undefined` when there is none.
+*/
+function summarize(text, maxLength = 280) {
+	if (text === void 0) return void 0;
+	const collapsed = text.replace(/\s+/g, " ").trim();
+	if (collapsed.length === 0) return void 0;
+	if (collapsed.length <= maxLength) return collapsed;
+	return `${collapsed.slice(0, maxLength - 1)}…`;
+}
+/** Coerce an unknown thrown value into a message string. */
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/** 32-bit FNV-1a hash, used only to build stable ids (never for security). */
+function hash32(input) {
+	let hash = 2166136261;
+	for (let index = 0; index < input.length; index++) {
+		hash ^= input.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return hash >>> 0;
+}
+//#endregion
+//#region lib/types/store.js
+/**
+* The host-side state store: one JSON document under the deployment's state
+* root, holding the source list and, per source, the raw payload of its last
+* fetch plus that fetch's metadata.
+*
+* **Why plain `node:fs` and not `ctx.fs`.** `ctx.fs` is the SANDBOXED
+* filesystem: every mutation is fenced by the calling session's policy, so a
+* workspace-write session refuses a write to `$DSH_HOME/state` with
+* `FS_SANDBOX_DENIED` — which is exactly what happened on the acceptance
+* instance, where a subscription failed with
+* `cannot write "…/state/dsh-reader/state.json": file access denied under
+* workspace-write mode`. That fence is correct and must stay; the mistake is
+* aiming a session-fenced capability at host-owned durable state. This
+* package's state belongs to the DEPLOYMENT, not to whichever session happened
+* to click "fetch", so it is written the way this repo's other host-state
+* packages write theirs (`packages/lab/src/state.ts`): `node:fs`, atomic
+* via a temporary file plus rename.
+*
+* The rest of the contract is unchanged and is why this file exists:
+*
+* - a missing document reads as empty, and a **corrupt** one refuses rather
+*   than being overwritten, so a hand-edited file stays visible until its
+*   owner fixes it instead of being silently destroyed by the next refresh;
+* - an unwritable root degrades to memory-only instead of taking the plugin
+*   down, because a composition must never fail for lack of a writable disk;
+* - nothing here parses a feed. The document stores raw payloads, and the
+*   browser half — the only side with a DOM parser — turns them into entries.
+*
+* @module @khorsheed/dsh-reader/store
+*/
+/** The failure codes the document may carry, for normalization. */
+const PREVIEW_FAILURE_CODES = /* @__PURE__ */ new Set([
+	"blocked",
+	"login",
+	"unsupported-type",
+	"redirected",
+	"empty",
+	"unreachable",
+	"http",
+	"unreadable"
+]);
+/** How many tags one document may define (a vocabulary, not a folksonomy dump). */
+const MAX_TAGS = 200;
+/** How many entries may carry fetched bodies, before the newest-first eviction. */
+const MAX_CACHED_BODIES = 500;
+/** The state file name inside the plugin's state root. */
+const READER_STATE_FILE_NAME = "state.json";
+/** A store failure that the service maps onto a wire outcome. */
+var ReaderStoreError = class extends Error {
+	kind;
+	constructor(message, kind) {
+		super(message);
+		this.kind = kind;
+		this.name = "ReaderStoreError";
+	}
+};
+/**
+* Resolve the state root: an explicit config value wins, then
+* `$DSH_HOME/state/dsh-reader`, then `<cwd>/.dsh-reader`.
+*
+* @param configured - the plugin-provided override, if any.
+* @returns the absolute state root directory.
+*/
+function resolveReaderStateRoot(configured) {
+	if (configured !== void 0 && configured !== "") return configured;
+	const home = process.env.DSH_HOME;
+	if (home !== void 0 && home !== "") return join(home, "state", STATE_ROOT_SEGMENT);
+	return join(process.cwd(), `.${STATE_ROOT_SEGMENT}`);
+}
+/** The empty document. */
+function emptyStateDoc() {
+	return {
+		version: 1,
+		sources: [],
+		refresh: {
+			enabled: true,
+			timeOfDay: "10:00"
+		}
+	};
+}
+/** Serialize the document (trailing newline, the repo's state-file shape). */
+function serializeStateDoc(doc) {
+	return `${JSON.stringify(doc, null, 2)}\n`;
+}
+/**
+* Coerce a parsed value into a document, dropping anything unrecognizable
+* rather than trusting the file: this is user-editable state.
+*
+* @param value - the parsed JSON.
+* @returns a valid document.
+*/
+function normalizeStateDoc(value) {
+	const base = emptyStateDoc();
+	if (typeof value !== "object" || value === null) return base;
+	const record = value;
+	const sources = Array.isArray(record.sources) ? record.sources : [];
+	const refresh = typeof record.refresh === "object" && record.refresh !== null ? record.refresh : {};
+	return {
+		version: 1,
+		sources: sources.flatMap((item) => {
+			const source = normalizeSource(item);
+			return source === void 0 ? [] : [source];
+		}),
+		refresh: {
+			enabled: refresh.enabled !== false,
+			timeOfDay: typeof refresh.timeOfDay === "string" && /^\d{1,2}:\d{2}$/.test(refresh.timeOfDay) ? refresh.timeOfDay : base.refresh.timeOfDay
+		},
+		...typeof record.lastRefreshAt === "string" ? { lastRefreshAt: record.lastRefreshAt } : {},
+		...(() => {
+			const cache = normalizeCachePolicy(record.cache);
+			return cache === void 0 ? {} : { cache };
+		})(),
+		...(() => {
+			const tags = normalizeTags(record.tags);
+			return Object.keys(tags).length > 0 ? { tags } : {};
+		})(),
+		...(() => {
+			const annotations = normalizeAnnotations(record.annotations);
+			return Object.keys(annotations).length > 0 ? { annotations } : {};
+		})(),
+		...(() => {
+			const translationMemory = normalizeTranslationMemory(record.translationMemory);
+			return translationMemory === void 0 ? {} : { translationMemory };
+		})(),
+		...(() => {
+			const recent = normalizeRecent(record.recent);
+			return recent.length > 0 ? { recent } : {};
+		})()
+	};
+}
+/**
+* The recent list, dropping anything without the two ids and a timestamp.
+*
+* The order is the file's, which is newest-first by construction (the service
+* unshifts); a hand-edited file that disagrees still renders in its own order,
+* which is the honest reading of what is on disk.
+*/
+function normalizeRecent(value) {
+	if (!Array.isArray(value)) return [];
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const item of value) {
+		if (typeof item !== "object" || item === null) continue;
+		const record = item;
+		const entryId = typeof record.entryId === "string" ? record.entryId.trim() : "";
+		const sourceId = typeof record.sourceId === "string" ? record.sourceId.trim() : "";
+		const title = typeof record.title === "string" ? record.title.trim() : "";
+		const readAt = typeof record.readAt === "string" ? record.readAt : "";
+		if (entryId.length === 0 || sourceId.length === 0 || readAt.length === 0) continue;
+		if (seen.has(entryId)) continue;
+		seen.add(entryId);
+		out.push({
+			entryId,
+			sourceId,
+			title: title.slice(0, 300),
+			...typeof record.url === "string" && record.url.length > 0 ? { url: record.url } : {},
+			readAt
+		});
+		if (out.length >= 100) break;
+	}
+	return out;
+}
+/** The cache policy, coerced to something usable (absent = the default). */
+function normalizeCachePolicy(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const record = value;
+	const ttlHours = typeof record.ttlHours === "number" && Number.isFinite(record.ttlHours) && record.ttlHours >= 0 ? Math.min(record.ttlHours, 2160) : DEFAULT_CACHE_POLICY.ttlHours;
+	const maxEntries = typeof record.maxEntries === "number" && Number.isFinite(record.maxEntries) && record.maxEntries > 0 ? Math.min(Math.floor(record.maxEntries), 5e3) : DEFAULT_CACHE_POLICY.maxEntries;
+	const translationBudgetChars = typeof record.translationBudgetChars === "number" && Number.isFinite(record.translationBudgetChars) && record.translationBudgetChars > 0 ? Math.min(Math.floor(record.translationBudgetChars), 1073741824) : void 0;
+	return {
+		ttlHours,
+		maxEntries,
+		...translationBudgetChars === void 0 ? {} : { translationBudgetChars }
+	};
+}
+/** A `bodies/` file name is one path segment, or it is not a name we wrote. */
+function normalizeFileName(value) {
+	return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(value) ? value : void 0;
+}
+/** The global memory's manifest; kept as recorded (a version bump reads as a miss, lazily). */
+function normalizeTranslationMemory(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const record = value;
+	const file = normalizeFileName(record.file);
+	if (typeof record.version !== "number" || file === void 0) return void 0;
+	return {
+		version: record.version,
+		file,
+		entries: typeof record.entries === "number" && Number.isFinite(record.entries) ? Math.max(0, Math.floor(record.entries)) : 0,
+		chars: typeof record.chars === "number" && Number.isFinite(record.chars) ? Math.max(0, Math.floor(record.chars)) : 0,
+		updatedAt: typeof record.updatedAt === "string" ? record.updatedAt : (/* @__PURE__ */ new Date(0)).toISOString()
+	};
+}
+/**
+* One entry's translation segment map, when it carries the fields that make it
+* one. The schema version is preserved as recorded: a mismatch is a MISS when
+* the record is served, and the record is evicted by the next write or budget
+* pass — never by the read path.
+*/
+function normalizeTranslation(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const record = value;
+	if (typeof record.version !== "number") return void 0;
+	const pair = typeof record.pair === "string" ? record.pair : "";
+	const bodyHash = typeof record.bodyHash === "string" ? record.bodyHash : "";
+	if (pair.length === 0 || bodyHash.length === 0) return void 0;
+	const segments = typeof record.segments === "object" && record.segments !== null ? Object.fromEntries(Object.entries(record.segments).filter(([, target]) => typeof target === "string")) : void 0;
+	const file = normalizeFileName(record.file);
+	if (segments === void 0 && file === void 0) return void 0;
+	return {
+		version: record.version,
+		pair,
+		bodyHash,
+		...segments !== void 0 && Object.keys(segments).length > 0 ? { segments } : {},
+		...file === void 0 ? {} : { file },
+		...typeof record.chars === "number" && Number.isFinite(record.chars) ? { chars: record.chars } : {},
+		translatedAt: typeof record.translatedAt === "string" ? record.translatedAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+		lastUsedAt: typeof record.lastUsedAt === "string" ? record.lastUsedAt : (/* @__PURE__ */ new Date(0)).toISOString()
+	};
+}
+/** The tag vocabulary, dropping anything without an id and a name. */
+function normalizeTags(value) {
+	if (typeof value !== "object" || value === null) return {};
+	const out = {};
+	for (const [id, entry] of Object.entries(value)) {
+		if (typeof entry !== "object" || entry === null) continue;
+		const record = entry;
+		const name = typeof record.name === "string" ? record.name.trim() : "";
+		if (id.length === 0 || name.length === 0) continue;
+		out[id] = {
+			id,
+			name: name.slice(0, 40),
+			createdAt: typeof record.createdAt === "string" ? record.createdAt : (/* @__PURE__ */ new Date(0)).toISOString()
+		};
+		if (Object.keys(out).length >= 200) break;
+	}
+	return out;
+}
+/** The per-entry annotations, dropping entries that carry nothing. */
+function normalizeAnnotations(value) {
+	if (typeof value !== "object" || value === null) return {};
+	const out = {};
+	for (const [entryId, entry] of Object.entries(value)) {
+		if (entryId.length === 0 || typeof entry !== "object" || entry === null) continue;
+		const record = entry;
+		const body = normalizeBody(record.body);
+		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 annotation = {
+			...body === void 0 ? {} : { body },
+			...fetch === void 0 ? {} : { fetch },
+			...translation === void 0 ? {} : { translation },
+			...tagIds.length > 0 ? { tagIds } : {},
+			...typeof record.error === "string" ? { error: record.error.slice(0, 500) } : {},
+			...failureCode === void 0 ? {} : { failureCode },
+			...typeof record.failedAt === "string" ? { failedAt: record.failedAt } : {},
+			...typeof record.title === "string" && record.title.trim().length > 0 ? { title: record.title.trim().slice(0, 300) } : {},
+			...typeof record.excerpt === "string" && record.excerpt.trim().length > 0 ? { excerpt: record.excerpt.trim().slice(0, 1e3) } : {}
+		};
+		if (annotation.body === void 0 && annotation.fetch === void 0 && annotation.tagIds === void 0 && annotation.error === void 0 && annotation.translation === void 0 && annotation.title === void 0 && annotation.excerpt === void 0) continue;
+		out[entryId] = annotation;
+	}
+	return out;
+}
+/**
+* One in-flight or stored-raw record, when it carries the fields that make it one.
+*
+* @param value - the persisted field.
+* @returns the normalized record, or `undefined`.
+*/
+function normalizeFetch(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const record = value;
+	const state = record.state === "fetching" || record.state === "raw" ? record.state : void 0;
+	if (state === void 0) return void 0;
+	const rawFile = typeof record.rawFile === "string" && record.rawFile.length > 0 ? record.rawFile : void 0;
+	return {
+		state,
+		at: typeof record.at === "string" ? record.at : (/* @__PURE__ */ new Date(0)).toISOString(),
+		...rawFile === void 0 ? {} : { rawFile },
+		...typeof record.chars === "number" && Number.isFinite(record.chars) ? { chars: record.chars } : {},
+		...typeof record.url === "string" ? { url: record.url } : {},
+		...record.truncated === true ? { truncated: true } : {}
+	};
+}
+/** One cached body, when it carries the fields that make it one. */
+function normalizeBody(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const record = value;
+	const inline = typeof record.html === "string" && record.html.length > 0;
+	const file = typeof record.file === "string" && record.file.length > 0 ? record.file : void 0;
+	if (!inline && file === void 0) return void 0;
+	return {
+		...inline ? { html: record.html } : {},
+		...file === void 0 ? {} : { file },
+		...typeof record.chars === "number" && Number.isFinite(record.chars) ? { chars: record.chars } : {},
+		fetchedAt: typeof record.fetchedAt === "string" ? record.fetchedAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+		expiresAt: typeof record.expiresAt === "string" ? record.expiresAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+		url: typeof record.url === "string" ? record.url : "",
+		...record.truncated === true ? { truncated: true } : {},
+		...typeof record.scriptFigures === "number" && Number.isFinite(record.scriptFigures) ? { scriptFigures: record.scriptFigures } : {},
+		...record.rendered === true ? { rendered: true } : {}
+	};
+}
+/** One source, or `undefined` when it lacks the fields that make it one. */
+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 kind = record.kind === "link" ? "link" : "rss";
+	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,
+		enabled: record.enabled !== false,
+		addedAt: typeof record.addedAt === "string" ? record.addedAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+		...typeof record.fetchedAt === "string" ? { fetchedAt: record.fetchedAt } : {},
+		...status !== void 0 ? { status } : {},
+		...typeof record.error === "string" ? { error: record.error } : {},
+		...record.truncated === true ? { truncated: true } : {},
+		...failure === void 0 ? {} : { failure },
+		...typeof record.resolvedFrom === "string" ? { resolvedFrom: record.resolvedFrom } : {},
+		...typeof record.raw === "string" ? { raw: record.raw } : {},
+		...typeof record.timeOfDay === "string" ? { timeOfDay: record.timeOfDay } : {}
+	};
+}
+/**
+* One recorded preview failure, or `undefined` when the record is not one.
+*
+* An unknown code is dropped rather than trusted: the union is what the
+* browser switches on, and a code this build does not know would render as a
+* missing sentence instead of a diagnosis.
+*
+* @param value - the persisted field.
+* @returns the normalized failure, or `undefined`.
+*/
+function normalizePreviewFailure(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const record = value;
+	const code = record.code;
+	if (typeof code !== "string" || !PREVIEW_FAILURE_CODES.has(code)) return void 0;
+	return {
+		code,
+		message: typeof record.message === "string" ? record.message.slice(0, 500) : "",
+		at: typeof record.at === "string" ? record.at : (/* @__PURE__ */ new Date(0)).toISOString()
+	};
+}
+/**
+* Bound the document's payload bytes without dropping a subscription.
+*
+* Newest-first: the freshest payload is the one the reader is most likely to
+* open, so it survives and the oldest bodies are the ones released. Keeping
+* every source row regardless is deliberate — a source whose body was evicted
+* still refreshes, and dropping subscriptions to save space would be a silent
+* data loss the reader never asked for.
+*
+* @param doc - the document to bound.
+* @returns the bounded document, and whether anything was released.
+*/
+function boundPayloads(doc) {
+	let changed = false;
+	const byNewest = [...doc.sources].sort((a, b) => (b.fetchedAt ?? "").localeCompare(a.fetchedAt ?? ""));
+	const trimmed = /* @__PURE__ */ new Map();
+	let total = 0;
+	for (const source of byNewest) {
+		const raw = source.raw;
+		if (raw === void 0) continue;
+		if (raw.length > 2097152) {
+			trimmed.set(source.id, {
+				...source,
+				raw: raw.slice(0, MAX_BODY_CHARS_PER_SOURCE),
+				truncated: true
+			});
+			total += MAX_BODY_CHARS_PER_SOURCE;
+			changed = true;
+			continue;
+		}
+		if (total + raw.length > 12582912) {
+			const { raw: _dropped, ...withoutRaw } = source;
+			trimmed.set(source.id, withoutRaw);
+			changed = true;
+			continue;
+		}
+		total += raw.length;
+		trimmed.set(source.id, source);
+	}
+	if (!changed) return {
+		doc,
+		changed
+	};
+	return {
+		doc: {
+			...doc,
+			sources: doc.sources.map((s) => trimmed.get(s.id) ?? s)
+		},
+		changed
+	};
+}
+/** Sub-directory holding bodies too large to inline in the document. */
+const READER_BODIES_DIR = "bodies";
+/**
+* The global translation memory's file name inside `bodies/`.
+*
+* One fixed name rather than a per-key hash: the table is a single artifact,
+* rewritten whole by the (already debounced) write path, and referenced from
+* the document's `translationMemory` manifest so `pruneBodies` keeps it.
+*/
+const TRANSLATION_MEMORY_FILE = "translation-memory.json";
+/** Native-fs state store: the deployment's document, not the session's. */
+var ReaderStore = class {
+	stateRoot;
+	file;
+	bodiesDir;
+	/** Set once the root has proven unwritable; the service then goes memory-only. */
+	unwritable;
+	/**
+	* @param config - optional state-root override.
+	*/
+	constructor(config = {}) {
+		this.stateRoot = resolveReaderStateRoot(config.stateRoot);
+		this.file = join(this.stateRoot, READER_STATE_FILE_NAME);
+		this.bodiesDir = join(this.stateRoot, READER_BODIES_DIR);
+	}
+	/**
+	* Write one body to its own file, atomically, and return the file's name.
+	*
+	* The name is a digest of the entry id: entry ids are URLs, and a document
+	* carrying an absolute path (or a path derived from remote text) is a
+	* directory-traversal waiting to happen.
+	*
+	* @param entryId - the entry the body belongs to.
+	* @param html - the normalized body markup.
+	* @returns the file name to store in the document.
+	*/
+	writeBody(entryId, html) {
+		const name = `${bodyFileName(entryId)}.html`;
+		mkdirSync(this.bodiesDir, { recursive: true });
+		const target = join(this.bodiesDir, name);
+		const temporary = `${target}.${process.pid}.tmp`;
+		try {
+			writeFileSync(temporary, html);
+			renameSync(temporary, target);
+		} catch (error) {
+			rmSync(temporary, { force: true });
+			throw new ReaderStoreError(`reader: ${target} could not be written — ${errorMessage$1(error)}`, "io");
+		}
+		return name;
+	}
+	/**
+	* Write one NAMED artifact into `bodies/`, atomically.
+	*
+	* Unlike {@link writeBody} the name is the caller's, not a hash of an entry
+	* id: the global translation memory is one fixed file, not one per entry. The
+	* name is validated to a bare file name — this directory must never grow a
+	* path.
+	*
+	* @param name - the bare file name to write.
+	* @param content - the file's content.
+	* @returns the name written.
+	*/
+	writeNamedBody(name, content) {
+		if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name)) throw new ReaderStoreError(`reader: refusing to write ${name} — not a bare file name`, "io");
+		mkdirSync(this.bodiesDir, { recursive: true });
+		const target = join(this.bodiesDir, name);
+		const temporary = `${target}.${process.pid}.tmp`;
+		try {
+			writeFileSync(temporary, content);
+			renameSync(temporary, target);
+		} catch (error) {
+			rmSync(temporary, { force: true });
+			throw new ReaderStoreError(`reader: ${target} could not be written — ${errorMessage$1(error)}`, "io");
+		}
+		return name;
+	}
+	/**
+	* Read one body file.
+	*
+	* @param name - the file name recorded in the document.
+	* @returns the markup, or `undefined` when the file is gone or unreadable.
+	*/
+	readBody(name) {
+		try {
+			return readFileSync(join(this.bodiesDir, name), "utf8");
+		} catch {
+			return;
+		}
+	}
+	/**
+	* Delete body files the document no longer references.
+	*
+	* Eviction (`maxEntries`), tag edits that drop an annotation, and a hand-edited
+	* document all release bodies by REMOVING them from the JSON — which would
+	* otherwise leave their files on disk forever. Best-effort by design: a failed
+	* sweep must never fail the commit that triggered it.
+	*
+	* @param doc - the document that was just written.
+	* @returns how many files were removed.
+	*/
+	pruneBodies(doc) {
+		const referenced = /* @__PURE__ */ new Set();
+		for (const annotation of Object.values(doc.annotations ?? {})) {
+			if (annotation.body?.file !== void 0) referenced.add(annotation.body.file);
+			if (annotation.fetch?.rawFile !== void 0) referenced.add(annotation.fetch.rawFile);
+			if (annotation.translation?.file !== void 0) referenced.add(annotation.translation.file);
+		}
+		if (doc.translationMemory !== void 0) referenced.add(doc.translationMemory.file);
+		let names;
+		try {
+			names = readdirSync(this.bodiesDir);
+		} catch {
+			return 0;
+		}
+		let removed = 0;
+		for (const name of names) {
+			if (referenced.has(name)) continue;
+			try {
+				rmSync(join(this.bodiesDir, name), { force: true });
+				removed += 1;
+			} catch {}
+		}
+		return removed;
+	}
+	/** The absolute path of the state file (diagnostics and tests). */
+	get path() {
+		return this.file;
+	}
+	/** Why persistence is unavailable, when it is. */
+	get unavailableReason() {
+		return this.unwritable;
+	}
+	/**
+	* Whether persistence is available.
+	*
+	* Probed by creating the state root, not by asking a capability: a
+	* read-only deployment (a container with no writable home) must degrade to
+	* memory-only, and that is only knowable by trying.
+	*/
+	get available() {
+		if (this.unwritable !== void 0) return false;
+		try {
+			mkdirSync(this.stateRoot, { recursive: true });
+			return true;
+		} catch (error) {
+			this.unwritable = `${this.stateRoot}: ${errorMessage$1(error)}`;
+			return false;
+		}
+	}
+	/**
+	* Read the document tolerantly.
+	*
+	* @returns the document and its freshness token; a missing file reads as empty.
+	* @throws ReaderStoreError when the file exists but does not parse.
+	*/
+	async read() {
+		if (!this.available) return {
+			doc: emptyStateDoc(),
+			version: null
+		};
+		let text;
+		try {
+			text = readFileSync(this.file, "utf8");
+		} catch (error) {
+			if (isMissing(error)) return {
+				doc: emptyStateDoc(),
+				version: null
+			};
+			throw new ReaderStoreError(`reader: ${this.file} could not be read — ${errorMessage$1(error)}`, "io");
+		}
+		try {
+			return {
+				doc: normalizeStateDoc(JSON.parse(text)),
+				version: String(text.length) + ":" + String(statSync(this.file).mtimeMs)
+			};
+		} catch (error) {
+			if (error instanceof ReaderStoreError) throw error;
+			throw new ReaderStoreError(`reader: ${this.file} does not parse — fix or remove it by hand`, "corrupt");
+		}
+	}
+	/**
+	* Write the document atomically under the token from the last read.
+	*
+	* @param doc - the document to publish.
+	* @param version - the token from the last read (`null` for the first write).
+	* @returns the new freshness token.
+	*/
+	async write(doc, version) {
+		if (!this.available) throw new ReaderStoreError("reader: no writable state root", "io");
+		if (version !== null) {
+			if ((await this.read()).version !== version) throw new ReaderStoreError(`reader: ${this.file} changed underneath this write`, "io");
+		}
+		const temporary = `${this.file}.${process.pid}.tmp`;
+		try {
+			writeFileSync(temporary, serializeStateDoc(doc));
+			renameSync(temporary, this.file);
+		} catch (error) {
+			rmSync(temporary, { force: true });
+			throw new ReaderStoreError(`reader: ${this.file} could not be written — ${errorMessage$1(error)}`, "io");
+		}
+		const text = serializeStateDoc(doc);
+		return String(text.length) + ":" + String(statSync(this.file).mtimeMs);
+	}
+	/**
+	* Read-modify-write with the one concurrent-edit retry.
+	*
+	* @param mutate - pure function from the current document to the next one.
+	* @returns the document that ended up on disk.
+	*/
+	async update(mutate) {
+		for (let attempt = 0; attempt < 2; attempt++) {
+			const { doc, version } = await this.read();
+			const next = boundAnnotations(boundPayloads(mutate(doc)).doc).doc;
+			try {
+				await this.write(next, version);
+				this.pruneBodies(next);
+				return next;
+			} catch (error) {
+				if (attempt === 1 || !(error instanceof ReaderStoreError) || error.kind !== "io") throw error;
+			}
+		}
+		/* v8 ignore next -- the loop either returns or throws */
+		throw new ReaderStoreError("reader: could not commit after a concurrent-edit retry", "io");
+	}
+};
+/** Whether a native fs failure is "there is no file yet". */
+/** The bare file name one entry's body lives under. */
+function bodyFileName(entryId) {
+	return createHash("sha1").update(entryId).digest("hex").slice(0, 32);
+}
+function isMissing(error) {
+	return error?.code === "ENOENT";
+}
+/** A native fs failure's message, with its code, for the wire. */
+function errorMessage$1(error) {
+	const code = error?.code;
+	const message = error instanceof Error ? error.message : String(error);
+	return code === void 0 ? message : `${code}: ${message}`;
+}
+/**
+* Bound the cached article bodies without touching what the reader authored.
+*
+* Newest-first: the article just fetched is the one being read, so the budget
+* releases the older copies. Tags are NOT part of this budget — a tag is a
+* sentence the reader wrote, and losing it to make room for a cached page would
+* be the worst trade in this document.
+*
+* @param doc - the document to bound.
+* @returns the bounded document, and whether anything was released.
+*/
+function boundAnnotations(doc) {
+	const annotations = doc.annotations;
+	if (annotations === void 0) return {
+		doc,
+		changed: false
+	};
+	const withBody = Object.entries(annotations).filter(([, entry]) => entry.body !== void 0);
+	const limit = Math.max(1, doc.cache?.maxEntries ?? 500);
+	if (withBody.length <= limit) return {
+		doc,
+		changed: false
+	};
+	const keep = new Set([...withBody].sort((a, b) => (b[1].body?.fetchedAt ?? "").localeCompare(a[1].body?.fetchedAt ?? "")).slice(0, limit).map(([entryId]) => entryId));
+	const next = {};
+	for (const [entryId, entry] of Object.entries(annotations)) {
+		if (entry.body === void 0 || keep.has(entryId)) {
+			next[entryId] = entry;
+			continue;
+		}
+		const { body: _released, translation: _linked, ...rest } = entry;
+		if (rest.tagIds === void 0 && rest.error === void 0 && rest.fetch === void 0 && rest.title === void 0 && rest.excerpt === void 0) continue;
+		next[entryId] = rest;
+	}
+	return {
+		doc: {
+			...doc,
+			annotations: next
+		},
+		changed: true
+	};
+}
+/**
+* Drop tags nothing references any more.
+*
+* @param doc - the document to prune.
+* @returns the pruned document, and how many tags went.
+*/
+function pruneOrphanTags(doc) {
+	const annotations = doc.annotations ?? {};
+	const used = new Set(Object.values(annotations).flatMap((entry) => entry.tagIds ?? []));
+	const tags = doc.tags ?? {};
+	const kept = {};
+	let removed = 0;
+	for (const [id, tag] of Object.entries(tags)) if (used.has(id)) kept[id] = tag;
+	else removed += 1;
+	if (removed === 0) return {
+		doc,
+		removed
+	};
+	return {
+		doc: {
+			...doc,
+			tags: kept
+		},
+		removed
+	};
+}
+/** One memory entry's approximate size in characters (key + both texts + stamp). */
+function memoryEntryChars(key, entry) {
+	return key.length + entry.source.length + entry.target.length + 24;
+}
+/** One entry translation's size in characters, as recorded or estimated. */
+function entryTranslationChars(translation) {
+	if (translation.chars !== void 0) return translation.chars;
+	return Object.entries(translation.segments ?? {}).reduce((sum, [hash, target]) => sum + hash.length + target.length + 2, 0);
+}
+/**
+* Bound the two translation tiers to their shared budget, LRU by last use.
+*
+* The eviction list is ONE ordering across the global memory and every entry's
+* segment map: a sentence remembered and a per-entry map are the same kind of
+* thing (a translation that was paid for), so the oldest lastUsedAt goes first
+* regardless of which tier holds it. Two extra rules ride the same walk,
+* because it is the only place both tiers are walked: schema-version mismatches
+* are evicted on sight (the lazy half of "version bump = miss"), and the memory
+* table answers to its own count cap even when the budget has room.
+*
+* Pure over plain records: the service wires the files, this decides.
+*
+* @param memory - the global sentence memory (table content).
+* @param annotations - the document's annotations (entry translations included).
+* @param budgetChars - the shared budget.
+* @returns the bounded records, plus WHICH keys each tier lost (the caller
+*   applies the entry evictions to the freshest document inside its commit).
+*/
+function boundTranslations(memory, annotations, budgetChars) {
+	let nextMemory = memory;
+	const evictedMemoryKeys = [];
+	const keysByAge = Object.keys(memory).sort((a, b) => memory[a].lastUsedAt.localeCompare(memory[b].lastUsedAt));
+	if (keysByAge.length > 5e4) {
+		nextMemory = { ...memory };
+		for (const key of keysByAge.slice(0, keysByAge.length - MAX_TRANSLATION_MEMORY_ENTRIES)) {
+			delete nextMemory[key];
+			evictedMemoryKeys.push(key);
+		}
+	}
+	const ladder = [];
+	let total = 0;
+	for (const [key, entry] of Object.entries(nextMemory)) {
+		const chars = memoryEntryChars(key, entry);
+		total += chars;
+		ladder.push({
+			at: entry.lastUsedAt,
+			chars,
+			kind: "memory",
+			key,
+			stale: false
+		});
+	}
+	for (const [entryId, annotation] of Object.entries(annotations)) {
+		const translation = annotation.translation;
+		if (translation === void 0) continue;
+		const stale = translation.version !== 1;
+		const chars = entryTranslationChars(translation);
+		if (!stale) total += chars;
+		ladder.push({
+			at: stale ? (/* @__PURE__ */ new Date(0)).toISOString() : translation.lastUsedAt,
+			chars,
+			kind: "entry",
+			key: entryId,
+			stale
+		});
+	}
+	ladder.sort((a, b) => a.at.localeCompare(b.at));
+	const evictedEntryIds = [];
+	let nextAnnotations;
+	for (const item of ladder) {
+		if (!item.stale && total <= budgetChars) break;
+		if (item.kind === "memory") {
+			if (nextMemory === memory) nextMemory = { ...memory };
+			if (nextMemory[item.key] !== void 0) {
+				delete nextMemory[item.key];
+				total -= item.chars;
+				evictedMemoryKeys.push(item.key);
+			}
+		} else {
+			const annotation = (nextAnnotations ?? annotations)[item.key];
+			if (annotation?.translation !== void 0) {
+				if (nextAnnotations === void 0) nextAnnotations = { ...annotations };
+				const { translation: _evicted, ...rest } = annotation;
+				nextAnnotations[item.key] = rest;
+				if (!item.stale) total -= item.chars;
+				evictedEntryIds.push(item.key);
+			}
+		}
+	}
+	return {
+		memory: nextMemory,
+		annotations: nextAnnotations ?? annotations,
+		evictedMemoryKeys,
+		evictedEntryIds
+	};
+}
+/** The table's approximate size in characters, for the document's manifest. */
+function memoryTableChars(entries) {
+	return Object.entries(entries).reduce((sum, [key, entry]) => sum + memoryEntryChars(key, entry), 0);
+}
+//#endregion
+//#region lib/types/schedule.js
+/**
+* The daily-refresh clock: pure date math, deliberately separated from the
+* service that arms it.
+*
+* There is no host scheduler to hang a "refresh every morning" job on — the
+* host's `ctx.timer` is fiber-scoped `timeout`/`interval`/`throttle`/`debounce`
+* only, and `dsh-schedule` is agent-session reminders rather than a service a
+* plugin may schedule against. So the plugin owns a `setTimeout` and the only
+* interesting part is deciding *when* — which is what lives here, as functions
+* that take a `now` and are therefore testable without a clock.
+*
+* @module @khorsheed/dsh-reader/schedule
+*/
+/** Milliseconds in one day. */
+const DAY_MS = 864e5;
+/**
+* Parse an `HH:MM` string into hours and minutes.
+*
+* A malformed value falls back to the caller's default rather than throwing: a
+* hand-edited state file must not be able to break the refresh loop.
+*
+* @param value - the configured time of day.
+* @param fallback - the value to use when `value` is unusable.
+* @returns the parsed hour and minute.
+*/
+function parseTimeOfDay(value, fallback) {
+	return parseOrFallback(value) ?? parseOrFallback(fallback) ?? {
+		hour: 10,
+		minute: 0
+	};
+}
+/** Parse one candidate, or `undefined` when it is not a valid `HH:MM`. */
+function parseOrFallback(value) {
+	if (value === void 0) return void 0;
+	const match = /^(\d{1,2}):(\d{2})$/.exec(value.trim());
+	if (match === null) return void 0;
+	const hour = Number(match[1]);
+	const minute = Number(match[2]);
+	if (!Number.isFinite(hour) || !Number.isFinite(minute)) return void 0;
+	if (hour < 0 || hour > 23 || minute < 0 || minute > 59) return void 0;
+	return {
+		hour,
+		minute
+	};
+}
+/**
+* The next wall-clock occurrence of `timeOfDay` strictly after `now`.
+*
+* Computed through the local-time constructor rather than by adding a fixed
+* day length, so a DST shift moves the refresh to the same wall-clock time
+* instead of drifting an hour.
+*
+* @param now - the reference instant.
+* @param timeOfDay - the configured local time.
+* @returns the next occurrence.
+*/
+function nextOccurrence(now, timeOfDay) {
+	const { hour, minute } = parseTimeOfDay(timeOfDay, "10:00");
+	const candidate = new Date(now.getFullYear(), now.getMonth(), now.getDate(), hour, minute, 0, 0);
+	if (candidate.getTime() > now.getTime()) return candidate;
+	return new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1, hour, minute, 0, 0);
+}
+/**
+* The most recent occurrence of `timeOfDay` at or before `now` — the deadline
+* a catch-up refresh compares against.
+*
+* @param now - the reference instant.
+* @param timeOfDay - the configured local time.
+* @returns the most recent occurrence.
+*/
+function previousOccurrence(now, timeOfDay) {
+	const { hour, minute } = parseTimeOfDay(timeOfDay, "10:00");
+	const today = new Date(now.getFullYear(), now.getMonth(), now.getDate(), hour, minute, 0, 0);
+	if (today.getTime() <= now.getTime()) return today;
+	return new Date(now.getFullYear(), now.getMonth(), now.getDate() - 1, hour, minute, 0, 0);
+}
+/** Delay to the next occurrence, clamped to Node's timer ceiling. */
+const MAX_TIMEOUT_MS = 2147483647;
+/**
+* Whether a boot should refresh immediately because the last run missed its
+* slot — the thing that makes "daily refresh" true on a machine that was
+* asleep or whose process restarted.
+*
+* @param lastRun - the last completed refresh, if any.
+* @param now - the current instant.
+* @param timeOfDay - the configured local time.
+* @param enabled - whether the schedule is on at all.
+* @returns true when a catch-up run is due.
+*/
+function isCatchUpDue(lastRun, now, timeOfDay, enabled) {
+	if (!enabled) return false;
+	if (lastRun === void 0) return false;
+	return previousOccurrence(now, timeOfDay).getTime() > lastRun.getTime();
+}
+/**
+* The timer delay for the next occurrence, capped so a scheduler survives
+* dates beyond the 32-bit millisecond limit.
+*
+* @param now - the reference instant.
+* @param timeOfDay - the configured local time.
+* @returns the delay in milliseconds.
+*/
+function delayUntilNext(now, timeOfDay) {
+	const delta = nextOccurrence(now, timeOfDay).getTime() - now.getTime();
+	return Math.min(Math.max(0, delta), MAX_TIMEOUT_MS);
+}
+//#endregion
+//#region lib/types/arxiv.js
+/**
+* arXiv link recognition, and the upgrade to the official HTML version.
+*
+* Many papers carry a LaTeXML-built HTML rendering next to the abstract and the
+* PDF (`arxiv.org/html/<id>`): real tables, semantic sections and MathML
+* formulas, where the PDF is a byte stream and the abstract page is a summary.
+* A pasted `/abs` or `/pdf` link therefore upgrades to the HTML version BEFORE
+* the first fetch — the reader who pasted the paper meant the paper.
+*
+* Pure and network-free, so both the add flow and the link resolvers build on
+* it; the fetch policy (try the HTML version, fall back on 404) lives in the
+* service.
+*
+* @module @khorsheed/dsh-reader/arxiv
+*/
+/**
+* The id shapes arXiv assigns: new-style `YYMM.NNNNN(vN)` (month-keyed, four or
+* five sequence digits — six from 2027 on), or the archived subject-class form
+* `hep-th/9901001(vN)` / `math.GT/0309136(vN)`.
+*/
+const ARXIV_ID = /^(?:\d{4}\.\d{4,6}|[a-z-]+(?:\.[A-Z]{2})?\/\d{7})(?:v\d+)?$/;
+/** Whether a bare string is a syntactically valid arXiv id (the resolvers validate API answers with it). */
+function isArxivId(value) {
+	return ARXIV_ID.test(value);
+}
+/**
+* Parse an arxiv.org link to one paper.
+*
+* Only the three single-paper paths count: `/abs`, `/pdf`, `/html`. Listing,
+* search and author pages name no paper, so they read as ordinary links.
+*
+* @param url - the URL as pasted (already normalized by the caller).
+* @returns the parsed link, or `undefined`.
+*/
+function arxivLink(url) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		return;
+	}
+	const host = parsed.hostname.toLowerCase();
+	if (host !== "arxiv.org" && host !== "www.arxiv.org") return void 0;
+	const match = /^\/(abs|pdf|html)\/([^?#]+)/.exec(parsed.pathname);
+	const kind = match?.[1];
+	let id = match?.[2];
+	if (kind === void 0 || id === void 0) return void 0;
+	if (kind === "pdf" && /\.pdf$/i.test(id)) id = id.slice(0, -4);
+	if (!ARXIV_ID.test(id)) return void 0;
+	return {
+		kind,
+		id
+	};
+}
+/**
+* The official HTML version of an `/abs` or `/pdf` link.
+*
+* `undefined` when the link IS already the HTML page (no rewrite, so the add
+* flow can never loop) or is not an arXiv paper link at all. The HTML version
+* is not guaranteed to exist — old papers lack it — so the caller must treat
+* a 404 as "no upgrade", not as a failure of the link.
+*
+* @param url - the pasted arXiv URL.
+* @returns the HTML version's URL, or `undefined`.
+*/
+function arxivHtmlUrl(url) {
+	const link = arxivLink(url);
+	if (link === void 0 || link.kind === "html") return void 0;
+	return `https://arxiv.org/html/${link.id}`;
+}
+//#endregion
+//#region lib/types/link-resolvers.js
+/**
+* Paper-link resolvers: turn a link that NAMES a paper into the paper itself.
+*
+* A DOI or an OpenReview URL is a reference, not a readable page: doi.org
+* answers a cross-origin redirect the host seam refuses by design, and
+* openreview.net cannot be read server-side at all (measured 2026-09-20: the
+* API sits behind a Cloudflare challenge, the forum is a JS SPA whose static
+* title is always "Forum | OpenReview"). For such links the add flow asks this
+* module BEFORE fetching anything.
+*
+* Table-driven: one resolver per source, each answering an arXiv candidate, an
+* honest link-only verdict, or `null` ("not mine — take the ordinary path").
+* New sources (dblp, Semantic Scholar) are new rows, not new plumbing. The
+* network face is injected, so every branch is testable without a socket.
+*
+* The one rule the module exists to enforce: **a resolution is proven or
+* absent, never guessed.** A candidate that fails the gate degrades to the
+* ordinary path — a wrong paper filed under the reader's link is worse than a
+* card that says "open it in a browser".
+*
+* @module @khorsheed/dsh-reader/link-resolvers
+*/
+/** The DOI resolver covers the doi.org alias hosts; publisher URLs are out of scope. */
+const DOI_HOSTS = /* @__PURE__ */ new Set([
+	"doi.org",
+	"www.doi.org",
+	"dx.doi.org"
+]);
+/** A DOI is `10.<registrant>/<suffix>`; the registrant is 4–9 digits. */
+const DOI_PATH = /^\/(10\.\d{4,9}\/\S+)/;
+/** Crossref's filtered list route — see the resolver's doc comment on why not the work route. */
+const CROSSREF_SELECT = "DOI,title,author";
+/** The arXiv API phrase search silently answers nothing beyond six terms (measured). */
+const TITLE_QUERY_WORDS = 6;
+/** How many candidates one title search is read for. */
+const ARXIV_SEARCH_RESULTS = 5;
+const TITLE_SIMILARITY_STRICT = .95;
+/**
+* Lowercase, accent-folded, punctuation-to-space — the form two titles are
+* compared in. CJK characters are letters for this purpose (a Japanese paper
+* title must not collapse to nothing).
+*/
+function normalizeTitle(title) {
+	return title.normalize("NFKD").replace(/\p{M}/gu, "").toLowerCase().replace(/[^\p{L}\p{N}]+/gu, " ").trim();
+}
+/** Levenshtein distance, two rows, on ALREADY-normalized titles. */
+function editDistance(a, b) {
+	if (a === b) return 0;
+	if (a.length === 0) return b.length;
+	if (b.length === 0) return a.length;
+	let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+	for (let i = 1; i <= a.length; i++) {
+		const current = [i];
+		for (let j = 1; j <= b.length; j++) current[j] = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+		previous = current;
+	}
+	return previous[b.length];
+}
+/**
+* How alike two titles are: 1 for identical after normalization, 0 for nothing
+* in common. Either side empty is a 0 — there is nothing to compare.
+*/
+function titleSimilarity(a, b) {
+	const left = normalizeTitle(a);
+	const right = normalizeTitle(b);
+	if (left.length === 0 || right.length === 0) return 0;
+	if (left === right) return 1;
+	return 1 - editDistance(left, right) / Math.max(left.length, right.length);
+}
+/**
+* The family-name set of an author list, accent-folded and lowercased.
+*
+* Full names ("Nicholas G. Polson", the arXiv spelling) reduce to their last
+* token; structured records (Crossref's `family`) arrive already reduced.
+*/
+function familyNames(authors) {
+	const names = /* @__PURE__ */ new Set();
+	for (const author of authors) {
+		const last = normalizeTitle(author).split(" ").filter((part) => part.length > 0).at(-1);
+		if (last !== void 0) names.add(last);
+	}
+	return names;
+}
+/**
+* Whether one arXiv hit may stand in for the paper a DOI names.
+*
+* The author factor is what makes "no match → degrade" honest: short generic
+* titles collide across DIFFERENT papers (measured: Crossref's "Deep learning"
+* — LeCun, Bengio, Hinton — is a perfect title match for arXiv's "Deep
+* Learning" — Polson, Sokolov), so title similarity alone guesses.
+*
+* @param candidate - the arXiv hit.
+* @param wanted - the Crossref record's title and authors.
+* @returns true when the candidate is the same paper beyond a title accident.
+*/
+function gateArxivCandidate(candidate, wanted) {
+	const similarity = titleSimilarity(candidate.title, wanted.title);
+	const candidateNames = familyNames(candidate.authors);
+	const wantedNames = familyNames(wanted.authors);
+	if (candidateNames.size === 0 || wantedNames.size === 0) return similarity >= TITLE_SIMILARITY_STRICT;
+	const overlap = [...candidateNames].some((name) => wantedNames.has(name));
+	return similarity >= .85 && overlap;
+}
+/** The title phrase the arXiv API is asked for: the title's first words, quote-safe. */
+function titleQuery(title) {
+	return title.replace(/\s+/g, " ").trim().split(" ").slice(0, TITLE_QUERY_WORDS).join(" ").replace(/"+/g, " ").replace(/\s+/g, " ").trim();
+}
+/**
+* The entries of an arXiv API Atom answer. A deliberately narrow read — the
+* host runtime has no XML parser, and this document's shape is fixed: each
+* `<entry>` carries its `<id>` (the abs URL) and `<title>` first.
+*/
+function parseArxivSearch(xml) {
+	const hits = [];
+	for (const block of xml.split("<entry>").slice(1)) {
+		const id = /<id>https?:\/\/arxiv\.org\/abs\/([^<]+)<\/id>/.exec(block)?.[1]?.trim();
+		const rawTitle = /<title>([\s\S]*?)<\/title>/.exec(block)?.[1];
+		if (id === void 0 || rawTitle === void 0 || !isArxivId(id)) continue;
+		hits.push({
+			id,
+			title: unescapeXml(rawTitle).replace(/\s+/g, " ").trim(),
+			authors: [...block.matchAll(/<name>([^<]+)<\/name>/g)].map((match) => unescapeXml(match[1]).trim())
+		});
+	}
+	return hits;
+}
+/** The few entities an API title can carry. */
+function unescapeXml(value) {
+	return value.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&apos;/g, "'").replace(/&#(\d+);/g, (_, code) => String.fromCodePoint(Number(code))).replace(/&amp;/g, "&");
+}
+/**
+* Ask the arXiv API for papers titled like `title`.
+*
+* The phrase search accepts at most {@link TITLE_QUERY_WORDS} terms (measured:
+* a 7-word phrase answers an empty feed where its 6-word prefix finds the
+* paper), so the query is the title's prefix, and precision is the gate's job,
+* not the query's.
+*/
+async function searchArxiv(title, fetch) {
+	const phrase = titleQuery(title);
+	if (phrase.length === 0) return [];
+	const url = `https://export.arxiv.org/api/query?${new URLSearchParams({
+		search_query: `ti:"${phrase}"`,
+		max_results: String(ARXIV_SEARCH_RESULTS)
+	}).toString()}`;
+	let body;
+	try {
+		const response = await fetch(url);
+		if (response.statusCode !== 200) return [];
+		body = response.body;
+	} catch {
+		return [];
+	}
+	return parseArxivSearch(body);
+}
+/**
+* The title and authors Crossref has for one DOI, or `null`.
+*
+* The LIST route with a `doi:` filter is used, not `/works/<doi>`: the
+* single-work route rejects `select` (measured: `parameter-not-allowed`), and
+* an unfiltered work record can carry hundreds of references — past the fetch
+* seam's body cap, which truncates JSON into something unparseable. The
+* filtered route answers a few hundred bytes. A DOI Crossref does not know
+* (404, empty items) is not an error here: it is the ordinary path's business.
+*/
+async function crossrefWork(doi, fetch) {
+	const url = `https://api.crossref.org/works?${new URLSearchParams({
+		filter: `doi:${doi}`,
+		select: CROSSREF_SELECT
+	}).toString()}`;
+	let parsed;
+	try {
+		const response = await fetch(url);
+		if (response.statusCode !== 200) return null;
+		parsed = JSON.parse(response.body);
+	} catch {
+		return null;
+	}
+	const items = parsed?.message?.items;
+	const work = Array.isArray(items) ? items[0] : void 0;
+	if (typeof work !== "object" || work === null) return null;
+	const record = work;
+	const title = Array.isArray(record.title) ? record.title.find((item) => typeof item === "string" && item.length > 0) : void 0;
+	if (typeof title !== "string") return null;
+	return {
+		title,
+		authors: Array.isArray(record.author) ? record.author.flatMap((author) => {
+			const family = author?.family;
+			return typeof family === "string" && family.length > 0 ? [family] : [];
+		}) : []
+	};
+}
+/** The resolver table, in match order. */
+const LINK_RESOLVERS = [{
+	name: "doi",
+	match: (url) => DOI_HOSTS.has(url.hostname.toLowerCase()) && DOI_PATH.test(url.pathname),
+	resolve: async (url, fetch) => {
+		const doi = decodeURIComponent(DOI_PATH.exec(url.pathname)?.[1] ?? "");
+		if (doi.length === 0) return null;
+		const work = await crossrefWork(doi, fetch);
+		if (work === null) return null;
+		const hits = await searchArxiv(work.title, fetch);
+		let best;
+		for (const hit of hits) {
+			const similarity = titleSimilarity(hit.title, work.title);
+			if (best === void 0 || similarity > best.similarity) best = {
+				hit,
+				similarity
+			};
+		}
+		if (best === void 0 || !gateArxivCandidate(best.hit, work)) return null;
+		return {
+			kind: "arxiv",
+			id: best.hit.id,
+			title: best.hit.title
+		};
+	}
+}, {
+	name: "openreview",
+	match: (url) => {
+		const host = url.hostname.toLowerCase();
+		if (host !== "openreview.net" && host !== "www.openreview.net") return false;
+		return (url.pathname === "/forum" || url.pathname === "/pdf") && (url.searchParams.get("id") ?? "").length > 0;
+	},
+	resolve: () => Promise.resolve({
+		kind: "link-only",
+		code: "unreadable",
+		message: "OpenReview pages are script-rendered behind an anti-bot wall, so the server side cannot read them — if the paper has an arXiv version, paste that link instead"
+	})
+}];
+/**
+* Resolve a pasted link through the table.
+*
+* `null` — not an answer, but the ABSENCE of one — sends the URL down the
+* ordinary fetch-and-classify path. A resolver's own failure is caught by the
+* caller (the service): a DOI lookup that throws must not break an add.
+*
+* @param url - the normalized pasted URL.
+* @param fetch - the injected GET face.
+* @returns the resolution, or `null`.
+*/
+async function resolveLink(url, fetch) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		return null;
+	}
+	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 {};
+/**
+* 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;
+	ctx;
+	timer;
+	disposed = false;
+	/** The document of record when no filesystem is mounted. */
+	memoryDoc;
+	/**
+	* @param ctx - owning context.
+	* @param config - optional state-root override.
+	*/
+	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();
+	}
+	/** 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 }
+		}, {
+			code: resolution.code,
+			message: resolution.message,
+			at: now
+		}, now);
+		const resolvedId = resolution?.kind === "arxiv" ? resolution.id : void 0;
+		const upgrade = resolvedId === void 0 ? arxivHtmlUrl(url) : `https://arxiv.org/html/${resolvedId}`;
+		const fallbackUrl = resolvedId === void 0 ? url : `https://arxiv.org/abs/${resolvedId}`;
+		const resolvedFrom = resolvedId === void 0 ? void 0 : url;
+		if (upgrade !== void 0 && doc.sources.some((source) => sameTarget(source.url, upgrade))) return "duplicate";
+		let fetched;
+		try {
+			fetched = await this.fetchFollowing(upgrade ?? url);
+		} catch (error) {
+			if (upgrade !== void 0 && isNoHtmlVersion(error)) try {
+				fetched = await this.fetchFollowing(fallbackUrl);
+			} catch (fallbackError) {
+				return await this.saveLinkOnly({
+					url,
+					...request.label === void 0 ? {} : { label: request.label },
+					...resolvedFrom === void 0 ? {} : { resolvedFrom }
+				}, classifyFetchFailure(fallbackError, now), now);
+			}
+			else return await this.saveLinkOnly({
+				url,
+				...request.label === void 0 ? {} : { label: request.label },
+				...resolvedFrom === void 0 ? {} : { resolvedFrom }
+			}, classifyFetchFailure(error, now), now);
+		}
+		const feed = classifyPayload(fetched.raw) === "feed";
+		if (!feed) {
+			const problem = inspectPreview(fetched.raw, fetched.url, upgrade ?? url);
+			if (problem !== void 0) return await this.saveLinkOnly({
+				url: fetched.url,
+				...request.label === void 0 ? {} : { label: request.label },
+				...resolvedFrom === void 0 ? {} : { resolvedFrom }
+			}, {
+				code: problem.code,
+				message: problem.message,
+				at: now
+			}, now);
+		}
+		const label = request.label ?? (resolution?.kind === "arxiv" ? resolution.title : void 0) ?? defaultSourceLabel(fetched.url);
+		const source = {
+			id: `${feed ? "rss" : "link"}-${hash(fetched.url)}`,
+			kind: feed ? "rss" : "link",
+			url: fetched.url,
+			label,
+			enabled: true,
+			addedAt: now,
+			fetchedAt: now,
+			status: "ok",
+			...fetched.truncated ? { truncated: true } : {},
+			...resolvedFrom === void 0 ? {} : { resolvedFrom },
+			raw: fetched.raw
+		};
+		await this.commit((current) => ({
+			...current,
+			sources: [source, ...current.sources]
+		}));
+		return {
+			outcome: feed ? "subscribed" : "saved-link",
+			kind: source.kind,
+			id: source.id,
+			label
+		};
+	}
+	/**
+	* Persist a link the reader owns even though its body cannot be previewed.
+	*
+	* Two records, because two consumers ask different questions: the SOURCE
+	* carries the failure so the wall can mark the card and the backfill can
+	* leave a permanent wall alone, while the ENTRY annotation carries it so
+	* `getEntryBody` — the one call the detail view makes — explains itself
+	* instead of answering with a blank article.
+	*
+	* @param request - the final URL, an optional label, and the pasted URL when
+	*   this link was resolved to a canonical version.
+	* @param failure - the classified reason, with its timestamp.
+	* @param now - the commit instant.
+	* @returns the add outcome the browser reports.
+	*/
+	async saveLinkOnly(request, failure, now) {
+		const label = request.label ?? defaultSourceLabel(request.url);
+		const source = {
+			id: `link-${hash(request.url)}`,
+			kind: "link",
+			url: request.url,
+			label,
+			enabled: true,
+			addedAt: now,
+			fetchedAt: now,
+			status: "error",
+			error: failure.message,
+			failure,
+			...request.resolvedFrom === void 0 ? {} : { resolvedFrom: request.resolvedFrom }
+		};
+		await this.commit((current) => ({
+			...current,
+			sources: [source, ...current.sources]
+		}));
+		await this.recordFetchFailure(linkEntryId(source.id), failure.message);
+		return {
+			outcome: "saved-link",
+			kind: "link",
+			id: source.id,
+			label,
+			failure: {
+				code: failure.code,
+				message: failure.message
+			}
+		};
+	}
+	/**
+	* Update a source's mutable fields, or the global refresh time.
+	*
+	* @param request - the id plus the fields to change.
+	* @returns the outcome, or a domain refusal.
+	*/
+	async updateSource(request) {
+		if (!(await this.currentDoc()).sources.some((source) => source.id === request.id)) return "not-found";
+		if (request.timeOfDay !== void 0 && !/^\d{1,2}:\d{2}$/.test(request.timeOfDay)) return "invalid-time";
+		const url = request.url === void 0 || request.url === "" ? void 0 : normalizeUrl(request.url);
+		if (request.url !== void 0 && request.url !== "" && url === void 0) return "invalid-url";
+		await this.commit((current) => ({
+			...current,
+			sources: current.sources.map((source) => source.id === request.id ? {
+				...source,
+				...request.enabled !== void 0 ? { enabled: request.enabled } : {},
+				...request.label !== void 0 && request.label !== "" ? { label: request.label } : {},
+				...url !== void 0 ? {
+					url,
+					status: "ok"
+				} : {}
+			} : source),
+			...request.timeOfDay !== void 0 ? { refresh: {
+				...current.refresh,
+				timeOfDay: request.timeOfDay
+			} } : {}
+		}));
+		if (request.timeOfDay !== void 0) await this.armSchedule();
+		return "ok";
+	}
+	/**
+	* Remove a source.
+	*
+	* Its entries' TRANSLATIONS go with it: the entries themselves are unreachable
+	* once the source is gone (the recent page disables them), so their exact-fit
+	* maps are dead weight. The host never parses feeds, so the caller passes the
+	* entry ids it has parsed; a link source's single entry id is derivable here
+	* regardless. The cached BODIES stay — the body budget owns their lifetime,
+	* unchanged.
+	*
+	* @param request - the source id, plus the entries the caller knows belong to it.
+	* @returns the outcome, or a domain refusal.
+	*/
+	async removeSource(request) {
+		if (!(await this.currentDoc()).sources.some((source) => source.id === request.id)) return "not-found";
+		const entryIds = new Set(request.entryIds ?? []);
+		entryIds.add(linkEntryId(request.id));
+		await this.commit((current) => {
+			let annotations = current.annotations;
+			const touched = {};
+			let changed = false;
+			for (const id of entryIds) {
+				const annotation = annotations?.[id];
+				if (annotation?.translation === void 0) continue;
+				const { translation: _gone, ...rest } = annotation;
+				touched[id] = rest;
+				changed = true;
+			}
+			if (changed) annotations = {
+				...annotations,
+				...touched
+			};
+			return {
+				...current,
+				sources: current.sources.filter((source) => source.id !== request.id),
+				...changed ? { annotations } : {}
+			};
+		});
+		return "ok";
+	}
+	/**
+	* Refresh the enabled sources, or the named ones.
+	*
+	* @param request - optional id list.
+	* @returns one result per attempted source.
+	*/
+	async refresh(request = {}) {
+		const doc = await this.currentDoc();
+		const wanted = request.ids === void 0 ? doc.sources.filter((source) => source.enabled) : doc.sources.filter((source) => request.ids?.includes(source.id) === true);
+		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
+					};
+					patches.set(source.id, {
+						...withoutFailure({
+							...source,
+							url: fetched.url,
+							...source.raw === void 0 ? {} : { raw: source.raw }
+						}),
+						fetchedAt,
+						status: "error",
+						error: failure.message,
+						failure
+					});
+					await this.recordFetchFailure(linkEntryId(source.id), failure.message);
+					results.push({
+						id: source.id,
+						status: "unavailable",
+						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
+				});
+			}
+		}
+		if (patches.size > 0) await this.commit((current) => ({
+			...current,
+			lastRefreshAt: (/* @__PURE__ */ new Date()).toISOString(),
+			sources: current.sources.map((source) => patches.get(source.id) ?? source)
+		}));
+		return { results };
+	}
+	/**
+	* Hand back raw payloads for the browser to parse.
+	*
+	* @param request - the source ids whose payloads are wanted.
+	* @returns one body per requested id; an error instead of a payload when
+	*   nothing usable is stored.
+	*/
+	async getBodies(request) {
+		const doc = await this.currentDoc();
+		const byId = new Map(doc.sources.map((source) => [source.id, source]));
+		return { bodies: request.ids.map((id) => {
+			const source = byId.get(id);
+			if (source === void 0) return {
+				id,
+				error: "not-found"
+			};
+			const meta = source.kind === "link" ? doc.annotations?.[linkEntryId(source.id)] : void 0;
+			const carried = {
+				...meta?.title === void 0 ? {} : { title: meta.title },
+				...meta?.excerpt === void 0 ? {} : { excerpt: meta.excerpt }
+			};
+			if (source.raw === void 0) return {
+				id,
+				error: source.error ?? "no payload stored yet",
+				...carried
+			};
+			return {
+				id,
+				raw: source.raw,
+				...source.truncated === true ? { truncated: true } : {},
+				...carried
+			};
+		}) };
+	}
+	/**
+	* Pass a ref block to the side-chat service when one is composed.
+	*
+	* @param request - the target context, its label, and the ref text.
+	* @returns `'ok'`, or `'unavailable'` when no side chat is mounted.
+	*/
+	async quoteToSideChat(request) {
+		const sideChat = this.sideChat();
+		if (sideChat === void 0) return "unavailable";
+		try {
+			await sideChat.openWith({
+				contextKey: request.contextKey,
+				label: request.label,
+				refs: [{
+					label: request.label,
+					text: request.text
+				}]
+			});
+			return "ok";
+		} catch {
+			return "unavailable";
+		}
+	}
+	/**
+	* The body the detail view should render for one entry, if any.
+	*
+	* The order is the whole contract: a fresh cached fetch wins (it is full text
+	* the reader already paid for), then the feed's own payload, and only when
+	* neither exists does the view offer to fetch. A STALE cache entry reports
+	* `fresh: false` and no html — the detail view then offers the fetch again
+	* rather than quietly serving yesterday's copy.
+	*
+	* @param request - the entry and the payload the feed gave for it.
+	* @returns what there is to show, and whether a fetch is worth offering.
+	*/
+	async getEntryBody(request) {
+		const doc = await this.currentDoc();
+		const cached = doc.annotations?.[request.entryId]?.body;
+		if (cached !== void 0) {
+			const fresh = isFresh(cached.expiresAt);
+			const html = cached.file === void 0 ? cached.html : fresh && cached.url === request.url ? this.store.readBody(cached.file) : void 0;
+			return {
+				entryId: request.entryId,
+				cached: true,
+				fresh,
+				fromFeed: false,
+				fetchedAt: cached.fetchedAt,
+				...cached.truncated === true ? { truncated: true } : {},
+				...cached.scriptFigures === void 0 ? {} : { scriptFigures: cached.scriptFigures },
+				...cached.rendered === true ? { rendered: true } : {},
+				...html === void 0 || !fresh || cached.url !== request.url ? {} : { html }
+			};
+		}
+		if (request.feedHtml !== void 0 && request.feedHtml.length > 0) return {
+			entryId: request.entryId,
+			cached: false,
+			fresh: true,
+			fromFeed: true,
+			html: request.feedHtml
+		};
+		const failure = doc.annotations?.[request.entryId];
+		return {
+			entryId: request.entryId,
+			cached: false,
+			fresh: true,
+			fromFeed: false,
+			...failure?.error === void 0 ? {} : { error: failure.error }
+		};
+	}
+	/**
+	* Fetch one entry's article and hand the raw HTML to the browser.
+	*
+	* The HOST does not extract: extraction needs a DOM, and this runtime has no
+	* XML/HTML parser at all (the same reason feed parsing lives in the browser
+	* half). So this verb is the network half only — it returns what came back,
+	* and `storeEntryBody` persists what the browser made of it.
+	*
+	* Fetching here is deliberately NOT automatic on refresh: doing it for every
+	* summary-only entry would make this a crawler of other people's sites, which
+	* the design refuses. One entry, one fetch, on the reader's request.
+	*
+	* @param request - the entry and its article URL.
+	* @returns the raw payload, or why there is none.
+	*/
+	async fetchEntryBody(request) {
+		const url = normalizeUrl(request.url);
+		if (url === void 0) {
+			await this.recordFetchFailure(request.entryId, "invalid-url");
+			return {
+				entryId: request.entryId,
+				error: "invalid-url"
+			};
+		}
+		await this.markFetching(request.entryId);
+		try {
+			const fetched = await this.fetchFollowing(url);
+			const rawFile = await this.storeRaw(request.entryId, fetched.raw, fetched.url, fetched.truncated);
+			return {
+				entryId: request.entryId,
+				url: fetched.url,
+				raw: fetched.raw,
+				...rawFile === void 0 ? {} : { rawFile },
+				...fetched.truncated ? { truncated: true } : {}
+			};
+		} catch (error) {
+			const failure = classifyFetchFailure(error, (/* @__PURE__ */ new Date()).toISOString());
+			await this.recordFetchFailure(request.entryId, failure.message, failure.code);
+			return {
+				entryId: request.entryId,
+				error: failure.message
+			};
+		}
+	}
+	/**
+	* Which entries have a body, a stored raw payload, or a recorded failure.
+	*
+	* The wall needs this per ENTRY (entries come from the browser's parse of a
+	* feed), so it cannot ride the source summaries. `raw` means "fetched, not yet
+	* extracted" — the browser half turns those into bodies on its next load.
+	*
+	* @param request - the entry ids the caller is showing.
+	* @returns one state per requested id.
+	*/
+	async entryFetchStates(request) {
+		const doc = await this.currentDoc();
+		const states = {};
+		const now = Date.now();
+		for (const entryId of request.entryIds) {
+			const annotation = doc.annotations?.[entryId];
+			if (annotation?.body !== void 0 && isFresh(annotation.body.expiresAt)) {
+				states[entryId] = {
+					state: "ready",
+					...annotation.body.fetchedAt === void 0 ? {} : { at: annotation.body.fetchedAt }
+				};
+				continue;
+			}
+			const fetch = annotation?.fetch;
+			if (fetch?.state === "raw") {
+				states[entryId] = {
+					state: "raw",
+					at: fetch.at
+				};
+				continue;
+			}
+			if (fetch?.state === "fetching" && isRecent(fetch.at, now, FETCH_STALE_MS)) {
+				states[entryId] = {
+					state: "fetching",
+					at: fetch.at
+				};
+				continue;
+			}
+			if (annotation?.error !== void 0 && annotation.failedAt !== void 0) {
+				states[entryId] = {
+					state: "failed",
+					at: annotation.failedAt,
+					message: annotation.error,
+					...annotation.failureCode === void 0 ? {} : { code: annotation.failureCode }
+				};
+				continue;
+			}
+			states[entryId] = { state: "none" };
+		}
+		return { states };
+	}
+	/**
+	* Hand back a stored raw payload so the browser can extract it.
+	*
+	* @param request - the entry whose payload is wanted.
+	* @returns the payload, or why there is none.
+	*/
+	async getRawBody(request) {
+		const annotation = (await this.currentDoc()).annotations?.[request.entryId];
+		const file = annotation?.fetch?.state === "raw" ? annotation.fetch.rawFile : void 0;
+		if (file === void 0) return {
+			entryId: request.entryId,
+			error: "no stored payload"
+		};
+		const raw = this.store.readBody(file);
+		if (raw === void 0) return {
+			entryId: request.entryId,
+			error: "stored payload is gone"
+		};
+		return {
+			entryId: request.entryId,
+			raw,
+			...annotation?.fetch?.url === void 0 ? {} : { url: annotation.fetch.url },
+			...annotation?.fetch?.truncated === true ? { truncated: true } : {}
+		};
+	}
+	/** Record that a fetch is in flight, so a wall reopened later can say so. */
+	async markFetching(entryId) {
+		await this.commit((current) => ({
+			...current,
+			annotations: {
+				...current.annotations,
+				[entryId]: {
+					...current.annotations?.[entryId],
+					fetch: {
+						state: "fetching",
+						at: (/* @__PURE__ */ new Date()).toISOString()
+					}
+				}
+			}
+		}));
+	}
+	/**
+	* Store one raw payload for later extraction.
+	*
+	* @param entryId - the entry it belongs to.
+	* @param raw - the payload.
+	* @returns the file name, or `undefined` when the deployment has no fs.
+	*/
+	async storeRaw(entryId, raw, url, truncated) {
+		if (!this.store.available) return void 0;
+		const file = this.store.writeBody(`${entryId}#raw`, raw);
+		await this.commit((current) => ({
+			...current,
+			annotations: {
+				...current.annotations,
+				[entryId]: {
+					...current.annotations?.[entryId],
+					fetch: {
+						state: "raw",
+						at: (/* @__PURE__ */ new Date()).toISOString(),
+						rawFile: file,
+						chars: raw.length,
+						url,
+						...truncated ? { truncated: true } : {}
+					}
+				}
+			}
+		}));
+		return file;
+	}
+	/**
+	* Cache the markup the browser extracted for one entry.
+	*
+	* The deadline is computed here, not on the client, so the policy has exactly
+	* one owner (this service's document) — a client that guessed the TTL would
+	* be a second implementation of it.
+	*
+	* @param request - the entry, the markup, and the URL it came from.
+	* @returns the stored view.
+	*/
+	async storeEntryBody(request) {
+		const html = request.html.trim();
+		if (html.length === 0) {
+			await this.recordFetchFailure(request.entryId, "empty extraction");
+			return {
+				entryId: request.entryId,
+				cached: false,
+				fresh: false,
+				fromFeed: false,
+				error: "empty extraction"
+			};
+		}
+		const ttlHours = (await this.currentDoc()).cache?.ttlHours ?? DEFAULT_CACHE_POLICY.ttlHours;
+		const now = /* @__PURE__ */ new Date();
+		const sidecar = html.length > 262144 ? this.store.writeBody(request.entryId, html) : void 0;
+		const body = {
+			...sidecar === void 0 ? { html } : {
+				file: sidecar,
+				chars: html.length
+			},
+			fetchedAt: now.toISOString(),
+			expiresAt: ttlHours === 0 ? 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 },
+			...request.rendered === true ? { rendered: true } : {}
+		};
+		await this.commit((current) => {
+			const existing = current.annotations?.[request.entryId];
+			const tagIds = existing?.tagIds;
+			const translation = existing?.translation !== void 0 && request.bodyHash !== void 0 && existing.translation.bodyHash === request.bodyHash ? existing.translation : void 0;
+			const title = metaText(request.title, 300) ?? existing?.title;
+			const excerpt = metaText(request.excerpt, 1e3) ?? existing?.excerpt;
+			return {
+				...current,
+				annotations: {
+					...current.annotations,
+					[request.entryId]: {
+						body,
+						...tagIds === void 0 ? {} : { tagIds },
+						...translation === void 0 ? {} : { translation },
+						...title === void 0 ? {} : { title },
+						...excerpt === void 0 ? {} : { excerpt }
+					}
+				}
+			};
+		});
+		return {
+			entryId: request.entryId,
+			cached: true,
+			fresh: true,
+			fromFeed: false,
+			html,
+			fetchedAt: body.fetchedAt,
+			...body.truncated === true ? { truncated: true } : {},
+			...body.scriptFigures === void 0 ? {} : { scriptFigures: body.scriptFigures },
+			...body.rendered === true ? { rendered: true } : {}
+		};
+	}
+	/**
+	* Which entries still need their full text, and which may be retried.
+	*
+	* The host is the only side that can answer this: it holds the cache, the
+	* recorded failures and the policy. A failure is retried only after
+	* `BACKFILL_RETRY_MS` — an entry whose publisher refuses us must not be
+	* hammered once per refresh, which would make this a crawler with a grudge.
+	*
+	* @param request - the entries the caller is looking at (id, url, label) and
+	*   whether the caller already has full text for them (the feed's own payload).
+	* @returns the candidates, capped so one refresh cannot start a stampede.
+	*/
+	async listBackfillCandidates(request) {
+		const doc = await this.currentDoc();
+		const limit = Math.max(1, Math.min(request.limit ?? 8, 8));
+		const candidates = [];
+		const now = Date.now();
+		for (const entry of request.entries) {
+			if (entry.url === "") continue;
+			if (entry.hasBody) 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];
+			if (annotation?.body !== void 0 && isFresh(annotation.body.expiresAt)) continue;
+			if (annotation?.failedAt !== void 0) {
+				const failedAt = new Date(annotation.failedAt).getTime();
+				if (Number.isFinite(failedAt) && now - failedAt < 216e5) continue;
+			}
+			candidates.push({
+				entryId: entry.entryId,
+				url: entry.url,
+				label: entry.label,
+				...annotation?.error === void 0 ? {} : { lastError: annotation.error }
+			});
+			if (candidates.length >= limit) break;
+		}
+		return { candidates };
+	}
+	/**
+	* One entry's exact-fit translation record, with its segment map resolved.
+	*
+	* A record from an older storage schema, or one whose sidecar file is gone,
+	* reads as absent — the caller falls back to the global memory, and the stale
+	* record is carried out by the next write or budget pass (lazy, never wiped).
+	*
+	* @param request - the entry.
+	* @returns the record, or nothing usable.
+	*/
+	async getEntryTranslation(request) {
+		const record = (await this.currentDoc()).annotations?.[request.entryId]?.translation;
+		if (record === void 0 || record.version !== 1) return {};
+		const segments = record.segments !== void 0 ? { ...record.segments } : record.file === void 0 ? void 0 : readSegmentsFile(this.store.readBody(record.file));
+		if (segments === void 0) return {};
+		return { translation: {
+			pair: record.pair,
+			bodyHash: record.bodyHash,
+			segments
+		} };
+	}
+	/**
+	* The translations for exactly the sentences asked about, of one pair.
+	*
+	* The client hashes the body's sentences itself, so the slice is precise and
+	* the whole table never crosses the wire. Reads do not rewrite the file:
+	* the LRU stamp moves when the sentence next serves (the client's batched
+	* report of what it reused), not when a list of hashes arrives.
+	*
+	* @param request - the pair label and the sentence hashes wanted.
+	* @returns hash → translation for the hits.
+	*/
+	async getSentenceTranslations(request) {
+		const memory = await this.translationMemory();
+		const translations = {};
+		for (const hash of request.hashes.slice(0, TRANSLATION_SLICE_LIMIT)) {
+			if (typeof hash !== "string" || hash.length === 0) continue;
+			const hit = memory[`${request.pair}:${hash}`];
+			if (hit !== void 0) translations[hash] = hit.target;
+		}
+		return { translations };
+	}
+	/**
+	* Persist what one translation run produced, in one batch.
+	*
+	* `entries` are the sentences the model just translated: they upsert into the
+	* global memory AND the entry's exact-fit map. `recalled` are the sentences
+	* the run was served from memory: their lastUsedAt bumps (that is what makes
+	* the budget's LRU a use-clock rather than a write-clock), and they join the
+	* entry map too, so the map stays the complete record of this body. When
+	* `entryId` + `bodyHash` are present the entry map is REWRITTEN to the run's
+	* full sentence set — the run saw the whole body, so a merge would only
+	* preserve sentences the current body no longer has.
+	*
+	* @param request - the pair, the learned and recalled sentences, and the
+	*   entry identity when this run was an article's.
+	* @returns how many sentences were newly learned.
+	*/
+	async rememberSentences(request) {
+		const pair = request.pair.trim();
+		if (pair.length === 0) return { stored: 0 };
+		const learned = normalizeLearns(request.entries);
+		const recalled = normalizeLearns(request.recalled ?? []);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const doc = await this.currentDoc();
+		const budget = doc.cache?.translationBudgetChars ?? 67108864;
+		const memory = { ...await this.translationMemory() };
+		let memoryChanged = false;
+		for (const learn of [...learned, ...recalled]) {
+			memory[`${pair}:${learn.hash}`] = {
+				source: learn.source,
+				target: learn.target,
+				lastUsedAt: now
+			};
+			memoryChanged = true;
+		}
+		let entryWrite;
+		if (request.entryId !== void 0 && request.bodyHash !== void 0) {
+			const segments = {};
+			for (const learn of [...learned, ...recalled]) segments[learn.hash] = learn.target;
+			const entryId = request.entryId;
+			let translation = {
+				version: 1,
+				pair,
+				bodyHash: request.bodyHash,
+				translatedAt: doc.annotations?.[entryId]?.translation?.translatedAt ?? now,
+				lastUsedAt: now
+			};
+			const serialized = JSON.stringify(segments);
+			if (serialized.length > 262144) translation = {
+				...translation,
+				file: this.store.writeBody(`${entryId}#translation`, serialized),
+				chars: serialized.length
+			};
+			else translation = {
+				...translation,
+				segments,
+				chars: serialized.length
+			};
+			entryWrite = {
+				entryId,
+				translation
+			};
+		}
+		const bounded = boundTranslations(memory, {
+			...doc.annotations ?? {},
+			...entryWrite === void 0 ? {} : { [entryWrite.entryId]: {
+				...doc.annotations?.[entryWrite.entryId],
+				translation: entryWrite.translation
+			} }
+		}, budget);
+		if (bounded.evictedMemoryKeys.length > 0) memoryChanged = true;
+		if (memoryChanged) {
+			const table = {
+				version: 1,
+				entries: bounded.memory
+			};
+			this.store.writeNamedBody(TRANSLATION_MEMORY_FILE, JSON.stringify(table));
+		}
+		await this.commit((current) => {
+			let annotations;
+			if (entryWrite !== void 0 || bounded.evictedEntryIds.length > 0) {
+				annotations = { ...current.annotations };
+				if (entryWrite !== void 0) annotations[entryWrite.entryId] = {
+					...annotations[entryWrite.entryId],
+					translation: entryWrite.translation
+				};
+				for (const id of bounded.evictedEntryIds) {
+					const annotation = annotations[id];
+					if (annotation?.translation === void 0) continue;
+					const { translation: _evicted, ...rest } = annotation;
+					annotations[id] = rest;
+				}
+			}
+			return {
+				...current,
+				...annotations === void 0 ? {} : { annotations },
+				...memoryChanged ? { translationMemory: {
+					version: 1,
+					file: TRANSLATION_MEMORY_FILE,
+					entries: Object.keys(bounded.memory).length,
+					chars: memoryTableChars(bounded.memory),
+					updatedAt: now
+				} } : {}
+			};
+		});
+		return { stored: learned.length };
+	}
+	/**
+	* How much the two caches currently hold, aggregated on the host.
+	*
+	* The tables themselves never cross the wire for a settings readout: counts
+	* and characters only. The characters are the store's own accounting unit —
+	* the same numbers the budgets bound.
+	*
+	* @returns per-tier usage.
+	*/
+	async getStorageStats() {
+		const doc = await this.currentDoc();
+		let bodyEntries = 0;
+		let bodyChars = 0;
+		let translationEntries = 0;
+		let translationChars = 0;
+		for (const annotation of Object.values(doc.annotations ?? {})) {
+			const body = annotation.body;
+			if (body !== void 0) {
+				bodyEntries += 1;
+				bodyChars += body.chars ?? body.html?.length ?? 0;
+			}
+			const translation = annotation.translation;
+			if (translation !== void 0) {
+				translationEntries += 1;
+				translationChars += translation.chars ?? Object.entries(translation.segments ?? {}).reduce((sum, [hash, target]) => sum + hash.length + target.length + 2, 0);
+			}
+		}
+		return {
+			bodies: {
+				entries: bodyEntries,
+				chars: bodyChars
+			},
+			translations: {
+				entries: translationEntries,
+				chars: translationChars,
+				memoryEntries: doc.translationMemory?.entries ?? 0,
+				memoryChars: doc.translationMemory?.chars ?? 0
+			}
+		};
+	}
+	/**
+	* Forget every translation: the global sentence memory AND every entry map.
+	*
+	* The manage page's one gesture for it, after its own confirm. Bodies, tags,
+	* the recent list and the sources are untouched — the reader is clearing a
+	* derived cache, not their library. The commit's own `pruneBodies` sweep
+	* takes the files once the document no longer names them.
+	*
+	* @returns how many entry maps went, and whether the memory table went.
+	*/
+	async clearTranslations() {
+		const doc = await this.currentDoc();
+		const clearedEntries = Object.values(doc.annotations ?? {}).filter((annotation) => annotation.translation !== void 0).length;
+		const clearedMemory = doc.translationMemory !== void 0;
+		if (clearedEntries === 0 && !clearedMemory) return {
+			clearedEntries: 0,
+			clearedMemory: false
+		};
+		await this.commit((current) => {
+			const annotations = {};
+			for (const [id, annotation] of Object.entries(current.annotations ?? {})) {
+				if (annotation.translation === void 0) {
+					annotations[id] = annotation;
+					continue;
+				}
+				const { translation: _cleared, ...rest } = annotation;
+				annotations[id] = rest;
+			}
+			const { translationMemory: _dropped, ...rest } = current;
+			return {
+				...rest,
+				annotations
+			};
+		});
+		return {
+			clearedEntries,
+			clearedMemory
+		};
+	}
+	/**
+	* The global sentence memory's table, from its sidecar file.
+	*
+	* Read per call, not cached: the file is the truth, and the service's own
+	* commits are the only writes — a cache keyed on the manifest would save a
+	* few MB of JSON parsing per translation run at the price of a coherence
+	* story. An absent, unreadable, or stale-version file reads as empty (the
+	* lazy half of the schema version).
+	*/
+	async translationMemory() {
+		const manifest = (await this.currentDoc()).translationMemory;
+		if (manifest === void 0) return {};
+		const raw = this.store.readBody(manifest.file);
+		if (raw === void 0) return {};
+		try {
+			const table = JSON.parse(raw);
+			if (table.version !== 1 || typeof table.entries !== "object" || table.entries === null) return {};
+			return { ...table.entries };
+		} catch {
+			return {};
+		}
+	}
+	/** The tag vocabulary plus which entry ids carry each tag. */
+	async listTags() {
+		const doc = await this.currentDoc();
+		const tags = Object.values(doc.tags ?? {}).sort((a, b) => a.name.localeCompare(b.name));
+		const counts = {};
+		for (const annotation of Object.values(doc.annotations ?? {})) for (const id of annotation.tagIds ?? []) counts[id] = (counts[id] ?? 0) + 1;
+		return {
+			tags,
+			counts
+		};
+	}
+	/**
+	* Create a tag, or return the existing one with the same name.
+	*
+	* Names are matched case-insensitively on purpose: "AI" and "ai" becoming two
+	* tags is what makes a tag system useless for filtering, and the reader
+	* cannot be expected to remember which spelling they used.
+	*
+	* @param request - the name to create or find.
+	* @returns the tag id, or a refusal.
+	*/
+	async createTag(request) {
+		const name = request.name.trim().slice(0, 40);
+		if (name.length === 0) return "empty";
+		const doc = await this.currentDoc();
+		const existing = Object.values(doc.tags ?? {}).find((tag) => tag.name.toLowerCase() === name.toLowerCase());
+		if (existing !== void 0) return existing;
+		const tag = {
+			id: `tag-${hash(name.toLowerCase())}`,
+			name,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		await this.commit((current) => ({
+			...current,
+			tags: {
+				...current.tags,
+				[tag.id]: tag
+			}
+		}));
+		return tag;
+	}
+	/** Rename a tag (its id, and therefore every entry that carries it, is untouched). */
+	async renameTag(request) {
+		const name = request.name.trim().slice(0, 40);
+		if (name.length === 0) return "empty";
+		if ((await this.currentDoc()).tags?.[request.id] === void 0) return "not-found";
+		await this.commit((current) => ({
+			...current,
+			tags: {
+				...current.tags,
+				[request.id]: {
+					...current.tags?.[request.id],
+					id: request.id,
+					name
+				}
+			}
+		}));
+		return "ok";
+	}
+	/** Drop a tag from the vocabulary and from every entry that carried it. */
+	async deleteTag(request) {
+		if ((await this.currentDoc()).tags?.[request.id] === void 0) return "not-found";
+		await this.commit((current) => {
+			const annotations = {};
+			for (const [entryId, entry] of Object.entries(current.annotations ?? {})) {
+				const tagIds = (entry.tagIds ?? []).filter((id) => id !== request.id);
+				annotations[entryId] = tagIds.length > 0 ? {
+					...entry,
+					tagIds
+				} : withoutTags(entry);
+			}
+			const { [request.id]: _removed, ...tags } = current.tags ?? {};
+			return {
+				...current,
+				tags,
+				annotations: cleanupAnnotations(annotations)
+			};
+		});
+		return "ok";
+	}
+	/** Add or remove one tag on one entry. */
+	async tagEntry(request) {
+		if ((await this.currentDoc()).tags?.[request.tagId] === void 0) return "not-found";
+		await this.commit((current) => {
+			const entry = current.annotations?.[request.entryId] ?? {};
+			const ids = new Set(entry.tagIds ?? []);
+			if (request.on) ids.add(request.tagId);
+			else ids.delete(request.tagId);
+			const tagIds = [...ids];
+			return {
+				...current,
+				annotations: {
+					...current.annotations,
+					[request.entryId]: tagIds.length > 0 ? {
+						...entry,
+						tagIds
+					} : withoutTags(entry)
+				}
+			};
+		});
+		return "ok";
+	}
+	/** The tags on one entry. */
+	async entryTags(request) {
+		const doc = await this.currentDoc();
+		const ids = new Set(doc.annotations?.[request.entryId]?.tagIds ?? []);
+		return { tags: Object.values(doc.tags ?? {}).filter((tag) => ids.has(tag.id)) };
+	}
+	/** How long a fetched body is served, and how large the translation store may grow. */
+	async getCachePolicy() {
+		const doc = await this.currentDoc();
+		return {
+			ttlHours: doc.cache?.ttlHours ?? DEFAULT_CACHE_POLICY.ttlHours,
+			maxEntries: doc.cache?.maxEntries ?? DEFAULT_CACHE_POLICY.maxEntries,
+			translationBudgetChars: doc.cache?.translationBudgetChars ?? 67108864
+		};
+	}
+	/** Change the cache policy (`ttlHours: 0` = keep until the budget evicts). */
+	async setCachePolicy(request) {
+		if (!Number.isFinite(request.ttlHours) || request.ttlHours < 0 || request.ttlHours > 2160) return "invalid";
+		if (request.translationBudgetChars !== void 0 && (!Number.isFinite(request.translationBudgetChars) || request.translationBudgetChars <= 0 || request.translationBudgetChars > 1073741824)) return "invalid";
+		const doc = await this.currentDoc();
+		const maxEntries = request.maxEntries ?? doc.cache?.maxEntries ?? DEFAULT_CACHE_POLICY.maxEntries;
+		const translationBudgetChars = request.translationBudgetChars ?? doc.cache?.translationBudgetChars ?? 67108864;
+		await this.commit((current) => ({
+			...current,
+			cache: {
+				ttlHours: request.ttlHours,
+				maxEntries,
+				translationBudgetChars
+			}
+		}));
+		return "ok";
+	}
+	/** Drop tags no entry references any more. */
+	async pruneTags() {
+		const doc = await this.currentDoc();
+		const used = new Set(Object.values(doc.annotations ?? {}).flatMap((entry) => entry.tagIds ?? []));
+		const kept = {};
+		let removed = 0;
+		for (const [id, tag] of Object.entries(doc.tags ?? {})) if (used.has(id)) kept[id] = tag;
+		else removed += 1;
+		if (removed > 0) await this.commit((current) => ({
+			...current,
+			tags: kept
+		}));
+		return { removed };
+	}
+	/**
+	* Record that the reader opened one entry.
+	*
+	* One row per ENTRY (not per source): the question the recent page answers is
+	* about the articles that were read, and an RSS entry has no source-level
+	* page to point at. Reopening an entry moves it to the top rather than
+	* duplicating it, and the list is capped — see `MAX_RECENT_ENTRIES`.
+	*
+	* The write is deliberately not batched: opening is a human-paced gesture,
+	* and a queue that had not flushed yet would lose the item on a restart.
+	*
+	* @param request - the entry, its source, and what to call it in the list.
+	* @returns how many entries the list holds afterwards.
+	*/
+	async recordRead(request) {
+		const entryId = request.entryId.trim();
+		const sourceId = request.sourceId.trim();
+		if (entryId.length === 0 || sourceId.length === 0) return { entries: (await this.currentDoc()).recent?.length ?? 0 };
+		const title = request.title.trim().slice(0, 300);
+		const url = request.url === void 0 || request.url.length === 0 ? void 0 : request.url;
+		const readAt = (/* @__PURE__ */ new Date()).toISOString();
+		await this.commit((current) => {
+			const kept = (current.recent ?? []).filter((item) => item.entryId !== entryId);
+			return {
+				...current,
+				recent: [{
+					entryId,
+					sourceId,
+					title,
+					...url === void 0 ? {} : { url },
+					readAt
+				}, ...kept].slice(0, 100)
+			};
+		});
+		return { entries: (await this.currentDoc()).recent?.length ?? 0 };
+	}
+	/**
+	* The entries the reader opened, newest first.
+	*
+	* @returns the recent list as the page renders it.
+	*/
+	async listRecent() {
+		return { entries: [...(await this.currentDoc()).recent ?? []] };
+	}
+	/**
+	* Forget every recent entry.
+	*
+	* The reader's own list is theirs to erase: a "recently read" page that can
+	* only grow is one nobody wants to open in company.
+	*
+	* @returns how many entries were dropped.
+	*/
+	async clearRecent() {
+		const removed = (await this.currentDoc()).recent?.length ?? 0;
+		if (removed > 0) await this.commit((current) => ({
+			...current,
+			recent: []
+		}));
+		return { removed };
+	}
+	/**
+	* Record why a fetch produced nothing, so the retry is a decision.
+	*
+	* The failure also carries its classified CODE when there is one: the wall's
+	* card button explains a red state with the same sentence the detail view
+	* uses, instead of the seam's raw words.
+	*
+	* @param entryId - the entry.
+	* @param error - the message to keep, verbatim.
+	* @param code - the classified reason, when one was derived.
+	*/
+	async recordFetchFailure(entryId, error, code) {
+		await this.commit((current) => {
+			const { fetch: _cleared, ...rest } = current.annotations?.[entryId] ?? {};
+			return {
+				...current,
+				annotations: {
+					...current.annotations,
+					[entryId]: {
+						...rest,
+						error,
+						...code === void 0 ? {} : { failureCode: code },
+						failedAt: (/* @__PURE__ */ new Date()).toISOString()
+					}
+				}
+			};
+		});
+	}
+	/**
+	* Ask the link-resolver table what a pasted URL names.
+	*
+	* Runs on the ADD path only, and never breaks it: the table's own failure
+	* (a resolver bug, an answer shape nobody planned for) reads as "no answer"
+	* and the ordinary fetch path takes over. Resolvers that need the network
+	* ride the same sanctioned seam as every fetch here; with no seam mounted
+	* their fetch throws, they answer `null`, and the ordinary path reports the
+	* missing capability — while a resolver that needs no network (OpenReview's
+	* known-unreadable verdict) still answers.
+	*/
+	async resolvePaper(url) {
+		const web = this.web();
+		const fetch = async (target) => {
+			if (web === void 0) throw new UnsupportedContent("no web capability is mounted");
+			const result = await web.fetch({ url: target });
+			return {
+				statusCode: result.statusCode,
+				body: result.body.content
+			};
+		};
+		try {
+			return await resolveLink(url, fetch);
+		} catch {
+			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");
+	}
+	/**
+	* The document of record: from disk when one is mounted, else the in-memory
+	* copy the service has been accumulating.
+	*/
+	async currentDoc() {
+		if (!this.store.available) return this.memoryDoc ?? emptyStateDoc();
+		try {
+			const { doc } = await this.store.read();
+			this.memoryDoc = doc;
+			return doc;
+		} catch (error) {
+			if (!(error instanceof ReaderStoreError)) throw error;
+			this.ctx.logger.warn(`reader: state document unusable — ${error.message}`);
+			return this.memoryDoc ?? emptyStateDoc();
+		}
+	}
+	/**
+	* Apply a mutation to the document of record.
+	*
+	* Without a filesystem the mutation lands in memory so the session still
+	* works; with one it goes through the store's version guard.
+	*
+	* @param mutate - pure function from the current document to the next.
+	*/
+	async commit(mutate) {
+		if (!this.store.available) {
+			this.memoryDoc = mutate(this.memoryDoc ?? emptyStateDoc());
+			return;
+		}
+		this.memoryDoc = await this.store.update(mutate);
+	}
+	/**
+	* Fetch a URL, following the cross-origin hops that can be reconstructed.
+	*
+	* The seam refuses a cross-origin hop and names only the target ORIGIN, so
+	* there is exactly one hop this method can follow without inventing a URL:
+	* a same-host scheme/port change, which keeps the path and query
+	* (`http://host/feed` → `https://host/feed`). A hop to a DIFFERENT host is
+	* re-thrown untouched — the caller classifies it, and the reader is told the
+	* address moves to another site rather than being served some other page
+	* under the URL they pasted.
+	*
+	* @param url - the initial URL.
+	* @returns the final URL and its decoded payload.
+	*/
+	async fetchFollowing(url) {
+		const web = this.web();
+		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 {
+			const result = await web.fetch({ url: current });
+			if (result.statusCode < 200 || result.statusCode >= 300) throw new UnsupportedContent(result.statusCode === 403 || result.statusCode === 401 ? `HTTP ${result.statusCode}: the site refuses non-browser requests, so its page cannot be read here — use the original page` : `HTTP ${result.statusCode}`);
+			return {
+				url: result.url,
+				raw: result.body.content,
+				truncated: result.truncated
+			};
+		} catch (error) {
+			const target = crossOriginRetarget(error, current);
+			if (target === void 0) throw error;
+			current = target;
+		}
+		throw new UnsupportedContent(`more than ${MAX_REDIRECT_HOPS} cross-origin redirects`);
+	}
+	/** Arm (or re-arm) the daily refresh timer against the current document. */
+	async armSchedule() {
+		if (this.disposed) return;
+		if (this.timer !== void 0) {
+			clearTimeout(this.timer);
+			this.timer = void 0;
+		}
+		const doc = await this.currentDoc();
+		if (!doc.refresh.enabled) return;
+		const now = /* @__PURE__ */ new Date();
+		const lastRun = doc.lastRefreshAt === void 0 ? void 0 : new Date(doc.lastRefreshAt);
+		const runThenRearm = () => {
+			this.refresh().then(() => this.armSchedule(), () => this.armSchedule());
+		};
+		if (isCatchUpDue(lastRun, now, doc.refresh.timeOfDay, doc.refresh.enabled)) {
+			runThenRearm();
+			return;
+		}
+		this.timer = setTimeout(runThenRearm, delayUntilNext(now, doc.refresh.timeOfDay));
+		this.timer.unref?.();
+	}
+};
+/** Parse and normalize a pasted URL; reject anything that is not http(s). */
+function normalizeUrl(input) {
+	try {
+		const url = new URL(input.trim());
+		if (url.protocol !== "http:" && url.protocol !== "https:") return void 0;
+		if (url.username.length > 0 || url.password.length > 0) return void 0;
+		return url.toString();
+	} catch {
+		return;
+	}
+}
+/** Whether two URLs point at the same target, ignoring a trailing slash. */
+function sameTarget(a, b) {
+	const strip = (value) => value.replace(/\/+$/, "");
+	return strip(a) === strip(b);
+}
+/** A captured title/excerpt, trimmed and capped; empty reads as absent. */
+function metaText(value, cap) {
+	if (value === void 0) return void 0;
+	const trimmed = value.trim();
+	return trimmed.length === 0 ? void 0 : trimmed.slice(0, cap);
+}
+/** A short stable hash, used only to build ids. */
+function hash(input) {
+	let value = 2166136261;
+	for (let index = 0; index < input.length; index++) {
+		value ^= input.charCodeAt(index);
+		value = Math.imul(value, 16777619);
+	}
+	return (value >>> 0).toString(36);
+}
+/**
+* The next URL a cross-origin refusal can be followed to — or `undefined`.
+*
+* The host seams throw a `WEB_REDIRECT_BLOCKED` error whose CODE is a property
+* and whose message names only the target origin. The original implementation
+* tested the message for the code text, which it never contains, so the whole
+* follow path was dead code and every cross-origin redirect surfaced as a raw
+* seam error. This reads the code where it actually lives.
+*
+* @param error - the value the seam threw.
+* @param current - the URL whose request was refused.
+* @returns the same path and query on the new origin, when the HOST is
+*   unchanged (a scheme or port upgrade); otherwise `undefined`.
+*/
+function crossOriginRetarget(error, current) {
+	if (errorCode(error) !== "WEB_REDIRECT_BLOCKED") return void 0;
+	const origin = /cross-origin redirect to (\S+)/i.exec(errorMessage(error))?.[1];
+	if (origin === void 0) return void 0;
+	let target;
+	let from;
+	try {
+		target = new URL(origin);
+		from = new URL(current);
+	} catch {
+		return;
+	}
+	if (target.hostname !== from.hostname) return void 0;
+	return `${target.origin}${from.pathname}${from.search}`;
+}
+/**
+* The machine-readable code a harness error carries.
+*
+* @param error - any thrown value.
+* @returns the code when it has one, else `undefined`.
+*/
+function errorCode(error) {
+	const code = error?.code;
+	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|验证码|人机验证|访问验证|安全验证/;
+/** 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. */
+const LOGIN_HOST_PATTERN = /(^|[.-])(login|sso|auth|signin|idp|cas)([.-]|$)/i;
+/**
+* Whether a fetched page can be previewed at all, and why not when it cannot.
+*
+* The host has no DOM, so this is a deliberately crude reading of the payload:
+* strip script/style/tags, count what is left, and only when that is
+* vanishingly small look for the words a wall leaves behind. A page with real
+* text is never second-guessed.
+*
+* @param raw - the decoded payload.
+* @param finalUrl - where the fetch actually landed.
+* @param requestedUrl - the URL the reader pasted.
+* @returns the reason when there is nothing to preview, else `undefined`.
+*/
+function inspectPreview(raw, finalUrl, requestedUrl) {
+	const text = visibleTextLength(raw);
+	if (text >= 200) return void 0;
+	const haystack = `${finalUrl}\n${raw.slice(0, 8e3)}`.toLowerCase();
+	const host = hostOf(finalUrl);
+	if (BOT_WALL_PATTERN.test(haystack)) return {
+		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 (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)) {
+		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/remote.js
+var __runInitializers = function(thisArg, initializers, value) {
+	var useValue = arguments.length > 2;
+	for (var i = 0; i < initializers.length; i++) value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+	return useValue ? value : void 0;
+};
+var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+	function accept(f) {
+		if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+		return f;
+	}
+	var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+	var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+	var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+	var _, done = false;
+	for (var i = decorators.length - 1; i >= 0; i--) {
+		var context = {};
+		for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+		for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+		context.addInitializer = function(f) {
+			if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+			extraInitializers.push(accept(f || null));
+		};
+		var result = (0, decorators[i])(kind === "accessor" ? {
+			get: descriptor.get,
+			set: descriptor.set
+		} : descriptor[key], context);
+		if (kind === "accessor") {
+			if (result === void 0) continue;
+			if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+			if (_ = accept(result.get)) descriptor.get = _;
+			if (_ = accept(result.set)) descriptor.set = _;
+			if (_ = accept(result.init)) initializers.unshift(_);
+		} else if (_ = accept(result)) {
+			if (kind === "field") initializers.unshift(_);
+			else descriptor[key] = _;
+		}
+	}
+	if (target) Object.defineProperty(target, contextIn.name, descriptor);
+	done = true;
+};
+/** The wire namespace is `reader`: the browser calls `remote.reader.*`. */
+let ReaderRemoteService = (() => {
+	let _classSuper = TypertRemoteService;
+	let _instanceExtraInitializers = [];
+	let _capabilities_decorators;
+	let _listSources_decorators;
+	let _addSource_decorators;
+	let _updateSource_decorators;
+	let _removeSource_decorators;
+	let _refresh_decorators;
+	let _getBodies_decorators;
+	let _getEntryBody_decorators;
+	let _fetchEntryBody_decorators;
+	let _storeEntryBody_decorators;
+	let _entryFetchStates_decorators;
+	let _getRawBody_decorators;
+	let _listBackfillCandidates_decorators;
+	let _getEntryTranslation_decorators;
+	let _getSentenceTranslations_decorators;
+	let _rememberSentences_decorators;
+	let _getStorageStats_decorators;
+	let _clearTranslations_decorators;
+	let _listTags_decorators;
+	let _createTag_decorators;
+	let _renameTag_decorators;
+	let _deleteTag_decorators;
+	let _tagEntry_decorators;
+	let _entryTags_decorators;
+	let _getCachePolicy_decorators;
+	let _setCachePolicy_decorators;
+	let _pruneTags_decorators;
+	let _recordRead_decorators;
+	let _listRecent_decorators;
+	let _clearRecent_decorators;
+	let _quoteToSideChat_decorators;
+	return class ReaderRemoteService extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_capabilities_decorators = [Remote("capabilities")];
+			_listSources_decorators = [Remote("listSources")];
+			_addSource_decorators = [Remote("addSource")];
+			_updateSource_decorators = [Remote("updateSource")];
+			_removeSource_decorators = [Remote("removeSource")];
+			_refresh_decorators = [Remote("refresh")];
+			_getBodies_decorators = [Remote("getBodies")];
+			_getEntryBody_decorators = [Remote("getEntryBody")];
+			_fetchEntryBody_decorators = [Remote("fetchEntryBody")];
+			_storeEntryBody_decorators = [Remote("storeEntryBody")];
+			_entryFetchStates_decorators = [Remote("entryFetchStates")];
+			_getRawBody_decorators = [Remote("getRawBody")];
+			_listBackfillCandidates_decorators = [Remote("listBackfillCandidates")];
+			_getEntryTranslation_decorators = [Remote("getEntryTranslation")];
+			_getSentenceTranslations_decorators = [Remote("getSentenceTranslations")];
+			_rememberSentences_decorators = [Remote("rememberSentences")];
+			_getStorageStats_decorators = [Remote("getStorageStats")];
+			_clearTranslations_decorators = [Remote("clearTranslations")];
+			_listTags_decorators = [Remote("listTags")];
+			_createTag_decorators = [Remote("createTag")];
+			_renameTag_decorators = [Remote("renameTag")];
+			_deleteTag_decorators = [Remote("deleteTag")];
+			_tagEntry_decorators = [Remote("tagEntry")];
+			_entryTags_decorators = [Remote("entryTags")];
+			_getCachePolicy_decorators = [Remote("getCachePolicy")];
+			_setCachePolicy_decorators = [Remote("setCachePolicy")];
+			_pruneTags_decorators = [Remote("pruneTags")];
+			_recordRead_decorators = [Remote("recordRead")];
+			_listRecent_decorators = [Remote("listRecent")];
+			_clearRecent_decorators = [Remote("clearRecent")];
+			_quoteToSideChat_decorators = [Remote("quoteToSideChat")];
+			__esDecorate(this, null, _capabilities_decorators, {
+				kind: "method",
+				name: "capabilities",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "capabilities" in obj,
+					get: (obj) => obj.capabilities
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _listSources_decorators, {
+				kind: "method",
+				name: "listSources",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "listSources" in obj,
+					get: (obj) => obj.listSources
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _addSource_decorators, {
+				kind: "method",
+				name: "addSource",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "addSource" in obj,
+					get: (obj) => obj.addSource
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _updateSource_decorators, {
+				kind: "method",
+				name: "updateSource",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "updateSource" in obj,
+					get: (obj) => obj.updateSource
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _removeSource_decorators, {
+				kind: "method",
+				name: "removeSource",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "removeSource" in obj,
+					get: (obj) => obj.removeSource
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _refresh_decorators, {
+				kind: "method",
+				name: "refresh",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "refresh" in obj,
+					get: (obj) => obj.refresh
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _getBodies_decorators, {
+				kind: "method",
+				name: "getBodies",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "getBodies" in obj,
+					get: (obj) => obj.getBodies
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _getEntryBody_decorators, {
+				kind: "method",
+				name: "getEntryBody",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "getEntryBody" in obj,
+					get: (obj) => obj.getEntryBody
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _fetchEntryBody_decorators, {
+				kind: "method",
+				name: "fetchEntryBody",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "fetchEntryBody" in obj,
+					get: (obj) => obj.fetchEntryBody
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _storeEntryBody_decorators, {
+				kind: "method",
+				name: "storeEntryBody",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "storeEntryBody" in obj,
+					get: (obj) => obj.storeEntryBody
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _entryFetchStates_decorators, {
+				kind: "method",
+				name: "entryFetchStates",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "entryFetchStates" in obj,
+					get: (obj) => obj.entryFetchStates
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _getRawBody_decorators, {
+				kind: "method",
+				name: "getRawBody",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "getRawBody" in obj,
+					get: (obj) => obj.getRawBody
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _listBackfillCandidates_decorators, {
+				kind: "method",
+				name: "listBackfillCandidates",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "listBackfillCandidates" in obj,
+					get: (obj) => obj.listBackfillCandidates
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _getEntryTranslation_decorators, {
+				kind: "method",
+				name: "getEntryTranslation",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "getEntryTranslation" in obj,
+					get: (obj) => obj.getEntryTranslation
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _getSentenceTranslations_decorators, {
+				kind: "method",
+				name: "getSentenceTranslations",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "getSentenceTranslations" in obj,
+					get: (obj) => obj.getSentenceTranslations
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _rememberSentences_decorators, {
+				kind: "method",
+				name: "rememberSentences",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "rememberSentences" in obj,
+					get: (obj) => obj.rememberSentences
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _getStorageStats_decorators, {
+				kind: "method",
+				name: "getStorageStats",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "getStorageStats" in obj,
+					get: (obj) => obj.getStorageStats
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _clearTranslations_decorators, {
+				kind: "method",
+				name: "clearTranslations",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "clearTranslations" in obj,
+					get: (obj) => obj.clearTranslations
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _listTags_decorators, {
+				kind: "method",
+				name: "listTags",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "listTags" in obj,
+					get: (obj) => obj.listTags
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _createTag_decorators, {
+				kind: "method",
+				name: "createTag",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "createTag" in obj,
+					get: (obj) => obj.createTag
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _renameTag_decorators, {
+				kind: "method",
+				name: "renameTag",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "renameTag" in obj,
+					get: (obj) => obj.renameTag
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _deleteTag_decorators, {
+				kind: "method",
+				name: "deleteTag",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "deleteTag" in obj,
+					get: (obj) => obj.deleteTag
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _tagEntry_decorators, {
+				kind: "method",
+				name: "tagEntry",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "tagEntry" in obj,
+					get: (obj) => obj.tagEntry
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _entryTags_decorators, {
+				kind: "method",
+				name: "entryTags",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "entryTags" in obj,
+					get: (obj) => obj.entryTags
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _getCachePolicy_decorators, {
+				kind: "method",
+				name: "getCachePolicy",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "getCachePolicy" in obj,
+					get: (obj) => obj.getCachePolicy
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _setCachePolicy_decorators, {
+				kind: "method",
+				name: "setCachePolicy",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "setCachePolicy" in obj,
+					get: (obj) => obj.setCachePolicy
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _pruneTags_decorators, {
+				kind: "method",
+				name: "pruneTags",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "pruneTags" in obj,
+					get: (obj) => obj.pruneTags
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _recordRead_decorators, {
+				kind: "method",
+				name: "recordRead",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "recordRead" in obj,
+					get: (obj) => obj.recordRead
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _listRecent_decorators, {
+				kind: "method",
+				name: "listRecent",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "listRecent" in obj,
+					get: (obj) => obj.listRecent
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _clearRecent_decorators, {
+				kind: "method",
+				name: "clearRecent",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "clearRecent" in obj,
+					get: (obj) => obj.clearRecent
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _quoteToSideChat_decorators, {
+				kind: "method",
+				name: "quoteToSideChat",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "quoteToSideChat" in obj,
+					get: (obj) => obj.quoteToSideChat
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static inject = ["reader"];
+		constructor(ctx, _config = {}) {
+			super(ctx, "readerRemote", { namespace: "reader" });
+			__runInitializers(this, _instanceExtraInitializers);
+		}
+		/** The service core this face delegates to. */
+		get core() {
+			return this.ctx.reader;
+		}
+		/** Capability handshake: what the browser may rely on in this composition. */
+		capabilities() {
+			return this.core.capabilities();
+		}
+		/** The configured sources, without payloads. */
+		async listSources() {
+			return this.core.listSources();
+		}
+		/** Add a source; the host decides whether the URL is a feed or an article. */
+		addSource(request) {
+			return this.core.addSource(request);
+		}
+		/** Change a source's label/enabled flag, or the global refresh time. */
+		updateSource(request) {
+			return this.core.updateSource(request);
+		}
+		/** Drop a source; its entries' translations go with it (their bodies stay for the budget). */
+		removeSource(request) {
+			return this.core.removeSource(request);
+		}
+		/** Fetch the named sources (or every enabled one) now. */
+		async refresh(request) {
+			return this.core.refresh(request);
+		}
+		/** Hand back raw payloads for the browser to parse. */
+		async getBodies(request) {
+			return this.core.getBodies(request);
+		}
+		/** What the detail view should render for one entry, and whether a fetch is worth offering. */
+		getEntryBody(request) {
+			return this.core.getEntryBody(request);
+		}
+		/** Fetch one entry's article (the network half; the browser extracts). */
+		fetchEntryBody(request) {
+			return this.core.fetchEntryBody(request);
+		}
+		/** Cache the markup the browser extracted for one entry. */
+		storeEntryBody(request) {
+			return this.core.storeEntryBody(request);
+		}
+		/** What the plugin holds per entry: a body, a stored raw payload, or a failure. */
+		entryFetchStates(request) {
+			return this.core.entryFetchStates(request);
+		}
+		/** A stored raw payload, so the browser can extract it later. */
+		getRawBody(request) {
+			return this.core.getRawBody(request);
+		}
+		/** Which entries still need their full text (the automatic backfill's work list). */
+		listBackfillCandidates(request) {
+			return this.core.listBackfillCandidates(request);
+		}
+		/** One entry's exact-fit translation record (segment map resolved), when usable. */
+		getEntryTranslation(request) {
+			return this.core.getEntryTranslation(request);
+		}
+		/** Translations for exactly the asked sentence hashes of one pair — never the whole table. */
+		getSentenceTranslations(request) {
+			return this.core.getSentenceTranslations(request);
+		}
+		/** Persist what one translation run learned (and refresh what it reused), in one batch. */
+		rememberSentences(request) {
+			return this.core.rememberSentences(request);
+		}
+		/** Per-tier cache usage, aggregated on the host (the tables never cross). */
+		getStorageStats() {
+			return this.core.getStorageStats();
+		}
+		/** Forget every translation: the global memory and every entry map. */
+		clearTranslations() {
+			return this.core.clearTranslations();
+		}
+		/** The tag vocabulary, with how many entries carry each tag. */
+		listTags() {
+			return this.core.listTags();
+		}
+		/** Create a tag, or return the existing one with the same name. */
+		createTag(request) {
+			return this.core.createTag(request);
+		}
+		/** Rename a tag without touching the entries that carry it. */
+		renameTag(request) {
+			return this.core.renameTag(request);
+		}
+		/** Delete a tag and remove it from every entry. */
+		deleteTag(request) {
+			return this.core.deleteTag(request);
+		}
+		/** Add or remove one tag on one entry. */
+		tagEntry(request) {
+			return this.core.tagEntry(request);
+		}
+		/** The tags on one entry. */
+		entryTags(request) {
+			return this.core.entryTags(request);
+		}
+		/** Read or set how long a fetched body is served (and the translation budget). */
+		getCachePolicy() {
+			return this.core.getCachePolicy();
+		}
+		setCachePolicy(request) {
+			return this.core.setCachePolicy(request);
+		}
+		/** Drop tags nothing references any more. */
+		pruneTags() {
+			return this.core.pruneTags();
+		}
+		/** Record that the reader opened one entry (the recent page's write half). */
+		recordRead(request) {
+			return this.core.recordRead(request);
+		}
+		/** The entries the reader opened, newest first. */
+		listRecent() {
+			return this.core.listRecent();
+		}
+		/** Forget every recent entry. */
+		clearRecent() {
+			return this.core.clearRecent();
+		}
+		/** Forward a ref block to the side-chat service when one is composed. */
+		quoteToSideChat(request) {
+			return this.core.quoteToSideChat(request);
+		}
+	};
+})();
+//#endregion
+//#region lib/types/index.js
+/** Cordis plugin name used by loader diagnostics. */
+const name = "reader";
+/**
+* Plugin body: provide the service core, then mount the Remote data face.
+*
+* No `static inject`: every optional capability (`fs`, `web`, `sideChat`) is
+* probed at the point of use, so the row boots in any composition and degrades
+* — memory-only state without `fs`, `unsupported-content` without `web`, a
+* hidden side-chat gesture without `sideChat`.
+*
+* @param ctx - owning Cordis context.
+* @param config - optional plugin config.
+*/
+function apply(ctx, config = {}) {
+	const service = new ReaderService(ctx, config);
+	ctx.provide("reader", service);
+	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 };