@deepwatch/dsh-library 0.1.0

package/lib/client.js

@@ -0,0 +1,1882 @@
+window.__ModuleLoader__.load({
+	id: "@deepwatch/dsh-library",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		let react_jsx_runtime = require("react/jsx-runtime");
+		let react = require("react");
+		//#region ../contracts/lib/presentation.js
+		/** The sentence to show when Watch Core supplied no reason of its own. */
+		const FALLBACK_REASON = {
+			VERIFIED: "Every required check passed against valid evidence.",
+			FAILED: "A required check failed.",
+			UNVERIFIED: "Nothing executable was checked, so nothing was established.",
+			INCONCLUSIVE: "The evidence conflicts, or a check could not be run.",
+			STALE: "The evidence no longer describes the current source.",
+			BLOCKED: "Policy or a missing dependency prevented verification."
+		};
+		/** Every verdict the taxonomy defines, for exhaustive validation. */
+		const VERDICTS = /* @__PURE__ */ new Set([
+			"VERIFIED",
+			"FAILED",
+			"UNVERIFIED",
+			"INCONCLUSIVE",
+			"STALE",
+			"BLOCKED"
+		]);
+		/**
+		* Parse a tool result into a verdict.
+		*
+		* Returns null rather than guessing. A result this cannot read renders as a
+		* generic row, which is honest; inventing a verdict to fill a card would not
+		* be.
+		*/
+		function parseVerdict(value) {
+			const record = asRecord(value);
+			if (record === null) return null;
+			const verdict = record["verdict"];
+			if (typeof verdict !== "string" || !VERDICTS.has(verdict)) return null;
+			const checks = Array.isArray(record["checks"]) ? record["checks"] : [];
+			const reason = record["reason"];
+			return {
+				verdict,
+				reason: typeof reason === "string" && reason !== "" ? reason : FALLBACK_REASON[verdict],
+				checks: checks.flatMap(parseCheck),
+				contractDigest: typeof record["contractDigest"] === "string" ? record["contractDigest"] : "",
+				assurance: typeof record["assurance"] === "string" ? record["assurance"] : null
+			};
+		}
+		function parseCheck(value) {
+			const record = asRecord(value);
+			if (record === null || typeof record["checkId"] !== "string") return [];
+			return [{
+				checkId: record["checkId"],
+				kind: typeof record["kind"] === "string" ? record["kind"] : "check",
+				description: typeof record["description"] === "string" ? record["description"] : null,
+				passed: typeof record["passed"] === "boolean" ? record["passed"] : null,
+				detail: typeof record["detail"] === "string" ? record["detail"] : null
+			}];
+		}
+		/** Narrow an unknown to a plain object, excluding null and arrays. */
+		function asRecord(value) {
+			if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+			return value;
+		}
+		//#endregion
+		//#region ../brand/lib/identity.js
+		/** Every status the product renders, and the tone it is permitted. */
+		const STATUS_TONE = {
+			VERIFIED: "success",
+			FAILED: "error",
+			UNVERIFIED: "caution",
+			INCONCLUSIVE: "caution",
+			STALE: "caution",
+			BLOCKED: "caution",
+			queued: "neutral",
+			running: "active",
+			completed: "info",
+			failed: "error",
+			cancelled: "neutral",
+			current: "neutral",
+			gap: "caution",
+			expired: "caution",
+			unavailable: "caution"
+		};
+		/**
+		* The tone one status is allowed.
+		*
+		* Anything unrecognized is `neutral`, never `success`. A new status added
+		* elsewhere and not registered here renders as unremarkable rather than
+		* accidentally as a win.
+		*/
+		function toneFor(status) {
+			return STATUS_TONE[status] ?? "neutral";
+		}
+		/**
+		* The semantic token a tone maps to.
+		*
+		* Feature packages ask for a tone and get a CSS variable. They never write a
+		* hex value, which is what stops the palette from being re-invented slightly
+		* differently in every panel — and what makes a theme change one edit.
+		*/
+		function tokenFor(tone) {
+			return `var(--watch-tone-${tone})`;
+		}
+		//#endregion
+		//#region ../brand/lib/mark.js
+		/**
+		* The Watch mark, inlined.
+		*
+		* Generated by `scripts/brand-assets.mjs` from `assets/watch-orca-master.png`.
+		* Do not edit by hand: the master is the brand source of truth and this is a
+		* mechanical derivation of it at 64px, which covers a 32px slot at 2x.
+		*
+		* @module @deepwatch/dsh-client-brand/mark
+		*/
+		/** The orca, as a transparent PNG data URI. */
+		const WATCH_MARK_PNG = "data:image/png;base64,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";
+		//#endregion
+		//#region ../workspace/lib/client/surface.js
+		const MODE_KICKER = {
+			Watch: "Trust layer",
+			Live: "Observation",
+			Memory: "Knowledge",
+			Library: "Evidence library",
+			Compare: "Change analysis"
+		};
+		/** Stable global class names; their rules live with the product theme. */
+		const C = {
+			root: "watch-mode-root",
+			hero: "watch-mode-hero",
+			markFrame: "watch-mode-mark-frame",
+			mark: "watch-mode-mark",
+			heroCopy: "watch-mode-hero-copy",
+			eyebrow: "watch-mode-eyebrow",
+			title: "watch-mode-title",
+			lead: "watch-mode-lead",
+			localBadge: "watch-mode-local-badge",
+			body: "watch-mode-body",
+			empty: "watch-empty",
+			emptyCopy: "watch-empty-copy",
+			sectionLabel: "watch-section-label",
+			emptyShows: "watch-empty-shows",
+			emptyWhy: "watch-empty-why",
+			nextBlock: "watch-next-block",
+			nextList: "watch-next-list",
+			panel: "watch-panel",
+			panelHeading: "watch-panel-heading",
+			facts: "watch-facts",
+			factRow: "watch-fact-row",
+			factKey: "watch-fact-key",
+			factValue: "watch-fact-value",
+			note: "watch-note",
+			noteMark: "watch-note-mark",
+			unavailable: "watch-unavailable",
+			unavailableHead: "watch-unavailable-head",
+			unavailableBadge: "watch-unavailable-badge",
+			unavailableBecause: "watch-unavailable-because",
+			requirements: "watch-requirements"
+		};
+		/** The frame: a title, one sentence of what this is, then the body. */
+		function ModeSurface({ title, lead, children }) {
+			return (0, react_jsx_runtime.jsxs)("div", {
+				className: C.root,
+				"data-watch-mode": title.toLowerCase(),
+				children: [(0, react_jsx_runtime.jsxs)("header", {
+					className: C.hero,
+					children: [
+						(0, react_jsx_runtime.jsx)("span", {
+							className: C.markFrame,
+							"aria-hidden": "true",
+							children: (0, react_jsx_runtime.jsx)("img", {
+								className: C.mark,
+								src: WATCH_MARK_PNG,
+								alt: ""
+							})
+						}),
+						(0, react_jsx_runtime.jsxs)("div", {
+							className: C.heroCopy,
+							children: [
+								(0, react_jsx_runtime.jsx)("span", {
+									className: C.eyebrow,
+									children: `DEEPWATCH / ${MODE_KICKER[title] ?? "Evidence workspace"}`
+								}),
+								(0, react_jsx_runtime.jsx)("h2", {
+									className: C.title,
+									children: title
+								}),
+								(0, react_jsx_runtime.jsx)("p", {
+									className: C.lead,
+									children: lead
+								})
+							]
+						}),
+						(0, react_jsx_runtime.jsx)("span", {
+							className: C.localBadge,
+							children: "Local-first"
+						})
+					]
+				}), (0, react_jsx_runtime.jsx)("div", {
+					className: C.body,
+					children
+				})]
+			});
+		}
+		/** A titled block of content. */
+		function Panel({ heading, children }) {
+			return (0, react_jsx_runtime.jsxs)("section", {
+				className: C.panel,
+				"data-watch-panel": "",
+				children: [heading === void 0 ? null : (0, react_jsx_runtime.jsx)("h3", {
+					className: C.panelHeading,
+					children: heading
+				}), children]
+			});
+		}
+		/** A key/value grid. Long values wrap rather than forcing the page sideways. */
+		function Facts({ rows }) {
+			return (0, react_jsx_runtime.jsx)("dl", {
+				className: C.facts,
+				children: rows.map(([label, value]) => (0, react_jsx_runtime.jsxs)("div", {
+					className: C.factRow,
+					children: [(0, react_jsx_runtime.jsx)("dt", {
+						className: C.factKey,
+						children: label
+					}), (0, react_jsx_runtime.jsx)("dd", {
+						className: C.factValue,
+						children: value
+					})]
+				}, label))
+			});
+		}
+		/**
+		* Read the JSON a Watch tool returned out of whatever DSH handed us.
+		*
+		* Returns null on anything unexpected — a running call, a failed one, a result
+		* that is not JSON, a shape we do not recognise. The caller then renders its
+		* empty state, which is the honest outcome: a surface that cannot read its
+		* input must not draw a card implying it did.
+		*/
+		function readToolResult(value) {
+			if (typeof value !== "object" || value === null) return null;
+			const block = value;
+			if (!("kind" in block) || block.isError === true) return null;
+			if (!Array.isArray(block.content)) return null;
+			const text = block.content.filter((part) => typeof part === "object" && part !== null && part.type === "text" && typeof part.text === "string").map((part) => part.text).join("");
+			if (text === "") return null;
+			try {
+				return JSON.parse(text);
+			} catch {
+				return null;
+			}
+		}
+		/** The largest page anyone may ask for. */
+		const MAX_LIMIT = 200;
+		const DEFAULT_LIMIT = 25;
+		/** Han, Hiragana, Katakana — scripts written without spaces. */
+		const CJK = /[぀-ヿ㐀-䶿一-鿿]/u;
+		/**
+		* Split text into searchable tokens.
+		*
+		* Unicode-aware on purpose. Splitting on `[a-z0-9]+` would silently drop every
+		* Arabic, Chinese, Cyrillic and Greek record in the corpus — they would index
+		* as nothing and return nothing, and the failure would look like an empty
+		* library rather than a broken tokenizer.
+		*
+		* CJK has no spaces, so a run is emitted as its characters and its adjacent
+		* bigrams rather than whole. Keeping the run would make it a token only an
+		* exact repetition could match, and since every query term must be present,
+		* that run token would then fail a query whose characters are all indexed.
+		*
+		* Case folding is `toLowerCase`, which is a no-op for scripts without case and
+		* correct for those with it. Diacritics are deliberately *kept*: the original
+		* text is the evidence, and folding "عَلَم" into "علم" would make a citation
+		* resolve to something the source does not say.
+		*
+		* `\p{M}` is in the continuation class for the same reason, and its absence was
+		* a real bug. Arabic harakat are Unicode *Mark*, not *Letter*, so a class of
+		* letters and numbers alone breaks at every vowel sign: vocalised "عَلَم"
+		* tokenized as three separate consonants, and no query could ever match it.
+		*/
+		function tokenize(text) {
+			if (text === "") return [];
+			const tokens = [];
+			for (const match of text.toLowerCase().matchAll(/[\p{L}\p{N}][\p{L}\p{N}\p{M}_'-]*/gu)) {
+				const token = match[0];
+				if (CJK.test(token) && token.length > 1) {
+					for (const character of token) tokens.push(character);
+					for (let at = 0; at + 1 < token.length; at += 1) tokens.push(token.slice(at, at + 2));
+					continue;
+				}
+				tokens.push(token);
+			}
+			return tokens;
+		}
+		/** A stable digest over the index's own contents, for corruption detection. */
+		function digestOf(documents, postings) {
+			let hash = 2166136261;
+			const parts = [...documents.map((document) => `${document.recordId}@${document.revisionId}`).sort(), ...[...postings.keys()].sort().map((token) => `${token}:${String(postings.get(token)?.size ?? 0)}`)];
+			for (const part of parts) for (let index = 0; index < part.length; index += 1) {
+				hash ^= part.charCodeAt(index);
+				hash = Math.imul(hash, 16777619) >>> 0;
+			}
+			return hash.toString(16).padStart(8, "0");
+		}
+		/** The local, derived, rebuildable search index. */
+		var LibraryIndex = class LibraryIndex {
+			#documents = /* @__PURE__ */ new Map();
+			#postings = /* @__PURE__ */ new Map();
+			#health = "empty";
+			#builtAt = null;
+			#pending = /* @__PURE__ */ new Set();
+			#notes = [];
+			get health() {
+				return this.#health;
+			}
+			/**
+			* One record by id, or undefined.
+			*
+			* A direct lookup rather than a search. The read plane's `get` was briefly
+			* implemented as a search with `limit: 1` whose single result was then
+			* compared to the requested id, which reports every record except the
+			* first-ranked one as missing. `#documents` is already keyed by record id;
+			* this is the accessor that key exists for.
+			*/
+			record(recordId) {
+				return this.#documents.get(recordId);
+			}
+			get size() {
+				return this.#documents.size;
+			}
+			/** Ids indexing began but did not finish, so a resumed run knows where it was. */
+			get pending() {
+				return [...this.#pending];
+			}
+			get diagnostics() {
+				return [...this.#notes];
+			}
+			/**
+			* Add or replace one record.
+			*
+			* Idempotent by construction: the record's existing postings are removed
+			* before the new ones are written, so re-indexing changed text cannot leave
+			* the old words behind still pointing at the document. Indexing identical
+			* content twice is a no-op, which is what makes an interrupted run safe to
+			* simply repeat.
+			*/
+			add(input) {
+				const record = normalizeRecord(input);
+				if (record.recordId === "") return;
+				this.#pending.add(record.recordId);
+				this.#removePostings(record.recordId);
+				this.#documents.set(record.recordId, record);
+				const haystack = [
+					record.title,
+					record.text,
+					record.source ?? "",
+					record.runId ?? "",
+					record.verdict ?? "",
+					...record.tags
+				].join(" ");
+				for (const token of tokenize(haystack)) {
+					let postings = this.#postings.get(token);
+					if (postings === void 0) {
+						postings = /* @__PURE__ */ new Set();
+						this.#postings.set(token, postings);
+					}
+					postings.add(record.recordId);
+				}
+				this.#pending.delete(record.recordId);
+				this.#health = this.#documents.size === 0 ? "empty" : "ready";
+				this.#builtAt = (/* @__PURE__ */ new Date()).toISOString();
+			}
+			/** Index many, reporting progress so an interrupted run can resume. */
+			addAll(records, signal) {
+				this.#health = "indexing";
+				let done = 0;
+				for (const record of records) {
+					if (signal?.aborted ?? false) {
+						this.#health = this.#documents.size === 0 ? "empty" : "stale";
+						this.#notes.push(`indexing cancelled after ${String(done)} of ${String(records.length)}`);
+						return done;
+					}
+					this.add(record);
+					done += 1;
+				}
+				this.#health = this.#documents.size === 0 ? "empty" : "ready";
+				return done;
+			}
+			/**
+			* Forget a record entirely.
+			*
+			* A deleted record must not survive as a search hit. Removing the document
+			* without its postings would leave a token pointing at an id that no longer
+			* resolves — a result that cannot be opened, which is worse than no result.
+			*/
+			remove(recordId) {
+				if (!this.#documents.has(recordId)) return false;
+				this.#removePostings(recordId);
+				this.#documents.delete(recordId);
+				this.#pending.delete(recordId);
+				if (this.#documents.size === 0) this.#health = "empty";
+				return true;
+			}
+			/** Throw everything away. The point of a derived index. */
+			clear() {
+				this.#documents.clear();
+				this.#postings.clear();
+				this.#pending.clear();
+				this.#notes = [];
+				this.#health = "empty";
+				this.#builtAt = null;
+			}
+			/** Mark the index as behind the store, without discarding what it has. */
+			markStale(reason) {
+				if (this.#health === "ready") this.#health = "stale";
+				this.#notes.push(reason);
+			}
+			#removePostings(recordId) {
+				for (const [token, ids] of this.#postings) if (ids.delete(recordId) && ids.size === 0) this.#postings.delete(token);
+			}
+			/**
+			* Search.
+			*
+			* Every term must be present — an AND over tokens. OR would return a page of
+			* documents sharing one common word, which reads as the search being broken.
+			*
+			* The query string is never interpreted: it is tokenized exactly like indexed
+			* text, so a regular expression, a glob, a SQL fragment or a path traversal
+			* in the box is simply a set of words that will not be found. There is no
+			* escaping to get wrong because there is nothing to escape into.
+			*/
+			search(query) {
+				const notes = [];
+				const limit = Math.min(Math.max(1, query.limit ?? DEFAULT_LIMIT), 200);
+				const offset = Math.max(0, query.offset ?? 0);
+				const cancelled = () => query.signal?.aborted ?? false;
+				if (this.#health === "corrupt") return {
+					results: [],
+					total: 0,
+					offset,
+					limit,
+					health: "corrupt",
+					notes: ["The index is unreadable and must be rebuilt.", ...this.#notes]
+				};
+				if (cancelled()) return {
+					results: [],
+					total: 0,
+					offset,
+					limit,
+					health: this.#health,
+					notes: ["Search cancelled."]
+				};
+				const terms = tokenize(query.text);
+				let candidates;
+				if (terms.length === 0) {
+					candidates = new Set(this.#documents.keys());
+					notes.push("No search terms: showing everything the filters allow.");
+				} else candidates = this.#intersect(terms);
+				const matched = [];
+				for (const recordId of candidates) {
+					if (cancelled()) return {
+						results: [],
+						total: 0,
+						offset,
+						limit,
+						health: this.#health,
+						notes: ["Search cancelled."]
+					};
+					const record = this.#documents.get(recordId);
+					if (record === void 0) continue;
+					if (!passesFilters(record, query)) continue;
+					matched.push({
+						record,
+						score: scoreOf(record, terms)
+					});
+				}
+				sortMatches(matched, query.sort ?? "relevance");
+				const total = matched.length;
+				const page = matched.slice(offset, offset + limit);
+				if (total > offset + page.length) notes.push(`Showing ${String(offset + 1)}–${String(offset + page.length)} of ${String(total)}.`);
+				if (this.#health === "stale") notes.push("The index is behind the store; some recent records may be missing.");
+				if (this.#health === "indexing") notes.push("Indexing is still running; this answer is partial.");
+				return {
+					results: page.map(({ record, score }) => toResult(record, terms, score)),
+					total,
+					offset,
+					limit,
+					health: this.#health,
+					notes
+				};
+			}
+			#intersect(terms) {
+				let smallest = null;
+				for (const term of terms) {
+					const postings = this.#postings.get(term);
+					if (postings === void 0) return /* @__PURE__ */ new Set();
+					if (smallest === null || postings.size < smallest.size) smallest = postings;
+				}
+				if (smallest === null) return /* @__PURE__ */ new Set();
+				const out = /* @__PURE__ */ new Set();
+				for (const candidate of smallest) if (terms.every((term) => this.#postings.get(term)?.has(candidate) === true)) out.add(candidate);
+				return out;
+			}
+			/** Serialise, with a digest so a later load can tell it was not damaged. */
+			serialize() {
+				const documents = [...this.#documents.values()];
+				return {
+					version: 1,
+					digest: digestOf(documents, this.#postings),
+					builtAt: this.#builtAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+					documents,
+					postings: Object.fromEntries([...this.#postings.entries()].map(([token, ids]) => [token, [...ids].sort()]))
+				};
+			}
+			/**
+			* Load a serialised index, refusing anything it cannot trust.
+			*
+			* A wrong version, a failed digest or a malformed body all produce a
+			* `corrupt` index rather than a partial one. Half-loading is the failure that
+			* looks like success: queries answer, and they answer wrongly.
+			*/
+			static load(value) {
+				const index = new LibraryIndex();
+				const fail = (reason) => {
+					index.#health = "corrupt";
+					index.#notes.push(reason);
+					return index;
+				};
+				if (typeof value !== "object" || value === null) return fail("The stored index is not an object.");
+				const stored = value;
+				if (stored.version !== 1) return fail(`Index version ${String(stored.version)} cannot be read by this build (expects ${String(1)}).`);
+				if (!Array.isArray(stored.documents) || typeof stored.postings !== "object" || stored.postings === null) return fail("The stored index is missing its documents or postings.");
+				const documents = [];
+				for (const document of stored.documents) {
+					if (typeof document !== "object" || document === null) return fail("A stored document is malformed.");
+					const record = document;
+					if (typeof record.recordId !== "string" || record.recordId === "") return fail("A stored document has no id.");
+					documents.push(normalizeRecord(record));
+				}
+				const postings = /* @__PURE__ */ new Map();
+				for (const [token, ids] of Object.entries(stored.postings)) {
+					if (!Array.isArray(ids)) return fail(`Postings for "${token}" are malformed.`);
+					postings.set(token, new Set(ids.filter((id) => typeof id === "string")));
+				}
+				if (digestOf(documents, postings) !== stored.digest) return fail("The stored index failed its own digest — it has been modified or truncated.");
+				for (const document of documents) index.#documents.set(document.recordId, document);
+				index.#postings = postings;
+				index.#builtAt = typeof stored.builtAt === "string" ? stored.builtAt : null;
+				index.#health = documents.length === 0 ? "empty" : "ready";
+				return index;
+			}
+		};
+		/** Fill in what a stored record may be missing, without inventing content. */
+		function normalizeRecord(record) {
+			return {
+				recordId: record.recordId ?? "",
+				revisionId: typeof record.revisionId === "string" ? record.revisionId : "",
+				title: typeof record.title === "string" ? record.title : "",
+				kind: record.kind ?? "document",
+				text: typeof record.text === "string" ? record.text : "",
+				source: typeof record.source === "string" ? record.source : null,
+				runId: typeof record.runId === "string" ? record.runId : null,
+				observedAt: typeof record.observedAt === "string" ? record.observedAt : null,
+				verdict: typeof record.verdict === "string" ? record.verdict : null,
+				tags: Array.isArray(record.tags) ? record.tags.filter((tag) => typeof tag === "string") : [],
+				evidenceIds: Array.isArray(record.evidenceIds) ? record.evidenceIds.filter((id) => typeof id === "string") : []
+			};
+		}
+		function passesFilters(record, query) {
+			if (query.kinds !== void 0 && query.kinds.length > 0 && !query.kinds.includes(record.kind)) return false;
+			if (query.runIds !== void 0 && query.runIds.length > 0) {
+				if (record.runId === null || !query.runIds.includes(record.runId)) return false;
+			}
+			if (query.verdicts !== void 0 && query.verdicts.length > 0) {
+				if (record.verdict === null || !query.verdicts.includes(record.verdict)) return false;
+			}
+			if (query.sources !== void 0 && query.sources.length > 0) {
+				if (record.source === null || !query.sources.includes(record.source)) return false;
+			}
+			if (query.tags !== void 0 && query.tags.length > 0) {
+				if (!query.tags.some((tag) => record.tags.includes(tag))) return false;
+			}
+			if (query.from !== void 0 && (record.observedAt === null || record.observedAt < query.from)) return false;
+			if (query.to !== void 0 && (record.observedAt === null || record.observedAt > query.to)) return false;
+			return true;
+		}
+		/**
+		* Score a match.
+		*
+		* Term frequency with a title bonus, and nothing more. A more elaborate
+		* relevance model would be guessing, and this one is at least explicable: a
+		* record whose title contains your words outranks one that merely mentions
+		* them, and more mentions outrank fewer.
+		*/
+		function scoreOf(record, terms) {
+			if (terms.length === 0) return 0;
+			const title = new Set(tokenize(record.title));
+			const body = tokenize(record.text);
+			let score = 0;
+			for (const term of terms) {
+				if (title.has(term)) score += 5;
+				score += body.filter((token) => token === term).length;
+			}
+			return score;
+		}
+		function sortMatches(matched, sort) {
+			const time = (record) => record.observedAt ?? "";
+			matched.sort((left, right) => {
+				if (sort === "newest") return time(right.record).localeCompare(time(left.record));
+				if (sort === "oldest") return time(left.record).localeCompare(time(right.record));
+				if (sort === "title") return left.record.title.localeCompare(right.record.title);
+				const byScore = right.score - left.score;
+				return byScore !== 0 ? byScore : left.record.recordId.localeCompare(right.record.recordId);
+			});
+		}
+		/**
+		* Build the snippet a person reads, around the first match.
+		*
+		* The text is returned verbatim and un-escaped — it is evidence, and altering
+		* it here would make the snippet disagree with the source. Rendering is the
+		* caller's job, and React escapes by default; this deliberately produces no
+		* markup for a renderer to trust.
+		*/
+		function snippetFor(text, terms, radius = 90) {
+			if (text === "" || terms.length === 0) return text.slice(0, radius * 2);
+			const lower = text.toLowerCase();
+			let at = -1;
+			for (const term of terms) {
+				const found = lower.indexOf(term);
+				if (found >= 0 && (at < 0 || found < at)) at = found;
+			}
+			if (at < 0) return text.slice(0, radius * 2);
+			const start = Math.max(0, at - radius);
+			const end = Math.min(text.length, at + radius);
+			return (start > 0 ? "…" : "") + text.slice(start, end) + (end < text.length ? "…" : "");
+		}
+		function toResult(record, terms, score) {
+			const hit = {
+				sourceId: record.recordId,
+				sourceRevisionId: record.revisionId,
+				range: null,
+				text: snippetFor(record.text === "" ? record.title : record.text, terms),
+				path: "lexical",
+				score,
+				evidenceIds: record.evidenceIds
+			};
+			return {
+				sourceId: record.recordId,
+				title: record.title,
+				kind: record.kind,
+				hits: [hit],
+				current: true
+			};
+		}
+		//#endregion
+		//#region src/client/read-plane.ts
+		/**
+		* Correlation ids, from a counter rather than from randomness.
+		*
+		* The host refuses a `requestId` that is not an identifier, and a counter
+		* produces one by construction. It is also what makes a failing request
+		* quotable: `library-7` names a call somebody can find twice.
+		*/
+		let sequence = 0;
+		/** The next correlation id for a Library read. */
+		function nextRequestId() {
+			sequence += 1;
+			return `library-${String(sequence)}`;
+		}
+		/** An answer that produced no rows, and says why. */
+		function nothing(note, health = "stale") {
+			return {
+				rows: [],
+				total: 0,
+				health,
+				generation: 0,
+				notes: [note],
+				pageable: false
+			};
+		}
+		/** The host's own vocabulary for index condition, in the surface's terms. */
+		function healthOf(state) {
+			return state === "rebuilding" ? "indexing" : state;
+		}
+		/** One wire record as a row. */
+		function rowOf(record) {
+			return {
+				key: `${record.recordId}@${record.revisionId}`,
+				recordId: record.recordId,
+				title: record.title,
+				kind: record.modality,
+				snippets: [],
+				evidenceCount: record.evidenceIds.length,
+				current: record.current
+			};
+		}
+		/**
+		* Ask the host, and turn whatever comes back into something renderable.
+		*
+		* Every outcome is an answer the surface shows rather than an exception it
+		* swallows. A refusal, an elapsed deadline and an expired cursor are different
+		* facts, and a person acts differently on each, so each keeps its own sentence.
+		*/
+		async function readLibraryPage(reads, query, signal) {
+			const answer = await reads.librarySearch({
+				protocol: 1,
+				requestId: nextRequestId(),
+				query: query.text,
+				modalities: query.modality === "" ? [] : [query.modality],
+				limit: query.limit,
+				cursor: null,
+				deadlineMs: query.deadlineMs
+			}, signal);
+			if (!answer.ok) return nothing(`The Library host did not answer: ${answer.error.message}`, "corrupt");
+			const value = answer.value;
+			switch (value.outcome) {
+				case "page": {
+					const notes = value.records.length < value.total ? [`Showing ${String(value.records.length)} of ${String(value.total)} matches; the host answered with one page and offered no cursor.`] : [];
+					return {
+						rows: value.records.map(rowOf),
+						total: value.total,
+						health: healthOf(value.indexState),
+						generation: value.generation,
+						notes,
+						pageable: value.nextCursor !== null
+					};
+				}
+				case "rejected": return nothing(`The host refused the request (${value.reason}${value.field === null ? "" : ` at ${value.field}`}).`);
+				case "deadline_exceeded": return nothing(`The host did not answer within ${String(value.deadlineMs)}ms. Try a narrower query.`);
+				case "cursor_expired": return nothing("That page is no longer held by the host. Search again.");
+			}
+		}
+		/** A local index answer as the same view model, so the surface renders one shape. */
+		function fromIndex(result) {
+			return {
+				rows: result.results.map((entry) => ({
+					key: entry.sourceId,
+					recordId: entry.sourceId,
+					title: entry.title,
+					kind: entry.kind,
+					snippets: entry.hits.map((hit) => hit.text),
+					evidenceCount: entry.hits[0]?.evidenceIds.length ?? 0,
+					current: entry.current
+				})),
+				total: result.total,
+				health: result.health,
+				generation: 0,
+				notes: result.notes,
+				pageable: true
+			};
+		}
+		/**
+		* Ask the host to read its roots again.
+		*
+		* Every outcome is rendered, and none of them is an exception. A refusal, an
+		* elapsed deadline, an abandoned rebuild and a failed one are four different
+		* facts; so is a rebuild that succeeded and found nothing new. Reporting any
+		* of them as "refreshed" would be a control that lies about what it did.
+		*/
+		async function refreshLibrary(reads, deadlineMs, signal) {
+			const answer = await reads.libraryRefresh({
+				protocol: 1,
+				requestId: nextRequestId(),
+				deadlineMs
+			}, signal);
+			if (!answer.ok) return failedRefresh(`The Library host did not answer: ${answer.error.message}`);
+			const value = answer.value;
+			switch (value.outcome) {
+				case "refreshed": return {
+					refreshed: true,
+					generation: value.index.generation,
+					recordCount: value.index.recordCount,
+					note: value.skipped.length === 0 ? "" : `${String(value.skipped.length)} file(s) were not readable: ` + value.skipped.slice(0, 3).join("; "),
+					failed: false
+				};
+				case "refresh_cancelled": return {
+					refreshed: false,
+					generation: value.index.generation,
+					recordCount: value.index.recordCount,
+					note: "The refresh was abandoned. The Library is unchanged.",
+					failed: false
+				};
+				case "refresh_failed": return {
+					refreshed: false,
+					generation: value.index.generation,
+					recordCount: value.index.recordCount,
+					note: `The refresh failed: ${value.reason}. The previous index is still searchable.`,
+					failed: true
+				};
+				case "rejected": return failedRefresh(`The host refused the refresh (${value.reason}).`);
+				case "deadline_exceeded": return failedRefresh(`The refresh did not finish within ${String(value.deadlineMs)}ms. It may still be running on the host.`);
+			}
+		}
+		/** A refresh that produced no generation, and why. */
+		function failedRefresh(note) {
+			return {
+				refreshed: false,
+				generation: 0,
+				recordCount: 0,
+				note,
+				failed: true
+			};
+		}
+		//#endregion
+		//#region src/client/search-view.tsx
+		const PAGE = 10;
+		/**
+		* How long the surface will wait for the host before it must show something.
+		*
+		* Shorter than the host's own ceiling on purpose: the host clamps to 30s, and a
+		* search box that can appear frozen for half a minute is a search box people
+		* stop trusting. The host is told this number, so an answer it cannot produce
+		* in time comes back as `deadline_exceeded` — a sentence on the screen — rather
+		* than as a request nobody ever cancelled.
+		*/
+		const DEADLINE_MS = 1e4;
+		/**
+		* How long the surface will wait for a rebuild.
+		*
+		* Longer than a search, because it is one: reading a corpus is work a person
+		* has asked for and expects to take a moment. Still bounded, and still the
+		* number the host is told, so an overrun comes back as an answer rather than
+		* as a control that never settles.
+		*/
+		const REFRESH_DEADLINE_MS = 6e4;
+		const S = {
+			root: {
+				display: "flex",
+				flexDirection: "column",
+				gap: "14px",
+				height: "100%",
+				minHeight: 0
+			},
+			bar: {
+				display: "flex",
+				gap: "10px",
+				flexWrap: "wrap",
+				alignItems: "flex-end"
+			},
+			field: {
+				display: "flex",
+				flexDirection: "column",
+				gap: "4px",
+				flex: "1 1 260px",
+				minWidth: 0
+			},
+			label: {
+				fontSize: "11px",
+				fontWeight: 600,
+				letterSpacing: ".05em",
+				textTransform: "uppercase",
+				color: "var(--dsw-alias-label-tertiary)"
+			},
+			input: {
+				background: "var(--dsw-alias-bg-layer-2)",
+				border: "1px solid color-mix(in srgb, var(--watch-accent) 12%, var(--dsw-alias-border-l2))",
+				borderRadius: "10px",
+				padding: "9px 11px",
+				fontSize: "13px",
+				color: "inherit",
+				font: "inherit",
+				minWidth: 0,
+				width: "100%"
+			},
+			select: {
+				background: "var(--dsw-alias-bg-layer-2)",
+				border: "1px solid color-mix(in srgb, var(--watch-accent) 12%, var(--dsw-alias-border-l2))",
+				borderRadius: "10px",
+				padding: "9px 11px",
+				fontSize: "13px",
+				color: "inherit"
+			},
+			button: {
+				background: "transparent",
+				border: "1px solid var(--dsw-alias-border-l2)",
+				borderRadius: "10px",
+				padding: "9px 13px",
+				fontSize: "13px",
+				color: "inherit",
+				cursor: "pointer"
+			},
+			status: {
+				fontSize: "12px",
+				color: "var(--dsw-alias-label-tertiary)",
+				margin: 0
+			},
+			list: {
+				display: "flex",
+				flexDirection: "column",
+				gap: "8px",
+				margin: 0,
+				padding: 0,
+				listStyle: "none"
+			},
+			hit: {
+				border: "1px solid color-mix(in srgb, var(--watch-accent) 9%, var(--dsw-alias-border-l2))",
+				borderRadius: "14px",
+				padding: "14px 16px",
+				background: "linear-gradient(145deg, color-mix(in srgb, var(--watch-accent) 3%, var(--dsw-alias-bg-layer-2)), var(--dsw-alias-bg-base))",
+				boxShadow: "0 8px 24px color-mix(in srgb, black 7%, transparent)"
+			},
+			title: {
+				fontSize: "13.5px",
+				fontWeight: 600,
+				margin: 0
+			},
+			snippet: {
+				fontSize: "12.5px",
+				lineHeight: 1.6,
+				margin: "6px 0 0",
+				color: "var(--dsw-alias-label-secondary)",
+				wordBreak: "break-word"
+			},
+			meta: {
+				fontSize: "11.5px",
+				color: "var(--dsw-alias-label-tertiary)",
+				marginTop: "6px",
+				display: "flex",
+				gap: "10px",
+				flexWrap: "wrap"
+			}
+		};
+		/** What the index says about itself, in words a person can act on. */
+		const HEALTH = {
+			empty: {
+				says: "Nothing indexed yet.",
+				tone: "var(--watch-tone-neutral)"
+			},
+			ready: {
+				says: "Index ready.",
+				tone: "var(--watch-tone-active)"
+			},
+			indexing: {
+				says: "Indexing — results are partial.",
+				tone: "var(--watch-tone-caution)"
+			},
+			stale: {
+				says: "Index is behind the store.",
+				tone: "var(--watch-tone-caution)"
+			},
+			corrupt: {
+				says: "Index unreadable. Rebuild required.",
+				tone: "var(--watch-tone-error)"
+			}
+		};
+		const KINDS = [
+			"video",
+			"audio",
+			"page",
+			"stream",
+			"document",
+			"screen_capture"
+		];
+		/**
+		* Highlight matches without building markup.
+		*
+		* The snippet is evidence, so it is never altered and never handed to a
+		* renderer as HTML. Splitting into plain segments and marking them with React
+		* elements keeps escaping the renderer's job, which is the only place it is
+		* reliably done.
+		*/
+		function Highlighted({ text, terms }) {
+			if (terms.length === 0 || text === "") return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: text });
+			const pattern = terms.map((term) => term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).filter((term) => term !== "").join("|");
+			if (pattern === "") return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: text });
+			const parts = text.split(new RegExp(`(${pattern})`, "giu"));
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: parts.map((part, index) => terms.includes(part.toLowerCase()) ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("mark", {
+				style: {
+					background: "var(--watch-wash-active)",
+					color: "inherit"
+				},
+				children: part
+			}, `${part}-${String(index)}`) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: part }, `${part}-${String(index)}`)) });
+		}
+		/** The Library search workflow: query, filter, sort, page, rebuild. */
+		function LibrarySearch({ records = [], index: injected, reads }) {
+			const queryId = (0, react.useId)();
+			const kindId = (0, react.useId)();
+			const verdictId = (0, react.useId)();
+			const sortId = (0, react.useId)();
+			const [text, setText] = (0, react.useState)("");
+			const [kind, setKind] = (0, react.useState)("");
+			const [verdict, setVerdict] = (0, react.useState)("");
+			const [sort, setSort] = (0, react.useState)("relevance");
+			const [offset, setOffset] = (0, react.useState)(0);
+			const [generation, setGeneration] = (0, react.useState)(0);
+			const [state, setState] = (0, react.useState)(null);
+			const [refreshing, setRefreshing] = (0, react.useState)(false);
+			const [refreshed, setRefreshed] = (0, react.useState)(null);
+			const index = (0, react.useMemo)(() => {
+				if (injected !== void 0) return injected;
+				const built = new LibraryIndex();
+				built.addAll(records);
+				return built;
+			}, [
+				injected,
+				records,
+				generation
+			]);
+			const inFlight = (0, react.useRef)(null);
+			const run = (0, react.useCallback)((nextOffset) => {
+				inFlight.current?.abort();
+				const controller = new AbortController();
+				inFlight.current = controller;
+				setOffset(nextOffset);
+				if (reads === void 0) {
+					setState(fromIndex(index.search({
+						text,
+						...kind === "" ? {} : { kinds: [kind] },
+						...verdict === "" ? {} : { verdicts: [verdict] },
+						sort,
+						offset: nextOffset,
+						limit: PAGE,
+						signal: controller.signal
+					})));
+					return;
+				}
+				readLibraryPage(reads, {
+					text,
+					modality: kind,
+					limit: PAGE,
+					deadlineMs: DEADLINE_MS
+				}, controller.signal).then((next) => {
+					if (!controller.signal.aborted) setState(next);
+				});
+			}, [
+				reads,
+				index,
+				text,
+				kind,
+				verdict,
+				sort
+			]);
+			(0, react.useEffect)(() => {
+				run(0);
+			}, [run]);
+			(0, react.useEffect)(() => () => {
+				inFlight.current?.abort();
+			}, []);
+			/**
+			* Ask the host to read its roots again, then search the result.
+			*
+			* Two steps rather than one, and deliberately in that order: the refresh
+			* reports what the host now holds, and the search that follows is what puts
+			* it on the screen. Collapsing them would leave the count and the rows
+			* describing two different generations.
+			*/
+			const refresh = (0, react.useCallback)(() => {
+				if (reads === void 0) {
+					setGeneration((value) => value + 1);
+					return;
+				}
+				if (refreshing) return;
+				setRefreshing(true);
+				setRefreshed(null);
+				const controller = new AbortController();
+				refreshLibrary(reads, REFRESH_DEADLINE_MS, controller.signal).then((next) => {
+					setRefreshed(next);
+					setRefreshing(false);
+					if (next.refreshed) setGeneration((value) => value + 1);
+				});
+			}, [reads, refreshing]);
+			const terms = (0, react.useMemo)(() => tokenize(text), [text]);
+			const health = HEALTH[state?.health ?? (reads === void 0 ? index.health : "empty")] ?? {
+				says: "Index state unknown.",
+				tone: "var(--watch-tone-neutral)"
+			};
+			const rows = state?.rows ?? [];
+			const total = state?.total ?? 0;
+			const shown = rows.length;
+			const page = Math.floor(offset / PAGE) + 1;
+			const pages = state?.pageable === true ? Math.max(1, Math.ceil(total / PAGE)) : 1;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: S.root,
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("form", {
+						style: S.bar,
+						role: "search",
+						onSubmit: (event) => {
+							event.preventDefault();
+							run(0);
+						},
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+								style: S.field,
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", {
+									htmlFor: queryId,
+									style: S.label,
+									children: "Search evidence"
+								}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+									id: queryId,
+									style: S.input,
+									type: "search",
+									value: text,
+									placeholder: "Words in a transcript, a title, a run…",
+									onChange: (event) => {
+										setText(event.target.value);
+									}
+								})]
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+								style: S.field,
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", {
+									htmlFor: kindId,
+									style: S.label,
+									children: "Type"
+								}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("select", {
+									id: kindId,
+									style: S.select,
+									value: kind,
+									onChange: (event) => {
+										setKind(event.target.value);
+									},
+									children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+										value: "",
+										children: "Any type"
+									}), KINDS.map((value) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+										value,
+										children: value.replace("_", " ")
+									}, value))]
+								})]
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+								style: S.field,
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", {
+									htmlFor: verdictId,
+									style: S.label,
+									children: "Verification"
+								}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("select", {
+									id: verdictId,
+									style: S.select,
+									value: verdict,
+									disabled: reads !== void 0,
+									onChange: (event) => {
+										setVerdict(event.target.value);
+									},
+									children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+										value: "",
+										children: "Any state"
+									}), [
+										"VERIFIED",
+										"FAILED",
+										"UNVERIFIED",
+										"INCONCLUSIVE"
+									].map((value) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+										value,
+										children: value
+									}, value))]
+								})]
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+								style: S.field,
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", {
+									htmlFor: sortId,
+									style: S.label,
+									children: "Sort"
+								}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("select", {
+									id: sortId,
+									style: S.select,
+									value: sort,
+									disabled: reads !== void 0,
+									onChange: (event) => {
+										setSort(event.target.value);
+									},
+									children: [
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+											value: "relevance",
+											children: "Relevance"
+										}),
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+											value: "newest",
+											children: "Newest first"
+										}),
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+											value: "oldest",
+											children: "Oldest first"
+										}),
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+											value: "title",
+											children: "Title"
+										})
+									]
+								})]
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								type: "submit",
+								style: S.button,
+								children: "Search"
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								type: "button",
+								style: S.button,
+								disabled: refreshing,
+								onClick: refresh,
+								children: refreshing ? "Refreshing…" : reads === void 0 ? "Rebuild index" : "Refresh library"
+							})
+						]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("p", {
+						style: {
+							...S.status,
+							color: health.tone
+						},
+						children: [
+							health.says,
+							" ",
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								style: { color: "var(--dsw-alias-label-tertiary)" },
+								children: reads === void 0 ? `${String(index.size)} record(s) indexed on this machine.` : "Answered by this workspace’s own host."
+							})
+						]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						style: S.status,
+						role: "status",
+						"aria-live": "polite",
+						children: total === 0 ? terms.length === 0 ? "No records to list." : `No matches for “${text}”.` : `${String(total)} match${total === 1 ? "" : "es"}, showing ${String(shown)} (page ${String(page)} of ${String(pages)}).`
+					}),
+					refreshing ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						style: S.status,
+						role: "status",
+						"aria-live": "polite",
+						children: "Reading the library again. The results below are the previous index until it finishes."
+					}) : null,
+					refreshed === null || refreshing ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("p", {
+						style: {
+							...S.status,
+							color: refreshed.failed ? "var(--watch-tone-error)" : "var(--dsw-alias-label-tertiary)"
+						},
+						role: "status",
+						"aria-live": "polite",
+						children: [refreshed.refreshed ? `Library refreshed: ${String(refreshed.recordCount)} record(s), generation ${String(refreshed.generation)}.` : refreshed.note, refreshed.refreshed && refreshed.note !== "" ? ` ${refreshed.note}` : ""]
+					}),
+					(state?.notes ?? []).map((note) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						style: S.status,
+						children: note
+					}, note)),
+					total === 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						style: {
+							...S.hit,
+							borderStyle: "dashed"
+						},
+						children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+							style: {
+								...S.snippet,
+								margin: 0
+							},
+							children: reads === void 0 && index.size === 0 ? "Nothing has been indexed yet. Evidence appears here once the workspace has recorded some — then this searches it locally, with no service and no model." : "Nothing matched. Every word has to appear in a record; try fewer words, or clear the filters."
+						})
+					}) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("ul", {
+						style: S.list,
+						children: rows.map((entry) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("li", {
+							style: S.hit,
+							children: [
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h4", {
+									style: S.title,
+									children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Highlighted, {
+										text: entry.title,
+										terms
+									})
+								}),
+								entry.snippets.map((snippet, at) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+									style: S.snippet,
+									children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Highlighted, {
+										text: snippet,
+										terms
+									})
+								}, `${entry.key}-${String(at)}`)),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+									style: S.meta,
+									children: [
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: entry.kind }),
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+											"data-watch-ltr": true,
+											children: entry.recordId
+										}),
+										entry.evidenceCount > 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+											"data-watch-ltr": true,
+											children: `${String(entry.evidenceCount)} evidence ref(s)`
+										}) : null
+									]
+								})
+							]
+						}, entry.key))
+					}),
+					pages > 1 ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("nav", {
+						style: {
+							display: "flex",
+							gap: "8px"
+						},
+						"aria-label": "Search results pages",
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+							type: "button",
+							style: S.button,
+							disabled: offset === 0,
+							onClick: () => {
+								run(Math.max(0, offset - PAGE));
+							},
+							children: "Previous"
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+							type: "button",
+							style: S.button,
+							disabled: offset + PAGE >= total,
+							onClick: () => {
+								run(Math.min(offset + PAGE, Math.max(0, total - 1)));
+							},
+							children: "Next"
+						})]
+					}) : null
+				]
+			});
+		}
+		//#endregion
+		//#region src/client/library-mode.tsx
+		/** The Library mode: everything recorded, and searchable. */
+		function LibraryModeView({ inspect, records = [], reads } = {}) {
+			const selected = parseVerdict(readToolResult(inspect));
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(ModeSurface, {
+				title: "Library",
+				lead: reads === void 0 ? "Every source and every piece of evidence this workspace has recorded. Search runs on this machine — no service, no model, nothing leaves it." : "Every source and every piece of evidence this workspace has recorded. Search runs on this workspace’s own host — no service, no model, nothing leaves the machine it runs on.",
+				children: [selected === null ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Panel, {
+					heading: "Selected record",
+					children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Facts, { rows: [
+						["Verdict", selected.verdict],
+						["Reason", selected.reason],
+						["Checks", String(selected.checks.length)]
+					] })
+				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(LibrarySearch, {
+					records,
+					reads
+				})]
+			});
+		}
+		//#endregion
+		//#region src/sources.ts
+		/**
+		* The current revision of a source.
+		*
+		* Highest revision number, not most recently observed — a re-index of an old
+		* revision must not become "current" because it happened last.
+		*/
+		function currentRevision(source) {
+			let best = null;
+			for (const revision of source.revisions) if (best === null || revision.revision > best.revision) best = revision;
+			return best;
+		}
+		/** Find one revision by id, wherever it sits in the history. */
+		function findRevision(source, sourceRevisionId) {
+			return source.revisions.find((revision) => revision.sourceRevisionId === sourceRevisionId) ?? null;
+		}
+		/**
+		* Whether a source revision is still the one a fresh observation would produce.
+		*
+		* Separated from freshness below because they are different questions: this is
+		* about the *source*, and freshness is about one piece of evidence taken from
+		* it. A source can be current while a specific observation from it is stale,
+		* when the observation covers a range the new revision no longer contains.
+		*/
+		function isCurrentRevision(source, sourceRevisionId) {
+			return currentRevision(source)?.sourceRevisionId === sourceRevisionId;
+		}
+		/**
+		* Freshness of one evidence record, given what the Library now holds.
+		*
+		* The rules, in order:
+		*
+		* - Evidence whose source the Library does not hold is `unavailable`. Not
+		*   `expired` — nobody knows whether it expired; it simply cannot be checked.
+		* - Evidence against the current revision keeps whatever freshness the engine
+		*   assigned it, including `gap`. Freshness is not the Library's to upgrade.
+		* - Evidence against a superseded revision is `stale`. It still resolves; it
+		*   no longer describes the source.
+		*
+		* Note what this function never returns: `current` for something it was not
+		* already told was current. A Library that could promote evidence to fresh
+		* would be a Library that re-validates by assertion.
+		*/
+		function freshnessOf(evidence, sources) {
+			const owner = sources.find((source) => source.revisions.some((revision) => revision.sourceRevisionId === evidence.sourceRevisionId));
+			if (owner === void 0) return "unavailable";
+			if (!isCurrentRevision(owner, evidence.sourceRevisionId)) return "stale";
+			return evidence.freshness;
+		}
+		/**
+		* Whether an evidence id can still be opened.
+		*
+		* Always true when the Library holds its revision, whatever the freshness. The
+		* function exists to make that a stated guarantee rather than an accident of
+		* whichever query happens to run: a stale citation that stopped opening would
+		* turn every old receipt into a dead link.
+		*/
+		function isAddressable(evidence, sources) {
+			return sources.some((source) => source.revisions.some((revision) => revision.sourceRevisionId === evidence.sourceRevisionId));
+		}
+		/**
+		* Resolve an evidence record to a place in the Library.
+		*
+		* Returns null only when the revision is not held. Everything else resolves,
+		* including evidence from four revisions ago — with `supersededBy` naming what
+		* replaced it, so the surface can offer "look at the same moment in the
+		* current revision" without silently doing it.
+		*/
+		function locate(evidence, sources) {
+			for (const source of sources) {
+				const revision = findRevision(source, evidence.sourceRevisionId);
+				if (revision === null) continue;
+				const current = currentRevision(source);
+				return {
+					sourceId: source.sourceId,
+					sourceRevisionId: revision.sourceRevisionId,
+					revision: revision.revision,
+					range: evidence.temporalRange,
+					freshness: freshnessOf(evidence, sources),
+					supersededBy: current === null || current.sourceRevisionId === revision.sourceRevisionId ? null : current.sourceRevisionId
+				};
+			}
+			return null;
+		}
+		/**
+		* Record a new revision of a source.
+		*
+		* Old revisions are kept, and their index state is marked `stale` rather than
+		* removed. That is the mechanism behind every "old evidence still opens"
+		* guarantee above — there is no code path that discards a revision, so there is
+		* no code path that could orphan a citation.
+		*/
+		function withRevision(source, revision) {
+			const superseded = source.revisions.filter((entry) => entry.sourceRevisionId !== revision.sourceRevisionId).map((entry) => entry.revision < revision.revision && entry.indexState === "indexed" ? {
+				...entry,
+				indexState: "stale"
+			} : entry);
+			return {
+				...source,
+				revisions: [...superseded, revision].sort((left, right) => left.revision - right.revision)
+			};
+		}
+		//#endregion
+		//#region src/search.ts
+		/**
+		* Decide the retrieval path.
+		*
+		* Semantic-only is a real state and is reported as one rather than silently
+		* treated as "search works". A library where exact-phrase search is
+		* unavailable behaves very differently from one where it is not, and a user
+		* searching for an error code needs to know which they are in.
+		*/
+		function searchPlan(capabilities) {
+			if (capabilities.lexical && capabilities.semantic) return {
+				path: "both",
+				explanation: "Hybrid search: exact matches and meaning-based matches, marked separately.",
+				degradedBecause: "",
+				fix: ""
+			};
+			if (capabilities.lexical) return {
+				path: "lexical",
+				explanation: "Exact matching only. A paraphrase of what was said will not be found.",
+				degradedBecause: "No embeddings role is bound, so semantic retrieval is unavailable.",
+				fix: "Bind an embeddings role in Settings to search by meaning as well."
+			};
+			if (capabilities.semantic) return {
+				path: "semantic",
+				explanation: "Meaning-based matching only. An exact phrase may rank below a paraphrase.",
+				degradedBecause: "The lexical index is unavailable.",
+				fix: "Re-index the library to restore exact matching."
+			};
+			return {
+				path: "none",
+				explanation: "Search is unavailable.",
+				degradedBecause: "Neither the lexical index nor an embeddings role is available.",
+				fix: "Index a source, or bind an embeddings role in Settings."
+			};
+		}
+		/** Count values, dropping the empty ones. */
+		function tally(values) {
+			const counts = /* @__PURE__ */ new Map();
+			for (const value of values) counts.set(value, (counts.get(value) ?? 0) + 1);
+			return [...counts.entries()].map(([value, count]) => ({
+				value,
+				count
+			})).sort((left, right) => {
+				const byCount = right.count - left.count;
+				return byCount !== 0 ? byCount : left.value.localeCompare(right.value);
+			});
+		}
+		/**
+		* Compute facets over a result set.
+		*
+		* Only values that actually occur. A facet list generated from the schema
+		* rather than from the results offers filters that return nothing, and a
+		* filter that returns nothing is indistinguishable from a broken one.
+		*/
+		function facetsFor(results, sources) {
+			const byId = new Map(sources.map((source) => [source.sourceId, source]));
+			const kinds = [];
+			const indexStates = [];
+			const collections = [];
+			const scripts = [];
+			const paths = [];
+			for (const result of results) {
+				kinds.push(result.kind);
+				const source = byId.get(result.sourceId);
+				if (source !== void 0) {
+					for (const collection of source.collections) collections.push(collection);
+					for (const revision of source.revisions) {
+						if (!result.hits.some((hit) => hit.sourceRevisionId === revision.sourceRevisionId)) continue;
+						indexStates.push(revision.indexState);
+						for (const script of revision.scripts) scripts.push(script);
+					}
+				}
+				for (const hit of result.hits) paths.push(hit.path);
+			}
+			return {
+				kind: tally(kinds),
+				indexState: tally(indexStates),
+				collection: tally(collections),
+				script: tally(scripts),
+				path: tally(paths)
+			};
+		}
+		/** Apply filters to a result set. Pure; the engine does the retrieval. */
+		function applyFilters(results, sources, filters) {
+			const byId = new Map(sources.map((source) => [source.sourceId, source]));
+			return results.filter((result) => {
+				if (filters.kinds !== void 0 && !filters.kinds.includes(result.kind)) return false;
+				if (filters.currentOnly === true && !result.current) return false;
+				const source = byId.get(result.sourceId);
+				if (filters.collections !== void 0) {
+					if (source === void 0) return false;
+					if (!filters.collections.some((collection) => source.collections.includes(collection))) return false;
+				}
+				if (filters.indexStates !== void 0) {
+					if (source === void 0) return false;
+					if (!source.revisions.filter((revision) => result.hits.some((hit) => hit.sourceRevisionId === revision.sourceRevisionId)).map((revision) => revision.indexState).some((state) => filters.indexStates?.includes(state) === true)) return false;
+				}
+				if (filters.scripts !== void 0) {
+					if (source === void 0) return false;
+					const present = new Set(source.revisions.flatMap((revision) => revision.scripts));
+					if (!filters.scripts.some((script) => present.has(script))) return false;
+				}
+				return true;
+			});
+		}
+		/**
+		* Order results for display.
+		*
+		* Within a source, hits are ordered by path and then by time — not by score
+		* across paths, because the scores are not comparable. Across sources, the
+		* source with the strongest lexical evidence leads, because an exact match is
+		* the strongest claim search can make.
+		*/
+		function rankResults(results) {
+			const lexicalWeight = (result) => result.hits.filter((hit) => hit.path === "lexical" || hit.path === "both").length;
+			return [...results].sort((left, right) => {
+				const byLexical = lexicalWeight(right) - lexicalWeight(left);
+				if (byLexical !== 0) return byLexical;
+				const byHits = right.hits.length - left.hits.length;
+				if (byHits !== 0) return byHits;
+				return left.sourceId.localeCompare(right.sourceId);
+			});
+		}
+		/**
+		* One line above the results, stating what was searched and how.
+		*
+		* Always says the path. "12 results" alone invites the reading that the library
+		* was searched thoroughly, which may not be true.
+		*/
+		function describeSearch(plan, results) {
+			const hits = results.reduce((total, result) => total + result.hits.length, 0);
+			const count = `${String(hits)} hit(s) in ${String(results.length)} source(s)`;
+			return plan.degradedBecause === "" ? `${count} · ${plan.explanation}` : `${count} · ${plan.explanation} ${plan.degradedBecause}`;
+		}
+		//#endregion
+		//#region src/client/components.tsx
+		/** The glyph half of a freshness state, so colour is never the only signal. */
+		const FRESHNESS_GLYPH = {
+			current: "●",
+			stale: "⌛",
+			gap: "⌇",
+			expired: "⊘",
+			unavailable: "?"
+		};
+		/** Freshness as glyph, word and tone. */
+		function FreshnessBadge({ freshness }) {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+				"data-watch-freshness": freshness,
+				style: { color: tokenFor(toneFor(freshness)) },
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+					"aria-hidden": "true",
+					children: FRESHNESS_GLYPH[freshness]
+				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: ` ${freshness}` })]
+			});
+		}
+		/**
+		* A source's revisions, newest last.
+		*
+		* Every revision is listed, including superseded ones, and every one is
+		* openable. A history that showed only the current revision would make old
+		* evidence unreachable through the interface even though it remains
+		* addressable underneath, which is the same failure with extra steps.
+		*/
+		function RevisionHistory({ source, onOpen }) {
+			const current = currentRevision(source);
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("ol", {
+				"data-watch-revisions": source.sourceId,
+				style: {
+					listStyle: "none",
+					margin: 0,
+					padding: 0
+				},
+				children: source.revisions.map((revision) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("li", {
+					"data-watch-revision": revision.sourceRevisionId,
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("button", {
+						type: "button",
+						"data-watch-index-state": revision.indexState,
+						"aria-current": current?.sourceRevisionId === revision.sourceRevisionId ? "true" : void 0,
+						onClick: () => {
+							onOpen(revision);
+						},
+						style: {
+							font: "inherit",
+							color: "inherit",
+							background: "none",
+							border: "none",
+							cursor: "pointer"
+						},
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								dir: "ltr",
+								children: `r${String(revision.revision)}`
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: ` ${revision.indexState}` }),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("time", {
+								dateTime: revision.observedAt,
+								children: ` ${revision.observedAt}`
+							}),
+							current?.sourceRevisionId === revision.sourceRevisionId && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: " · current" })
+						]
+					}), revision.indexError !== null && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+						"data-watch-index-error": "",
+						children: ` ${revision.indexError}`
+					})]
+				}, revision.sourceRevisionId))
+			});
+		}
+		/**
+		* One hit.
+		*
+		* The retrieval path is on the row, not in a legend. A person reading a
+		* semantic hit needs to know it is a semantic hit at the moment they read it,
+		* because that is what decides whether they should check it.
+		*/
+		function SearchHitRow({ hit, freshness, onOpen }) {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", {
+				"data-watch-hit": hit.sourceRevisionId,
+				"data-watch-path": hit.path,
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("button", {
+					type: "button",
+					onClick: () => {
+						onOpen(hit);
+					},
+					style: {
+						font: "inherit",
+						color: "inherit",
+						background: "none",
+						border: "none",
+						cursor: "pointer",
+						textAlign: "start"
+					},
+					children: [
+						hit.range !== null && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							dir: "ltr",
+							style: { fontVariantNumeric: "tabular-nums" },
+							children: `${String(Math.floor(hit.range.startMs / 1e3))}s `
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							dir: "auto",
+							children: hit.text
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							"data-watch-hit-path": hit.path,
+							children: ` (${hit.path})`
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)(FreshnessBadge, { freshness })
+					]
+				})
+			});
+		}
+		/** The facet rail. Only values that actually occur are offered. */
+		function FacetPanel({ facets, onFilter }) {
+			const groups = [
+				["kind", facets.kind],
+				["indexState", facets.indexState],
+				["collection", facets.collection],
+				["script", facets.script],
+				["path", facets.path]
+			];
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("aside", {
+				"data-watch-facets": "",
+				"aria-label": "Filters",
+				children: groups.map(([name, values]) => values.length === 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
+					"data-watch-facet": name,
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", {
+						style: {
+							font: "inherit",
+							fontSize: "11px"
+						},
+						children: name
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("ul", {
+						style: {
+							listStyle: "none",
+							margin: 0,
+							padding: 0
+						},
+						children: values.map((value) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", { children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+							type: "button",
+							"data-watch-facet-value": value.value,
+							onClick: () => {
+								onFilter(name, value.value);
+							},
+							style: {
+								font: "inherit",
+								color: "inherit",
+								background: "none",
+								border: "none",
+								cursor: "pointer"
+							},
+							children: `${value.value} (${String(value.count)})`
+						}) }, value.value))
+					})]
+				}, name))
+			});
+		}
+		/** The Library mode body. */
+		function LibrarySurface(props) {
+			const byId = new Map(props.sources.map((source) => [source.sourceId, source]));
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
+				"data-watch-library": "",
+				"aria-label": "Library",
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						"data-watch-search-plan": props.plan.path,
+						children: describeSearch(props.plan, props.results)
+					}),
+					props.plan.fix !== "" && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						"data-watch-search-fix": "",
+						children: props.plan.fix
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(FacetPanel, {
+						facets: props.facets,
+						onFilter: props.onFilter
+					}),
+					props.results.length === 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						"data-watch-library-empty": "",
+						children: "Nothing in the Library matches."
+					}) : props.results.map((result) => {
+						const source = byId.get(result.sourceId);
+						return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("article", {
+							"data-watch-source": result.sourceId,
+							children: [
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", {
+									style: { font: "inherit" },
+									dir: "auto",
+									children: result.title
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+									"data-watch-source-kind": result.kind,
+									children: result.kind
+								}),
+								!result.current && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+									"data-watch-source-superseded": "",
+									children: " The source has changed since these were observed."
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)("ul", {
+									style: {
+										listStyle: "none",
+										margin: 0,
+										padding: 0
+									},
+									children: result.hits.map((hit) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SearchHitRow, {
+										hit,
+										freshness: props.freshnessOf(hit),
+										onOpen: props.onOpenHit
+									}, `${hit.sourceRevisionId}:${String(hit.range?.startMs ?? 0)}:${hit.text}`))
+								}),
+								source !== void 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RevisionHistory, {
+									source,
+									onOpen: props.onOpenRevision
+								})
+							]
+						}, result.sourceId);
+					})
+				]
+			});
+		}
+		//#endregion
+		//#region src/client/index.tsx
+		/**
+		* Services this half needs before it can register anything.
+		*
+		* `remote.watchQuery` as well as `remote`. The Gateway installs each mounted
+		* namespace as its own cordis service under that key, so naming it is what
+		* makes this plugin wait for the mount rather than load beside it: the bare
+		* `remote` resolves as soon as the Gateway's browser half exists — which is
+		* before any contribution is mounted — and leaves `ctx.remote` with no
+		* `watchQuery` on it. Both are listed because both are read, and cordis
+		* refuses a property no `inject` entry claims: reaching `ctx.remote.watchQuery`
+		* on the strength of the second entry alone fails the fiber with "cannot get
+		* property "remote" without inject".
+		*
+		* The mount itself belongs to `@deepwatch/dsh-client-remotes`. This package
+		* owns the Library capability, and a package that owns a capability does not
+		* also own the transport that carries it; when it did, the two depended on
+		* each other.
+		*/
+		const inject = [
+			"slots",
+			"remote",
+			"remote.watchQuery"
+		];
+		/**
+		* Register the Library mode body, bound to the read plane it queries.
+		*
+		* A `conversation.view` entry is handed `{ inspect, onInspectDone }` and
+		* nothing else, so a mode body has no way to reach a service on its own. The
+		* binding happens here, where the context is: what gets registered is the mode
+		* body with the mounted `watchQuery` namespace already supplied.
+		*
+		* Nothing here is defensive about `ctx.remote.watchQuery`. `inject` above means
+		* cordis does not call `apply` until that service exists, so a profile without
+		* the mount parks this plugin — no Library tab at all — rather than drawing a
+		* tab whose search quietly answers from an empty local index.
+		*/
+		function apply(ctx) {
+			const slots = ctx.slots;
+			const reads = ctx.remote.watchQuery;
+			/** The Library body, bound to the host that answers for it. */
+			const BoundLibraryModeView = (props) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(LibraryModeView, {
+				...props,
+				reads
+			});
+			slots.inject("conversation.view", () => {
+				slots.register({
+					name: "conversation.view",
+					id: "library",
+					label: "Library",
+					order: 50
+				}, BoundLibraryModeView);
+			});
+		}
+		//#endregion
+		exports.FacetPanel = FacetPanel;
+		exports.FreshnessBadge = FreshnessBadge;
+		exports.LibraryModeView = LibraryModeView;
+		exports.LibrarySearch = LibrarySearch;
+		exports.LibrarySurface = LibrarySurface;
+		exports.MAX_LIMIT = MAX_LIMIT;
+		exports.RevisionHistory = RevisionHistory;
+		exports.SearchHitRow = SearchHitRow;
+		exports.apply = apply;
+		exports.applyFilters = applyFilters;
+		exports.currentRevision = currentRevision;
+		exports.describeSearch = describeSearch;
+		exports.facetsFor = facetsFor;
+		exports.findRevision = findRevision;
+		exports.freshnessOf = freshnessOf;
+		exports.fromIndex = fromIndex;
+		exports.inject = inject;
+		exports.isAddressable = isAddressable;
+		exports.isCurrentRevision = isCurrentRevision;
+		exports.locate = locate;
+		exports.nextRequestId = nextRequestId;
+		exports.rankResults = rankResults;
+		exports.readLibraryPage = readLibraryPage;
+		exports.refreshLibrary = refreshLibrary;
+		exports.searchPlan = searchPlan;
+		exports.withRevision = withRevision;
+		return module.exports;
+	}
+});
+
+//# sourceMappingURL=client.js.map