@pithy-sh/support 0.5.0 → 0.6.0

package/dist/store/hybrid.js

@@ -0,0 +1,185 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+import { SUPPORT_THREADS_TABLE } from "../data/tables.js";
+import { semanticHits } from "../semantic/query.js";
+import "./paging.js";
+import { keywordHits } from "./search.js";
+import { applyThreadFilters, listedThreadOf, viewerThreads } from "./threads.js";
+import { ValidationError } from "@pithy-sh/core/src/error/pithyError";
+import { pithyCommandOf } from "@pithy-sh/core/src/cli/command";
+import { chunkByBoundParameters } from "@pithy-sh/core/src/data/boundParameters";
+//#region src/store/hybrid.ts
+/** The reciprocal-rank-fusion constant — the standard 60, which damps the head without flattening it. */
+const RRF_K = 60;
+/** How many messages each backend retrieves before the roll-up. Vectorize's payload-free ceiling. */
+const SEARCH_HITS = 100;
+/**
+* Roll a backend's message hits up to threads: a thread takes the rank of its best message, and appears once.
+* The input is best first, so the first message seen for a thread is its best.
+*/
+function rollUp(hits) {
+	const seen = /* @__PURE__ */ new Set();
+	const ranked = [];
+	for (const hit of hits) {
+		if (seen.has(hit.threadId)) continue;
+		seen.add(hit.threadId);
+		ranked.push({
+			threadId: hit.threadId,
+			messageId: hit.messageId,
+			rank: ranked.length + 1
+		});
+	}
+	return ranked;
+}
+/**
+* Fuse ranked thread lists by reciprocal rank fusion. A thread found by several lists sums its terms.
+*
+* The message a result names comes from the list that ranked the thread highest, the first list winning a
+* tie — the keyword list is passed first, so an exact match names the message that holds it.
+*/
+function fuse(lists) {
+	const fused = /* @__PURE__ */ new Map();
+	for (const list of lists) for (const entry of list) {
+		const term = 1 / (60 + entry.rank);
+		const known = fused.get(entry.threadId);
+		if (!known) {
+			fused.set(entry.threadId, {
+				threadId: entry.threadId,
+				messageId: entry.messageId,
+				fused: term,
+				best: entry.rank
+			});
+			continue;
+		}
+		known.fused += term;
+		if (entry.rank < known.best) {
+			known.best = entry.rank;
+			known.messageId = entry.messageId;
+		}
+	}
+	return [...fused.values()].map(({ threadId, messageId, fused: score }) => ({
+		threadId,
+		messageId,
+		fused: score
+	}));
+}
+/** Whether an error is SQLite saying the full-text index does not exist. */
+function isMissingSearchTable(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return message.includes("no such table") && message.includes("pithy_support_search");
+}
+/** A refusal for a mode this configuration cannot run. */
+function semanticOff(mode) {
+	return new ValidationError({
+		message: `Search mode \`${mode}\` needs semantic search, and \`search.semantic\` is off.`,
+		action: `Turn on \`search.semantic\` in support()'s config and run \`${pithyCommandOf("support provision", {}, { runtime: true })}\`, or search with \`mode=keyword\`.`,
+		detail: `mode ${mode} requested with search.semantic off`
+	});
+}
+/** Run a search. */
+async function searchThreads(deps, query) {
+	const semanticOn = deps.index !== void 0;
+	if ((query.mode === "semantic" || query.mode === "hybrid") && !semanticOn) throw semanticOff(query.mode);
+	const mode = query.mode ?? "hybrid";
+	const limit = Math.min(Math.max(query.limit ?? 20, 1), 50);
+	const ran = [];
+	const skipped = [];
+	const lists = [];
+	const keywordRank = /* @__PURE__ */ new Map();
+	const bm25 = /* @__PURE__ */ new Map();
+	const similarity = /* @__PURE__ */ new Map();
+	if (mode !== "semantic") {
+		let backend = deps.fts ? "fts" : "like";
+		let hits;
+		try {
+			hits = await keywordHits(deps.db, query.q, {
+				backend,
+				limit: 100
+			});
+		} catch (error) {
+			if (backend !== "fts" || !isMissingSearchTable(error)) throw error;
+			deps.log?.warn("support FTS index is configured but absent — searching with a LIKE scan", { action: `Run \`${pithyCommandOf("support provision", {}, { runtime: true })}\` to create and backfill it, or set \`search.fts: false\`.` });
+			skipped.push({
+				backend: "fts",
+				reason: "unprovisioned"
+			});
+			backend = "like";
+			hits = await keywordHits(deps.db, query.q, {
+				backend,
+				limit: 100
+			});
+		}
+		ran.push(backend);
+		if (backend === "fts") {
+			for (const hit of hits) if (hit.score !== void 0) bm25.set(hit.messageId, hit.score);
+		}
+		const keywordList = rollUp(hits);
+		for (const entry of keywordList) keywordRank.set(entry.threadId, entry.rank);
+		lists.push(keywordList);
+	}
+	if (mode !== "keyword" && deps.index) {
+		if (!deps.ai || !deps.store) {
+			deps.log?.warn("support semantic search is on but its index is not bound — skipping it", { action: `Run \`${pithyCommandOf("support provision", {}, { runtime: true })}\` to create the index and bind it.` });
+			skipped.push({
+				backend: "semantic",
+				reason: "unprovisioned"
+			});
+		} else try {
+			const hits = await semanticHits({
+				db: deps.db,
+				ai: deps.ai,
+				store: deps.store,
+				index: deps.index
+			}, query.q);
+			for (const hit of hits) if (hit.score !== void 0) similarity.set(hit.messageId, hit.score);
+			lists.push(rollUp(hits));
+			ran.push("semantic");
+		} catch (error) {
+			deps.log?.warn("support semantic search could not answer — skipping it", { detail: error instanceof Error ? error.message : String(error) });
+			skipped.push({
+				backend: "semantic",
+				reason: "failed"
+			});
+		}
+	}
+	const fused = fuse(lists);
+	const threads = await hydrate(deps.db, deps.viewer, fused.map((entry) => entry.threadId), query);
+	return {
+		mode,
+		ran,
+		skipped,
+		results: fused.flatMap((entry) => {
+			const thread = threads.get(entry.threadId);
+			return thread ? [{
+				entry,
+				thread
+			}] : [];
+		}).sort((a, b) => b.entry.fused - a.entry.fused || (keywordRank.get(a.entry.threadId) ?? Number.POSITIVE_INFINITY) - (keywordRank.get(b.entry.threadId) ?? Number.POSITIVE_INFINITY) || b.thread.lastMessageAt.getTime() - a.thread.lastMessageAt.getTime() || (a.thread.id < b.thread.id ? 1 : a.thread.id > b.thread.id ? -1 : 0)).slice(0, limit).map(({ entry, thread }) => {
+			const keyword = bm25.get(entry.messageId);
+			const near = similarity.get(entry.messageId);
+			return {
+				thread,
+				messageId: entry.messageId,
+				...keyword !== void 0 ? { bm25: keyword } : {},
+				...near !== void 0 ? { similarity: near } : {}
+			};
+		})
+	};
+}
+/** The filter values bind before the id list; this is the most a filtered read can bind besides it. */
+const HYDRATE_FIXED_PARAMETERS = 12;
+/** Read the candidate threads that pass the caller's filters, as this viewer sees them. */
+async function hydrate(db, viewer, threadIds, filters) {
+	const threads = /* @__PURE__ */ new Map();
+	if (threadIds.length === 0) return threads;
+	for (const group of chunkByBoundParameters(threadIds, HYDRATE_FIXED_PARAMETERS)) {
+		const rows = await applyThreadFilters(viewerThreads(db, viewer), filters).where(`${SUPPORT_THREADS_TABLE}.id`, "in", group).execute();
+		for (const row of rows) {
+			const thread = listedThreadOf(row);
+			threads.set(thread.id, thread);
+		}
+	}
+	return threads;
+}
+//#endregion
+export { RRF_K, SEARCH_HITS, fuse, rollUp, searchThreads };

package/dist/store/paging.d.ts

@@ -17,4 +17,14 @@
 export declare const DEFAULT_PAGE_SIZE = 25;
 /** The most a caller may ask for in one page. */
 export declare const MAX_PAGE_SIZE = 100;
+/**
+ * The search route's bounds. Here rather than in `store/hybrid.ts` for the reason the page bounds are:
+ * `http/schemas.ts` is a client's business and reaches no Kysely.
+ */
+/** How many threads a search returns by default. */
+export declare const DEFAULT_SEARCH_LIMIT = 20;
+/** The most a search returns. A ranked list's tail is noise; fifty is past where anyone reads. */
+export declare const MAX_SEARCH_LIMIT = 50;
+/** The longest search term accepted — it becomes a scan predicate and a model input. */
+export declare const MAX_SEARCH_TERM = 200;
 //# sourceMappingURL=paging.d.ts.map

package/dist/store/paging.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paging.d.ts","sourceRoot":"","sources":["../../src/store/paging.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AAEH,gDAAgD;AAChD,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAEpC,iDAAiD;AACjD,eAAO,MAAM,aAAa,MAAM,CAAC"}
+{"version":3,"file":"paging.d.ts","sourceRoot":"","sources":["../../src/store/paging.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AAEH,gDAAgD;AAChD,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAEpC,iDAAiD;AACjD,eAAO,MAAM,aAAa,MAAM,CAAC;AAEjC;;;GAGG;AAEH,oDAAoD;AACpD,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAEvC,kGAAkG;AAClG,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAEnC,wFAAwF;AACxF,eAAO,MAAM,eAAe,MAAM,CAAC"}

package/dist/store/paging.js

@@ -18,5 +18,15 @@
 const DEFAULT_PAGE_SIZE = 25;
 /** The most a caller may ask for in one page. */
 const MAX_PAGE_SIZE = 100;
+/**
+* The search route's bounds. Here rather than in `store/hybrid.ts` for the reason the page bounds are:
+* `http/schemas.ts` is a client's business and reaches no Kysely.
+*/
+/** How many threads a search returns by default. */
+const DEFAULT_SEARCH_LIMIT = 20;
+/** The most a search returns. A ranked list's tail is noise; fifty is past where anyone reads. */
+const MAX_SEARCH_LIMIT = 50;
+/** The longest search term accepted — it becomes a scan predicate and a model input. */
+const MAX_SEARCH_TERM = 200;
 //#endregion
-export { DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE };
+export { DEFAULT_PAGE_SIZE, DEFAULT_SEARCH_LIMIT, MAX_PAGE_SIZE, MAX_SEARCH_LIMIT, MAX_SEARCH_TERM };

package/dist/store/provisionIndex.d.ts

@@ -0,0 +1,21 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+import type { D1Database } from "@cloudflare/workers-types";
+import { type SearchIndexAction } from "./searchIndex";
+/**
+ * **Bring one database's full-text index into line with `search.fts`, and say what that took.**
+ *
+ * The body of `pithy support provision`'s search step, and of `pithy restore`'s rebuild of the index a
+ * backup leaves out (#848). One function for both, because the two have to agree: a restore that rebuilt
+ * the index some other way would be a second definition of a provisioned index, and the first time the
+ * triggers changed it would restore the old ones.
+ *
+ * It reads `sqlite_master` for the table and its triggers, decides with {@link searchIndexAction}, and
+ * applies the decision. A create and a repair backfill from `pithy_support_messages` straight away: an
+ * index that exists and is empty answers "no matches" for a word plainly in a message, because the `LIKE`
+ * fallback only fires while the table is absent. A drop takes the triggers first, then the table.
+ *
+ * Every statement is idempotent, so a re-run is a no-op that answers `none`.
+ */
+export declare function provisionSearchIndex(database: D1Database, wanted: boolean): Promise<SearchIndexAction>;
+//# sourceMappingURL=provisionIndex.d.ts.map

package/dist/store/provisionIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provisionIndex.d.ts","sourceRoot":"","sources":["../../src/store/provisionIndex.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAG5D,OAAO,EAIL,KAAK,iBAAiB,EAGvB,MAAM,eAAe,CAAC;AAEvB;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,oBAAoB,CAAC,QAAQ,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAe5G"}

package/dist/store/provisionIndex.js

@@ -0,0 +1,36 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+import { supportDatabase } from "../data/tables.js";
+import { reindexAll } from "./search.js";
+import { SEARCH_OBJECTS, createSearchIndex, dropSearchIndex, searchIndexAction, searchIndexState } from "./searchIndex.js";
+//#region src/store/provisionIndex.ts
+/**
+* **Bring one database's full-text index into line with `search.fts`, and say what that took.**
+*
+* The body of `pithy support provision`'s search step, and of `pithy restore`'s rebuild of the index a
+* backup leaves out (#848). One function for both, because the two have to agree: a restore that rebuilt
+* the index some other way would be a second definition of a provisioned index, and the first time the
+* triggers changed it would restore the old ones.
+*
+* It reads `sqlite_master` for the table and its triggers, decides with {@link searchIndexAction}, and
+* applies the decision. A create and a repair backfill from `pithy_support_messages` straight away: an
+* index that exists and is empty answers "no matches" for a word plainly in a message, because the `LIKE`
+* fallback only fires while the table is absent. A drop takes the triggers first, then the table.
+*
+* Every statement is idempotent, so a re-run is a no-op that answers `none`.
+*/
+async function provisionSearchIndex(database, wanted) {
+	const listed = await database.prepare(`SELECT name FROM sqlite_master WHERE name IN (${SEARCH_OBJECTS.map(() => "?").join(", ")})`).bind(...SEARCH_OBJECTS).all();
+	const action = searchIndexAction(searchIndexState((listed.results ?? []).map((row) => row.name)), wanted);
+	if (action === "none") return action;
+	const db = supportDatabase(database);
+	if (action === "drop") {
+		await dropSearchIndex(db);
+		return action;
+	}
+	await createSearchIndex(db);
+	await reindexAll(db);
+	return action;
+}
+//#endregion
+export { provisionSearchIndex };

package/dist/store/search.d.ts

@@ -1,6 +1,5 @@
 // SPDX-FileCopyrightText: 2026 Pithy
 // SPDX-License-Identifier: MIT
-import { type Expression, type SqlBool } from "kysely";
 import { type SupportDatabase } from "../data/tables";
 /**
  * Turn a user's words into an FTS5 MATCH expression.
@@ -12,17 +11,27 @@ import { type SupportDatabase } from "../data/tables";
  * of the package applies to model output and to HTML.
  */
 export declare function ftsQuery(term: string): string;
-/** Whether a term has anything searchable left after tokenizing. */
-export declare function isSearchable(term: string, fts: boolean): boolean;
+/** One message a backend matched, in rank order. */
+export interface MessageHit {
+    /** The message. */
+    messageId: string;
+    /** Its thread. */
+    threadId: string;
+    /** The backend's own score for it, raw — `bm25` for FTS5, similarity for Vectorize, none for `LIKE`. */
+    score?: number;
+}
+/** Which keyword backend answered. */
+export type KeywordBackend = "fts" | "like";
 /**
- * A predicate matching threads whose messages contain `term`.
+ * The messages matching `term`, best first, at most `limit` of them.
  *
- * Correlated on the thread id so it drops into a `where` beside every other filter. The subquery is
- * `exists`, so it stops at the first matching message rather than counting them.
+ * A term that tokenizes to nothing — `???`, `@@@` — asked a question with no answer, and the honest answer
+ * is none: never the whole inbox rendered as search results.
  */
-export declare function searchPredicate(term: string, options: {
-    fts: boolean;
-}): Expression<SqlBool>;
+export declare function keywordHits(db: SupportDatabase, term: string, options: {
+    backend: KeywordBackend;
+    limit: number;
+}): Promise<MessageHit[]>;
 /**
  * Add a message to the full-text index, replacing any row already there for it.
  *

package/dist/store/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/store/search.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,OAAO,EAAO,MAAM,QAAQ,CAAC;AAC5D,OAAO,EAA0B,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AA+B9E;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAS7C;AAED,oEAAoE;AACpE,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,GAAG,OAAO,CAEhE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE;IAAE,GAAG,EAAE,OAAO,CAAA;CAAE,GAAG,UAAU,CAAC,OAAO,CAAC,CAkB5F;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,YAAY,CAChC,EAAE,EAAE,eAAe,EACnB,KAAK,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC5E,OAAO,CAAC,IAAI,CAAC,CAMf;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,EAAE,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAkB1F;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,UAAU,CAC9B,EAAE,EAAE,eAAe,EACnB,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAAO,GAC1E,OAAO,CAAC,MAAM,CAAC,CA4CjB"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/store/search.ts"],"names":[],"mappings":"AAIA,OAAO,EAA0B,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AA0B9E;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAS7C;AAED,oDAAoD;AACpD,MAAM,WAAW,UAAU;IACzB,mBAAmB;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,kBAAkB;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,wGAAwG;IACxG,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,sCAAsC;AACtC,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,MAAM,CAAC;AAE5C;;;;;GAKG;AACH,wBAAsB,WAAW,CAC/B,EAAE,EAAE,eAAe,EACnB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE;IAAE,OAAO,EAAE,cAAc,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAClD,OAAO,CAAC,UAAU,EAAE,CAAC,CAgCvB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,YAAY,CAChC,EAAE,EAAE,eAAe,EACnB,KAAK,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC5E,OAAO,CAAC,IAAI,CAAC,CAMf;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,EAAE,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAkB1F;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,UAAU,CAC9B,EAAE,EAAE,eAAe,EACnB,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAAO,GAC1E,OAAO,CAAC,MAAM,CAAC,CA4CjB"}

package/dist/store/search.js

@@ -4,24 +4,19 @@ import { SUPPORT_MESSAGES_TABLE } from "../data/tables.js";
 import { sql } from "kysely";
 //#region src/store/search.ts
 /**
-* Text search over the inbox — two backends behind one predicate.
+* Keyword retrieval over the inbox — two backends behind one call.
 *
-* **`LIKE` is the default and FTS5 is the opt-in**, which is the opposite of what it looks like it
-* should be. The reason is in `store/searchIndex.ts`: an FTS5 virtual table anywhere in a D1
-* database makes `wrangler d1 export` refuse to dump *the whole database*, so turning it on by
-* default would quietly cost every adopter their backup story for tables that have nothing to do
-* with support. `LIKE` is an unindexed scan and is completely adequate for an inbox measured in
-* thousands of messages, which is what this capability is for.
+* **FTS5 is the default and `LIKE` is the fallback.** The index lives in a virtual table that
+* `pithy support provision` creates beside its triggers, so a project that has not provisioned it — or
+* that set `search.fts: false` — searches with an unindexed `LIKE` scan, which is adequate for an inbox
+* measured in thousands of messages. `pithy backup` leaves the index out and `pithy restore` rebuilds it.
 *
-* Both paths return a **predicate over `pithy_support_threads`**, not a list of ids, so search
-* composes with the category/archived filters and — crucially — with cursor pagination. Returning
-* ids would mean either capping the match set (silent truncation, which reads as "that is all there
-* is") or paginating twice over.
+* **Both return messages, ranked, not threads.** A thread is scored by its best-matching message, and the
+* keyword half is fused with the semantic half by rank position in `store/hybrid.ts`. FTS5 ranks by `bm25`,
+* which is reported raw. `LIKE` has no score, so its matches rank by recency, newest first.
 *
-* Either way this is keyword search, deliberately. People search a support inbox for a word they
-* remember — an order number, an error string, a surname — not for a concept. `@pithy-sh/vector` is
-* there for anyone who wants meaning-matching, and it is the nicer demo and the wrong default: it
-* cannot find `ORD-40912`.
+* Keyword search is first-class beside semantic search: people search a support inbox for a word they
+* remember — an order number, an error string, a surname — and semantic search cannot find `ORD-40912`.
 */
 /** The longest search term accepted. Bounded because it becomes a scan predicate. */
 const MAX_TERM = 200;
@@ -41,28 +36,35 @@ function escapeLike(term) {
 function ftsQuery(term) {
 	return term.slice(0, MAX_TERM).split(/[^\p{L}\p{N}_-]+/u).filter((token) => token.length > 0).slice(0, 16).map((token) => `"${token.replace(/"/g, "\"\"")}"`).join(" AND ");
 }
-/** Whether a term has anything searchable left after tokenizing. */
-function isSearchable(term, fts) {
-	return fts ? ftsQuery(term).length > 0 : term.trim().length > 0;
-}
 /**
-* A predicate matching threads whose messages contain `term`.
+* The messages matching `term`, best first, at most `limit` of them.
 *
-* Correlated on the thread id so it drops into a `where` beside every other filter. The subquery is
-* `exists`, so it stops at the first matching message rather than counting them.
+* A term that tokenizes to nothing — `???`, `@@@` — asked a question with no answer, and the honest answer
+* is none: never the whole inbox rendered as search results.
 */
-function searchPredicate(term, options) {
-	if (options.fts) return sql`exists (
-      select 1 from pithy_support_search
-      where pithy_support_search.thread_id = pithy_support_threads.id
-        and pithy_support_search match ${ftsQuery(term)}
-    )`;
+async function keywordHits(db, term, options) {
+	if (options.backend === "fts") {
+		const match = ftsQuery(term);
+		if (match.length === 0) return [];
+		const { rows } = await sql`
+      select message_id as "messageId", thread_id as "threadId", bm25(pithy_support_search) as "score"
+      from pithy_support_search
+      where pithy_support_search match ${match}
+      order by "score" asc
+      limit ${options.limit}
+    `.execute(db);
+		return rows.map((row) => ({
+			messageId: row.messageId,
+			threadId: row.threadId,
+			score: Number(row.score)
+		}));
+	}
+	if (term.trim().length === 0) return [];
 	const pattern = `%${escapeLike(term.slice(0, MAX_TERM))}%`;
-	return sql`exists (
-    select 1 from pithy_support_messages m
-    where m.thread_id = pithy_support_threads.id
-      and (m.subject like ${pattern} escape '\\' or m.text_body like ${pattern} escape '\\')
-  )`;
+	return (await db.selectFrom(SUPPORT_MESSAGES_TABLE).select(["id", "threadId"]).where((eb) => eb.or([sql`${eb.ref("subject")} like ${pattern} escape '\\'`, sql`${eb.ref("textBody")} like ${pattern} escape '\\'`])).orderBy("receivedAt", "desc").orderBy("id", "desc").limit(options.limit).execute()).map((row) => ({
+		messageId: row.id,
+		threadId: row.threadId
+	}));
 }
 /**
 * Add a message to the full-text index, replacing any row already there for it.
@@ -166,4 +168,4 @@ async function reindexAll(db, options = {}) {
 	return indexed;
 }
 //#endregion
-export { ftsQuery, indexMessage, isSearchable, reindexAll, reindexThread, searchPredicate };
+export { ftsQuery, indexMessage, keywordHits, reindexAll, reindexThread };

package/dist/store/searchIndex.d.ts

@@ -129,10 +129,10 @@ export declare function searchIndexAction(state: SearchIndexState, wanted: boole
 /**
  * The `CREATE TRIGGER` statements, one per {@link SEARCH_TRIGGERS} entry and in that order.
  *
- * **`BEGIN` and `END` are uppercase, and that is load-bearing.** Miniflare accepts a lowercase
- * compound-statement body; remote D1 rejects it as `incomplete input [code: 7500]`, so a lowercased
- * body passes every local test in this repository and fails on deploy. `searchIndex.test.ts` fails on
- * the lowercase form, because no Workers test can.
+ * **`BEGIN` and `END` are uppercase, by convention.** Remote D1 and Miniflare both accept a lowercase
+ * compound-statement body today, so nothing enforces the casing at run time. Older D1 rejected the
+ * lowercase form as `incomplete input [code: 7500]`, and uppercase is accepted everywhere, so the bodies
+ * keep it and `searchIndex.test.ts` pins it.
  *
  * **Every column is the physical snake_case name.** `CamelCasePlugin` snake-cases the identifiers the
  * query builder emits and never touches a string inside a `sql` template, so this is the one place in

package/dist/store/searchIndex.js

@@ -127,10 +127,10 @@ function searchIndexAction(state, wanted) {
 /**
 * The `CREATE TRIGGER` statements, one per {@link SEARCH_TRIGGERS} entry and in that order.
 *
-* **`BEGIN` and `END` are uppercase, and that is load-bearing.** Miniflare accepts a lowercase
-* compound-statement body; remote D1 rejects it as `incomplete input [code: 7500]`, so a lowercased
-* body passes every local test in this repository and fails on deploy. `searchIndex.test.ts` fails on
-* the lowercase form, because no Workers test can.
+* **`BEGIN` and `END` are uppercase, by convention.** Remote D1 and Miniflare both accept a lowercase
+* compound-statement body today, so nothing enforces the casing at run time. Older D1 rejected the
+* lowercase form as `incomplete input [code: 7500]`, and uppercase is accepted everywhere, so the bodies
+* keep it and `searchIndex.test.ts` pins it.
 *
 * **Every column is the physical snake_case name.** `CamelCasePlugin` snake-cases the identifiers the
 * query builder emits and never touches a string inside a `sql` template, so this is the one place in