@embedpdf/plugin-search 3.0.0-next.13 → 3.0.0-next.15

package/dist/index.js

@@ -1,361 +1,403 @@
-import { n as validateSearchRegex, r as SearchToken, t as validateSearchQuery } from "./contract-YzH14CUn.js";
-import { definePlugin } from "@embedpdf/core";
+import { i as SearchToken, n as validateSearchQuery, r as validateSearchRegex, t as SEARCH_DEFAULTS } from "./contract-uWSW5IYM.js";
+import { PluginError, definePlugin, defineState, isPluginError, pageRefsEqual, toPluginError, toPluginErrorInfo } from "@embedpdf/core";
 import { StageToken } from "@embedpdf/plugin-stage/contract";
-import { applyPoint, boundsOfRects, pageGeometry, textQuadBounds } from "@embedpdf/core-geometry";
-import { EngineError, EngineErrorCode } from "@embedpdf/engine-core/runtime";
-//#region src/capability.ts
-const EMPTY = [];
-/** The browser find-bar feel: hit at the top-middle, no zoom change. */
-const DEFAULT_REVEAL = {
-	anchor: { y: .35 },
-	behavior: "smooth"
+import { boundsOfRects } from "@embedpdf/core-geometry";
+//#region src/model.ts
+/**
+* The search session: the query, the hits found so far (also grouped by
+* page), the active hit, and progress. Every function below is a pure
+* transition; the controller applies them with `ctx.state.update`.
+*/
+/** The progress of no search, one object for every session that hasn't searched a page yet. */
+const NO_PROGRESS = Object.freeze({
+	pagesSearched: 0,
+	pageCount: 0
+});
+const initialSearchState = () => ({
+	query: null,
+	status: "idle",
+	operationId: null,
+	hits: [],
+	hitsByPage: {},
+	activeHitIndex: -1,
+	progress: NO_PROGRESS,
+	error: null
+});
+/** A new scan starts: everything from the previous session is dropped. */
+const startSession = (_state, query, operationId) => ({
+	...initialSearchState(),
+	query,
+	status: "searching",
+	operationId
+});
+const sameProgress = (left, right) => left.pagesSearched === right.pagesSearched && left.pageCount === right.pageCount;
+/**
+* A slice of hits arrived. The first hit becomes active so "1 of N" reads
+* right; moving the camera is navigation's job, not the stream's. Progress
+* with the same counts keeps its object: readers, and `onProgressChanged`,
+* see a change only when the counts change.
+*/
+function appendHits(state, hits, slice) {
+	const progress = sameProgress(state.progress, slice) ? state.progress : slice;
+	if (hits.length === 0) return progress === state.progress ? state : {
+		...state,
+		progress
+	};
+	const hitsByPage = { ...state.hitsByPage };
+	for (const hit of hits) {
+		const pageObjectNumber = hit.page.objectNumber;
+		hitsByPage[pageObjectNumber] = [...hitsByPage[pageObjectNumber] ?? [], hit];
+	}
+	return {
+		...state,
+		hits: [...state.hits, ...hits],
+		hitsByPage,
+		activeHitIndex: state.activeHitIndex === -1 ? 0 : state.activeHitIndex,
+		progress
+	};
+}
+const completeSession = (state) => ({
+	...state,
+	status: "complete"
+});
+const cancelSession = (state) => ({
+	...state,
+	status: "cancelled"
+});
+const failSession = (state, error) => ({
+	...state,
+	status: "error",
+	error
+});
+const setActiveHit = (state, index) => state.activeHitIndex === index ? state : {
+	...state,
+	activeHitIndex: index
 };
-/** Local engines reject a denied scope before the worker; cloud maps 403. */
-const isPermissionDenied = (err) => err instanceof Error && err.name === "PermissionDenied" || EngineError.is(err, EngineErrorCode.Forbidden);
+const clearSession = (state) => state.status === "idle" ? state : initialSearchState();
 /**
-* The search capability: a client-driven cursor loop over the engine's
-* budgeted slices. One generation counter arbitrates: a new `search()` (or
-* `clear()`, or a document mutation via `rerun()`) supersedes the running
-* loop, which aborts its in-flight slice and stops dispatching.
+* Where `hit` is in `hits`: the same object, or else the hit that covers the
+* same characters of the same page, so a hit kept from before the search ran
+* again still finds its place. -1 when it isn't there.
+*/
+function indexOfHit(hits, hit) {
+	const same = hits.indexOf(hit);
+	if (same >= 0) return same;
+	return hits.findIndex((candidate) => candidate.start === hit.start && candidate.count === hit.count && pageRefsEqual(candidate.page, hit.page));
+}
+/**
+* The pages that have at least one hit, in document order: `pages` is the
+* document's page list, whose order moving a page changes (object numbers
+* don't follow it).
+*/
+const pagesWithHits = (state, pages) => pages.filter((page) => (state.hitsByPage[page.ref.objectNumber]?.length ?? 0) > 0).map((page) => page.ref);
+//#endregion
+//#region src/controller.ts
+const EMPTY = Object.freeze([]);
+const EMPTY_PAGES = Object.freeze([]);
+/** Reruns after document mutations are coalesced: a burst of events triggers one rescan. */
+const RERUN_DELAY_MS = 250;
+/**
+* The search controller. `search` runs on a `latest` lane (a newer search
+* supersedes the older one, which can no longer publish); `findAll` runs on
+* its own signal and never touches the session. Both share `collect`, the
+* one cursor loop over the engine's budgeted slices.
 *
-* Rect conversion happens HERE, once per slice: the engine's PDF-space
-* line rects → content space through the same page geometry the selection
-* plugin uses, so search highlights and selection highlights are pixel-twins.
+* The scan's own events (started, completed, cancelled, failed) fire where
+* the scan reaches those points. The progress, active-hit and cleared events
+* are derived from state changes, so they always agree with the getters.
 *
-* Stage integration is optional and additive: with a Stage present the scan
-* starts at the current page (viewport-first — the hits the user is looking
-* at arrive in the first slice) and `next()`/`prev()`/`goTo()` reveal the
-* hit's page. Without one, navigation still works; the host scrolls.
+* The settings are read where they're used, never copied, so
+* `updateSettings({ reveal })` applies to the next move at once.
 */
-function createSearchCapability(ctx, config = {}) {
-	let generation = 0;
-	let inflight = null;
+function createSearchController(ctx) {
+	const settings = ctx.settings();
+	const session = ctx.latest("session");
+	const started = ctx.events.source();
+	const progressChanged = ctx.events.source();
+	const completed = ctx.events.source();
+	const cancelled = ctx.events.source();
+	const failed = ctx.events.source();
+	const activeHitChanged = ctx.events.source();
+	const cleared = ctx.events.source();
+	const state = () => ctx.state.get();
+	ctx.state.onChange(({ previous, next }) => {
+		if (previous.progress !== next.progress) progressChanged.emit({
+			...next.progress,
+			hitCount: next.hits.length
+		});
+		if (previous.activeHitIndex !== next.activeHitIndex) activeHitChanged.emit({
+			index: next.activeHitIndex,
+			hit: next.hits[next.activeHitIndex] ?? null
+		});
+		if (previous.status !== "idle" && next.status === "idle") cleared.emit({});
+	});
 	function hitsFromSlice(slice) {
-		const converters = /* @__PURE__ */ new Map();
-		const converterFor = (pon) => {
-			let conv = converters.get(pon);
-			if (conv !== void 0) return conv;
-			const layout = ctx.document()?.pages.find((p) => p.pageObjectNumber === pon);
-			if (!layout) conv = null;
-			else {
-				const { pdfToContent } = pageGeometry({
-					crop: layout.boxes.crop,
-					rotation: layout.rotation,
-					userUnit: layout.userUnit
-				}, 1);
-				const toPoint = (pt) => applyPoint(pdfToContent, pt);
-				conv = {
-					pageIndex: layout.index,
-					toQuad: (q) => ({
-						upperStart: toPoint(q.p1),
-						upperEnd: toPoint(q.p2),
-						lowerStart: toPoint(q.p3),
-						lowerEnd: toPoint(q.p4)
-					})
-				};
-			}
-			converters.set(pon, conv);
-			return conv;
-		};
 		const hits = [];
 		for (const match of slice.matches) {
-			const conv = converterFor(match.pageObjectNumber);
-			if (!conv) continue;
-			const segments = match.segments.map((segment) => {
-				const quad = conv.toQuad(segment.quad);
-				return {
-					quad,
-					rect: textQuadBounds(quad),
-					advance: segment.advance
-				};
-			});
+			const page = ctx.getPage(match.page);
+			if (!page) continue;
+			const segments = match.segments;
 			hits.push({
-				pon: match.pageObjectNumber,
-				pageIndex: conv.pageIndex,
-				charStart: match.charStart,
-				charCount: match.charCount,
+				page: match.page,
+				pageIndex: page.index,
+				start: match.start,
+				count: match.count,
 				segments,
-				...segments.length ? { bounds: boundsOfRects(segments.map((s) => s.rect)) ?? void 0 } : {},
+				...segments.length ? { bounds: boundsOfRects(segments.map((segment) => segment.rect)) ?? void 0 } : {},
 				...match.snippet ? { snippet: match.snippet } : {}
 			});
 		}
 		return hits;
 	}
 	/**
-	* THE MECHANISM — one cursor loop over the engine's budgeted slices,
-	* shared by the session (`search`) and the session-free service
-	* (`findAll`): permission fallback ('full' → 'rects' when snippets are
-	* denied, unless the caller pinned a mode), restart-once on a stale
-	* cursor, rect conversion per slice. Resolves true on exhaustion, false
-	* when cancelled; throws on error.
+	* One cursor loop over budgeted slices: permission fallback (snippets → none
+	* when they are denied, unless pinned), restart-once on a stale cursor,
+	* projection per slice. Returns true on exhaustion, false when the signal
+	* aborted; throws on a real error (already a PluginError: ctx.doc is guarded).
 	*/
-	async function collect(query, opts, sink) {
-		const doc = ctx.doc;
-		if (!doc) return false;
+	async function collect(query, options, sink) {
+		const { signal } = options;
 		sink.onStart();
-		let mode = opts.mode ?? "full";
-		const modePinned = opts.mode !== void 0;
+		let snippets = options.snippets ?? true;
+		const snippetsPinned = options.snippets !== void 0;
 		let cursor;
 		let restarted = false;
 		for (;;) {
+			if (signal?.aborted) return false;
 			let slice;
+			const request = {
+				...query,
+				snippets,
+				...cursor !== void 0 ? { cursor } : options.from !== void 0 ? { from: options.from } : {}
+			};
 			try {
-				const request = {
-					query,
-					mode,
-					...cursor !== void 0 ? { cursor } : opts.startPage !== void 0 ? { startPage: opts.startPage } : {}
-				};
-				const pending = doc.search.query(request);
-				sink.setInflight(pending);
-				slice = await pending;
-			} catch (err) {
-				if (sink.isCancelled()) return false;
-				if (!modePinned && mode === "full" && cursor === void 0 && isPermissionDenied(err)) {
-					mode = "rects";
+				slice = await ctx.cancellable(signal, ctx.doc.with({ priority: "low" }).search.query(request));
+			} catch (error) {
+				if (signal?.aborted) return false;
+				if (!snippetsPinned && snippets && cursor === void 0 && isPluginError(error, "permission-denied")) {
+					snippets = false;
 					continue;
 				}
-				if (cursor !== void 0 && !restarted && EngineError.is(err, EngineErrorCode.InvalidArg)) {
+				if (cursor !== void 0 && !restarted && isPluginError(error, "invalid-input")) {
 					restarted = true;
 					cursor = void 0;
 					sink.onStart();
 					continue;
 				}
-				throw err;
-			}
-			if (sink.isCancelled()) return false;
-			sink.onSlice(hitsFromSlice(slice), slice.scannedPages, slice.totalPages);
-			if (slice.nextCursor === null) {
-				sink.setInflight(null);
-				return true;
+				throw error;
 			}
+			if (signal?.aborted) return false;
+			sink.onSlice(hitsFromSlice(slice), slice.pagesSearched, slice.pageCount);
+			if (slice.nextCursor === null) return true;
 			cursor = slice.nextCursor;
 		}
 	}
-	/** THE SESSION — collect() with state as the sink, generation-guarded. */
-	async function runSession(query, startPage) {
-		const gen = ++generation;
-		inflight?.abort("superseded");
-		inflight = null;
-		if (!ctx.doc) {
-			ctx.dispatch({ type: "CLEAR" });
-			return;
-		}
-		if (startPage === void 0) {
-			const stage = ctx.tryGet(StageToken);
-			if (stage) startPage = ctx.document()?.pages[stage.currentPage()]?.pageObjectNumber;
+	const viewportFirstPage = () => {
+		return ctx.tryGet(StageToken)?.getCurrentPage() ?? void 0;
+	};
+	async function search(query, options = {}) {
+		if (query.text.length === 0) {
+			clear();
+			return {
+				status: "complete",
+				hitCount: 0
+			};
 		}
-		try {
-			if (await collect(query, { startPage }, {
-				onStart: () => ctx.dispatch({
-					type: "START",
-					query
+		ctx.assertAllowed("doc.text.search", "search");
+		const from = options.from === void 0 ? viewportFirstPage() : ctx.pageOf(options.from).ref;
+		let operationId = "";
+		return session.run(async (run) => {
+			operationId = run.id;
+			if (!await collect(query, {
+				from,
+				signal: run.signal
+			}, {
+				onStart: () => run.commit(() => {
+					ctx.state.update(startSession, query, run.id);
+					started.emit({ query });
 				}),
-				onSlice: (hits, scanned, total) => ctx.dispatch({
-					type: "APPEND",
-					hits,
-					scanned,
-					total
-				}),
-				isCancelled: () => gen !== generation,
-				setInflight: (pending) => {
-					if (gen === generation) inflight = pending;
-				}
-			}) && gen === generation) ctx.dispatch({ type: "COMPLETE" });
-		} catch (err) {
-			if (gen !== generation) return;
-			ctx.dispatch({
-				type: "ERROR",
-				message: err instanceof Error ? err.message : String(err)
+				onSlice: (hits, pagesSearched, pageCount) => run.commit(() => ctx.state.update(appendHits, hits, {
+					pagesSearched,
+					pageCount
+				}))
+			})) throw new PluginError("operation-cancelled", "search", "search aborted");
+			run.commit(() => {
+				ctx.state.update(completeSession);
+				completed.emit({ hitCount: state().hits.length });
 			});
-		}
+			return {
+				status: "complete",
+				hitCount: state().hits.length
+			};
+		}, options).catch((error) => {
+			if (isPluginError(error, "instance-closed")) return {
+				status: "cancelled",
+				hitCount: 0
+			};
+			if (isPluginError(error, "operation-cancelled")) {
+				const why = error.details?.reason ?? "cancelled";
+				const reason = why === "superseded" ? "superseded" : why === "cleared" ? "cleared" : "cancelled";
+				if (reason === "cancelled" && state().operationId === operationId) ctx.state.update(cancelSession);
+				cancelled.emit({ reason });
+				return {
+					status: reason === "superseded" ? "superseded" : "cancelled",
+					hitCount: state().hits.length
+				};
+			}
+			const info = toPluginErrorInfo(toPluginError("search", error));
+			if (state().operationId === operationId) ctx.state.update(failSession, info);
+			failed.emit({ error: info });
+			throw error;
+		});
+	}
+	function clear() {
+		session.cancel("cleared");
+		ctx.state.update(clearSession);
 	}
-	function goTo(index, reveal) {
-		const { hits } = ctx.getState();
+	function goToHit(target, options) {
+		const { hits } = state();
 		if (hits.length === 0) return null;
-		const wrapped = (index % hits.length + hits.length) % hits.length;
-		ctx.dispatch({
-			type: "SET_ACTIVE",
-			index: wrapped
-		});
-		const hit = hits[wrapped];
+		const index = typeof target === "number" ? (target % hits.length + hits.length) % hits.length : indexOfHit(hits, target);
+		if (index < 0) return null;
+		ctx.state.update(setActiveHit, index);
+		reveal(hits[index], options);
+		return hits[index];
+	}
+	function reveal(hit, options) {
 		const arrival = {
-			...DEFAULT_REVEAL,
-			...config.reveal,
-			...reveal
+			...settings.get().reveal,
+			...options
 		};
-		ctx.tryGet(StageToken)?.reveal(hit.pageIndex, {
+		ctx.tryGet(StageToken)?.reveal(hit.page, {
 			rect: hit.bounds,
 			anchor: arrival.anchor,
 			behavior: arrival.behavior
 		});
-		return hit;
 	}
-	const clear = () => {
-		generation++;
-		inflight?.abort("cleared");
-		inflight = null;
-		ctx.dispatch({ type: "CLEAR" });
+	/**
+	* One page's hits, by the page's ref or index. A page that isn't in the
+	* document has none: a layer may read while its page is being deleted.
+	*/
+	const hitsOn = (page) => {
+		const found = ctx.getPage(page);
+		return found ? state().hitsByPage[found.ref.objectNumber] ?? EMPTY : EMPTY;
 	};
-	return {
-		canSearch: (mode) => {
-			const sec = ctx.doc?.security;
-			if (!sec) return false;
-			return sec.allows("doc.text.search") && (mode !== "full" || sec.allows("doc.text.copy"));
-		},
-		search: (query, exec) => query.text.length === 0 ? clear() : void runSession(query, exec?.startPage),
-		rerun: () => {
-			const { query, status } = ctx.getState();
-			if (query && status !== "idle") runSession(query);
+	const api = {
+		...settings.api,
+		canSearch: (options) => ctx.allows("doc.text.search") && (!options?.snippets || ctx.allows("doc.text.copy")),
+		search,
+		refresh: (options) => {
+			const { query, status } = state();
+			if (!query || status === "idle") return Promise.resolve({
+				status: "complete",
+				hitCount: 0
+			});
+			return search(query, options);
 		},
+		cancel: () => session.cancel("cancelled"),
 		clear,
-		next: () => goTo(ctx.getState().activeIndex + 1),
-		prev: () => goTo(ctx.getState().activeIndex - 1),
-		goTo,
-		query: () => ctx.getState().query,
-		findAll: async (query, opts = {}) => {
-			if (!ctx.doc) return [];
-			const all = [];
-			const signal = opts.signal;
-			let pending = null;
-			const onAbort = () => pending?.abort(signal?.reason);
-			signal?.addEventListener("abort", onAbort, { once: true });
-			try {
-				await collect(query, { mode: opts.mode }, {
-					onStart: () => {
-						all.length = 0;
-					},
-					onSlice: (hits) => all.push(...hits),
-					isCancelled: () => signal?.aborted ?? false,
-					setInflight: (p) => {
-						pending = p;
-					}
-				});
-				if (signal?.aborted) throw signal.reason ?? /* @__PURE__ */ new Error("findAll aborted");
-				return all;
-			} finally {
-				signal?.removeEventListener("abort", onAbort);
-			}
-		},
-		status: () => ctx.getState().status,
-		hits: () => ctx.getState().hits,
-		hitCount: () => ctx.getState().hits.length,
-		activeIndex: () => ctx.getState().activeIndex,
-		activeHit: () => {
-			const { hits, activeIndex } = ctx.getState();
-			return activeIndex >= 0 && activeIndex < hits.length ? hits[activeIndex] : null;
+		nextHit: (options) => goToHit(state().activeHitIndex + 1, options),
+		previousHit: (options) => goToHit(state().activeHitIndex - 1, options),
+		goToHit,
+		revealActiveHit: (options) => {
+			const hit = api.getActiveHit();
+			if (hit) reveal(hit, options);
 		},
-		hitsForPage: (pon) => {
-			const { hits, hitsByPage } = ctx.getState();
-			const indices = hitsByPage[pon];
-			return indices?.length ? indices.map((i) => hits[i]) : EMPTY;
+		getQuery: () => state().query,
+		getStatus: () => state().status,
+		listHits: (filter) => filter?.page === void 0 ? state().hits : hitsOn(filter.page),
+		getHitCount: (page) => (page === void 0 ? state().hits : hitsOn(page)).length,
+		listPagesWithHits: () => state().hits.length ? pagesWithHits(state(), ctx.document()?.pages ?? []) : EMPTY_PAGES,
+		getActiveHitIndex: () => state().activeHitIndex,
+		getActiveHit: () => state().hits[state().activeHitIndex] ?? null,
+		getProgress: () => state().progress,
+		getError: () => state().error,
+		findAll: async (query, options = {}) => {
+			ctx.assertAllowed("doc.text.search", "findAll");
+			const all = [];
+			if (!await collect(query, {
+				...options.snippets !== void 0 ? { snippets: options.snippets } : {},
+				...options.signal ? { signal: options.signal } : {}
+			}, {
+				onStart: () => {
+					all.length = 0;
+				},
+				onSlice: (hits) => all.push(...hits)
+			})) throw new PluginError("operation-cancelled", "search", "findAll aborted");
+			return all;
 		},
-		progress: () => ctx.getState().progress,
-		errorMessage: () => ctx.getState().error
+		onStarted: started.on,
+		onProgressChanged: progressChanged.on,
+		onCompleted: completed.on,
+		onCancelled: cancelled.on,
+		onFailed: failed.on,
+		onActiveHitChanged: activeHitChanged.on,
+		onCleared: cleared.on
 	};
-}
-//#endregion
-//#region src/effects.ts
-const RERUN_DELAY_MS = 250;
-function registerSearchEffects(ctx) {
-	const doc = ctx.doc;
-	if (!doc) return;
-	let timer = null;
-	const unsubscribe = doc.events.subscribe(() => {
-		if (ctx.getState().status === "idle") return;
-		if (timer !== null) clearTimeout(timer);
-		timer = setTimeout(() => {
-			timer = null;
-			ctx.get(SearchToken).rerun();
-		}, RERUN_DELAY_MS);
-	});
-	ctx.cleanup(() => {
-		if (timer !== null) clearTimeout(timer);
-		unsubscribe();
-	});
-}
-//#endregion
-//#region src/reducer.ts
-const initialSearchState = () => ({
-	query: null,
-	status: "idle",
-	hits: [],
-	hitsByPage: {},
-	activeIndex: -1,
-	progress: {
-		scanned: 0,
-		total: 0
-	},
-	error: null
-});
-const searchReducer = (state, action) => {
-	switch (action.type) {
-		case "START": return {
-			...initialSearchState(),
-			query: action.query,
-			status: "searching"
-		};
-		case "APPEND": {
-			if (action.hits.length === 0) return {
-				...state,
-				progress: {
-					scanned: action.scanned,
-					total: action.total
-				}
-			};
-			const hits = state.hits.concat(action.hits);
-			const hitsByPage = { ...state.hitsByPage };
-			for (let i = state.hits.length; i < hits.length; i++) {
-				const pon = hits[i].pon;
-				hitsByPage[pon] = (hitsByPage[pon] ?? []).concat(i);
-			}
-			return {
-				...state,
-				hits,
-				hitsByPage,
-				activeIndex: state.activeIndex === -1 ? 0 : state.activeIndex,
-				progress: {
-					scanned: action.scanned,
-					total: action.total
-				}
-			};
+	return {
+		api,
+		connect() {
+			let cancelRerun = null;
+			ctx.listen(ctx.doc.events, () => {
+				if (state().status === "idle") return;
+				cancelRerun?.();
+				cancelRerun = ctx.clock.after(RERUN_DELAY_MS, () => {
+					cancelRerun = null;
+					api.refresh().catch(() => {});
+				});
+			});
 		}
-		case "COMPLETE": return {
-			...state,
-			status: "complete"
-		};
-		case "ERROR": return {
-			...state,
-			status: "error",
-			error: action.message
-		};
-		case "SET_ACTIVE": return {
-			...state,
-			activeIndex: action.index
-		};
-		case "CLEAR": return initialSearchState();
-		default: return state;
-	}
-};
+	};
+}
 //#endregion
 //#region src/search.plugin.ts
 /**
-* Document text search over `doc.search` — the engine's budgeted,
-* cursor-resumable slices. Document-scoped; no pointer handling, so it
-* needs no interaction hub. The Stage is optional: when present, scans
-* start at the current page (viewport-first) and hit navigation reveals
-* the hit's page; without it the host owns scrolling.
+* Document text search over the engine's budgeted, resumable slices.
+* Document-scoped; no pointer handling. The stage is optional: with one,
+* scans start at the current page and navigation reveals hits. `config` is
+* the settings the app registers, over {@link SEARCH_DEFAULTS}.
 */
 const searchPlugin = (config) => definePlugin({
 	id: "search",
 	token: SearchToken,
 	scope: "document",
 	optional: [StageToken],
-	initialState: initialSearchState,
-	reduce: searchReducer,
-	capability: (ctx) => createSearchCapability(ctx, config),
-	effects: registerSearchEffects
+	state: initialSearchState,
+	settings: {
+		defaults: SEARCH_DEFAULTS,
+		registered: config
+	},
+	create: createSearchController
+});
+//#endregion
+//#region src/state.ts
+/**
+* The search page's State table as code: what `useSearchState()` returns, and
+* the same fields in every other framework. The matches themselves are not
+* here: `useSearchHits()` reads them, so a component that only shows the
+* count doesn't re-render for every match that arrives.
+*/
+const searchState = defineState(SearchToken, {
+	read: (search) => ({
+		query: search.getQuery(),
+		status: search.getStatus(),
+		hitCount: search.getHitCount(),
+		activeHitIndex: search.getActiveHitIndex(),
+		activeHit: search.getActiveHit(),
+		progress: search.getProgress(),
+		error: search.getError()
+	}),
+	empty: {
+		query: null,
+		status: "idle",
+		hitCount: 0,
+		activeHitIndex: -1,
+		activeHit: null,
+		progress: NO_PROGRESS,
+		error: null
+	}
 });
 //#endregion
-export { SearchToken, searchPlugin, validateSearchQuery, validateSearchRegex };
+export { SEARCH_DEFAULTS, SearchToken, searchPlugin, searchState, validateSearchQuery, validateSearchRegex };
 
 //# sourceMappingURL=index.js.map