@coywolf/emdash 0.0.0-stage → 0.35.13

package/src/search/live-serve.ts

@@ -0,0 +1,282 @@
+/**
+ * Live results and the title index, served by the pack middleware (feature
+ * "search.live") ahead of EmDash's plugin route dispatch, with Cloudflare's
+ * Cache API in front.
+ *
+ * Worker responses aren't cached by the CDN on their own, so every answer is
+ * stored in caches.default (per Cloudflare location) and in a small
+ * per-isolate memory cache, keyed by the normalized query, limit,
+ * collections, locale and the search content version. Publishing changes the
+ * version, so new keys miss and old answers simply expire. Cache hits skip
+ * the rate limit and the database entirely; misses count against
+ * search.rateLimit when it's on.
+ *
+ * The plugin routes (search/live, search/index) stay as the fallback for
+ * sites without the middleware; they run the same engine.
+ */
+import { contentUrlFingerprint } from "../core/content-url.js";
+import { isOn, registerSiteSetting, rememberSiteSetting, siteFeatures, siteSetting } from "../core/features.js";
+import type { PackMiddleware } from "../core/module.js";
+import { keepAtEdge, keepOffEdge } from "../pageCache/lib.js";
+import { type QueryStats, countingD1, liveSearchD1, loadSearchMeta } from "./engine.js";
+import { Lru, effectiveVersion, fingerprint, indexCacheKey, liveCacheKey, newContentVersion, normalizeCollections, normalizeLiveQuery, normalizeLocale } from "./live-cache.js";
+import { LIVE_ASSET, LIVE_ASSET_HASH, type LiveClientConfig, liveScript, liveScriptConfig } from "./live-client.js";
+import { rateLimitResponse } from "./ratelimit.js";
+import { TITLE_INDEX_MAX, buildTitleIndex } from "./title-index.js";
+
+export const LIVE_ENDPOINT = "/_emdash/api/plugins/coywolf-pack/search/live";
+export const INDEX_ENDPOINT = "/_emdash/api/plugins/coywolf-pack/search/index";
+
+/** Plugin setting holding the search content version. */
+export const VERSION_SETTING = "searchVersion";
+registerSiteSetting(VERSION_SETTING);
+
+/** Seconds a live answer is kept at the edge (the version in its key retires it sooner after a publish). */
+export const LIVE_EDGE_TTL = 300;
+/** Seconds browsers keep a live answer. */
+export const LIVE_BROWSER_TTL = 60;
+/** Seconds a title index is kept at the edge. */
+const INDEX_EDGE_TTL = 86_400;
+
+interface LiveServeConfig {
+	database: string;
+	limit: number;
+	indexMax: number;
+}
+
+let config: LiveServeConfig = { database: "DB", limit: 8, indexMax: TITLE_INDEX_MAX };
+
+/** Set from coywolfPlugin({ search }) when the Worker starts (same pattern as the rate limit options). */
+export function configureSearchLive(options: Partial<LiveServeConfig>): void {
+	config = { ...config, ...Object.fromEntries(Object.entries(options).filter(([, v]) => v !== undefined)) };
+}
+
+export function liveServeConfig(): LiveServeConfig {
+	return config;
+}
+
+/** The current search content version (from the per-isolate settings cache; no query on most requests). */
+export async function searchVersion(database = config.database): Promise<string> {
+	return effectiveVersion(await siteSetting<string>(VERSION_SETTING, database), contentUrlFingerprint());
+}
+
+/** Give published content a new version (content hooks, search settings changes). */
+export async function bumpSearchVersion(ctx: { settings: { set(key: string, value: unknown): Promise<void> } }): Promise<string> {
+	const version = newContentVersion();
+	await ctx.settings.set(VERSION_SETTING, version);
+	rememberSiteSetting(VERSION_SETTING, version);
+	return version;
+}
+
+let liveMemory = new Lru<string>(500);
+let indexMemory = new Lru<string>(4);
+
+/** Empty this isolate's memory caches (tests; the edge cache is untouched). */
+export function resetLiveMemory(): void {
+	liveMemory = new Lru<string>(500);
+	indexMemory = new Lru<string>(4);
+}
+
+const JSON_TYPE = "application/json; charset=utf-8";
+
+function edgeCache(): Cache | undefined {
+	return (globalThis as unknown as { caches?: { default?: Cache } }).caches?.default;
+}
+
+function timing(state: string, started: number, stats?: QueryStats): string {
+	const parts = [`cw-search;desc="${state}";dur=${Date.now() - started}`];
+	if (stats) parts.push(`cw-d1;desc="${stats.statements} statements, ${stats.roundTrips} round trips"`);
+	return parts.join(", ");
+}
+
+/** A fresh response with mutable headers (cached responses' headers are immutable, and later middleware may set some). */
+function jsonResponse(body: string | null, status: number, headers: Record<string, string>): Response {
+	return new Response(body, { status, headers: new Headers({ "Content-Type": JSON_TYPE, "X-Content-Type-Options": "nosniff", ...headers }) });
+}
+
+function badRequest(message: string): Response {
+	return jsonResponse(JSON.stringify({ success: false, error: { code: "VALIDATION_ERROR", message } }), 400, { "Cache-Control": "no-store" });
+}
+
+/** Text of a cached answer: this isolate's memory, then the edge cache. */
+async function cachedBody(memory: Lru<string>, key: string): Promise<{ body: string; where: string } | null> {
+	const inMemory = memory.get(key);
+	if (inMemory !== undefined) return { body: inMemory, where: "hit-memory" };
+	const cache = edgeCache();
+	const hit = cache ? await cache.match(key).catch(() => undefined) : undefined;
+	if (!hit) return null;
+	const body = await hit.text();
+	memory.set(key, body);
+	return { body, where: "hit-edge" };
+}
+
+function store(memory: Lru<string>, key: string, body: string, edgeTtl: number, waitUntil: (p: Promise<unknown>) => void): void {
+	memory.set(key, body);
+	const cache = edgeCache();
+	if (cache) waitUntil(cache.put(key, new Response(body, { headers: { "Content-Type": JSON_TYPE, "Cache-Control": `public, max-age=${edgeTtl}` } })).catch(() => undefined));
+}
+
+type Context = Parameters<PackMiddleware["handle"]>[0];
+
+async function rateLimited(context: Context, env: Record<string, unknown>): Promise<Response | undefined> {
+	return isOn(await siteFeatures(config.database), "search.rateLimit") ? rateLimitResponse(context, env) : undefined;
+}
+
+async function serveLive(context: Context, env: Record<string, unknown>, waitUntil: (p: Promise<unknown>) => void, db: D1Database): Promise<Response> {
+	const started = Date.now();
+	const params = context.url.searchParams;
+	const version = await searchVersion();
+
+	// Warm-up (first focus of a search field): wake this isolate and load the search metadata, nothing else.
+	if (params.get("warm") === "1") {
+		const stats: QueryStats = { statements: 0, roundTrips: 0 };
+		await loadSearchMeta(countingD1(db, stats), config.database, version).catch(() => undefined);
+		return new Response(null, { status: 204, headers: new Headers({ "Cache-Control": "no-store", "Server-Timing": timing("warm", started, stats) }) });
+	}
+
+	const query = normalizeLiveQuery(params.get("q") ?? "");
+	if (!query) return badRequest("Enter a search.");
+	if (query.length > 200) return badRequest("That search is too long.");
+	const rawLimit = params.get("limit");
+	const limit = rawLimit === null || rawLimit === "" ? config.limit : Number(rawLimit);
+	if (!Number.isInteger(limit) || limit < 1 || limit > 20) return badRequest("Limit must be a whole number from 1 to 20.");
+	const rawCollections = params.get("collections");
+	if (rawCollections && rawCollections.length > 500) return badRequest("Too many collections.");
+	const collections = normalizeCollections(rawCollections);
+	const locale = normalizeLocale(params.get("locale"));
+
+	const key = liveCacheKey(context.url.origin, { version, query, limit, collections, locale });
+	const browser = { "Cache-Control": `public, max-age=${LIVE_BROWSER_TTL}` };
+	const hit = await cachedBody(liveMemory, key);
+	if (hit) return jsonResponse(hit.body, 200, { ...browser, "Server-Timing": timing(hit.where, started), "X-Coywolf-Cache": "HIT" });
+
+	const limited = await rateLimited(context, env);
+	if (limited) return limited;
+
+	const stats: QueryStats = { statements: 0, roundTrips: 0 };
+	const data = await liveSearchD1(countingD1(db, stats), query, { collections, locale, limit, database: config.database, version });
+	const body = JSON.stringify({ success: true, data });
+	store(liveMemory, key, body, LIVE_EDGE_TTL, waitUntil);
+	return jsonResponse(body, 200, { ...browser, "Server-Timing": timing("miss", started, stats), "X-Coywolf-Cache": "MISS" });
+}
+
+async function serveIndex(context: Context, env: Record<string, unknown>, waitUntil: (p: Promise<unknown>) => void, db: D1Database): Promise<Response> {
+	const started = Date.now();
+	const params = context.url.searchParams;
+	const version = await searchVersion();
+	const rawCollections = params.get("collections");
+	if (rawCollections && rawCollections.length > 500) return badRequest("Too many collections.");
+	const collections = normalizeCollections(rawCollections);
+	const locale = normalizeLocale(params.get("locale"));
+	const key = indexCacheKey(context.url.origin, { version, collections, locale });
+
+	// Pages carry the version in the index URL: a matching one never changes, so browsers keep it.
+	// A stale page (an old version) still gets the current index, just not for long.
+	const headers = {
+		"Cache-Control": params.get("v") === version ? "public, max-age=31536000, immutable" : "public, max-age=300",
+		ETag: `"${fingerprint(key)}"`,
+	};
+	if (context.request.headers.get("If-None-Match") === headers.ETag) return new Response(null, { status: 304, headers: new Headers(headers) });
+
+	const hit = await cachedBody(indexMemory, key);
+	if (hit) return jsonResponse(hit.body, 200, { ...headers, "Server-Timing": timing(hit.where, started), "X-Coywolf-Cache": "HIT" });
+
+	const limited = await rateLimited(context, env);
+	if (limited) return limited;
+
+	const stats: QueryStats = { statements: 0, roundTrips: 0 };
+	const counted = countingD1(db, stats);
+	const meta = await loadSearchMeta(counted, config.database, version);
+	const index = await buildTitleIndex(counted, meta, { collections, locale, version, max: config.indexMax });
+	const body = JSON.stringify(index);
+	store(indexMemory, key, body, INDEX_EDGE_TTL, waitUntil);
+	return jsonResponse(body, 200, { ...headers, "Server-Timing": timing("miss", started, stats), "X-Coywolf-Cache": "MISS" });
+}
+
+/**
+ * The live results client as a file. Only the pack middleware serves it: EmDash's
+ * raw plugin routes can't answer with a JavaScript content type or set
+ * Cache-Control, so sites without the middleware get the script inline instead
+ * (liveScriptFragment).
+ */
+export const ASSET_ENDPOINT = "/_emdash/api/plugins/coywolf-pack/search/live-client";
+
+/**
+ * Per isolate: the pack middleware has run here. It runs before every page
+ * render on a site that installed it, so by the time a page asks for its
+ * fragments this is set when (and only when) the middleware will answer
+ * ASSET_ENDPOINT. A site without it (or a dev setup with a second copy of the
+ * pack) never sets it and keeps the inline script.
+ */
+let middlewareActive = false;
+
+/** Called by the pack middleware on each request it handles (false: tests). */
+export function notePackMiddleware(active = true): void {
+	middlewareActive = active;
+}
+
+/** Whether pages can load the client file, i.e. the pack middleware serves it (see notePackMiddleware). */
+export function packMiddlewareActive(): boolean {
+	return middlewareActive;
+}
+
+/**
+ * The page fragment for live results: the versioned client file when the pack
+ * middleware serves it, else the same client inline (as before the file existed).
+ */
+export function liveScriptFragment(config: LiveClientConfig, external = middlewareActive) {
+	return external
+		? {
+				kind: "external-script" as const,
+				placement: "body:end" as const,
+				key: "search-live",
+				src: liveAssetUrl(),
+				defer: true,
+				attributes: { "data-cw-live": liveScriptConfig(config) },
+			}
+		: { kind: "inline-script" as const, placement: "body:end" as const, key: "search-live", code: liveScript(config) };
+}
+
+/** Where pages load the client from: versioned, so it can be cached for a year. */
+export function liveAssetUrl(): string {
+	return `${ASSET_ENDPOINT}?v=${LIVE_ASSET_HASH}`;
+}
+
+/**
+ * Status, headers and body for the client file. Immutable for a year when the
+ * request names the current version; a few minutes otherwise (an old page's
+ * URL still gets today's client, but nothing pins it).
+ */
+export function liveAssetParts(version: string | null): { status: number; headers: Record<string, string>; body: string } {
+	return {
+		status: 200,
+		headers: {
+			"Content-Type": "text/javascript; charset=utf-8",
+			"X-Content-Type-Options": "nosniff",
+			"Cache-Control": version === LIVE_ASSET_HASH ? "public, max-age=31536000, immutable" : "public, max-age=300",
+		},
+		body: LIVE_ASSET,
+	};
+}
+
+export const searchLiveMiddleware: PackMiddleware = {
+	module: "search",
+	feature: "search.live",
+	// The client file goes to the edge cache (a year when the URL names this version); live results use their own cache.
+	ownsCache: true,
+	handle: async (context, env, waitUntil) => {
+		const path = context.url.pathname.length > 1 ? context.url.pathname.replace(/\/+$/, "") : context.url.pathname;
+		if (path === ASSET_ENDPOINT && (context.request.method === "GET" || context.request.method === "HEAD")) {
+			const version = context.url.searchParams.get("v");
+			const asset = liveAssetParts(version);
+			keepAtEdge(context, version === LIVE_ASSET_HASH ? 31536000 : 300);
+			return new Response(context.request.method === "HEAD" ? null : asset.body, { status: asset.status, headers: asset.headers });
+		}
+		if (path !== LIVE_ENDPOINT && path !== INDEX_ENDPOINT) return undefined;
+		keepOffEdge(context);
+		if (context.request.method !== "GET") return undefined;
+		const db = env[config.database] as D1Database | undefined;
+		if (!db) return undefined;
+		return path === LIVE_ENDPOINT ? serveLive(context, env, waitUntil, db) : serveIndex(context, env, waitUntil, db);
+	},
+};

package/src/search/module.ts

@@ -0,0 +1,261 @@
+/**
+ * Search module routes.
+ *
+ * - search/query (public): EmDash search with an OR fallback, title-first
+ *   suggestions, and resolved URLs.
+ * - search/live (public): live results for the as-you-type dropdown
+ *   (feature "search.live"): title matches, then full text, each with a
+ *   highlighted excerpt. Backs the live results script (injected on every
+ *   page by the page:fragments hook below) and the SearchBox. With the pack
+ *   middleware installed, live-serve.ts answers this path first, from the
+ *   edge cache when it can; this route is the fallback.
+ * - search/index (public): the title index for instant results in the
+ *   browser (title-index.ts), likewise served by the middleware first.
+ * - search/touch (admin): a new search content version, after search
+ *   settings change (the Search admin page calls it), so cached answers and
+ *   title indexes are rebuilt.
+ * - search/config (admin): each collection's search configuration and
+ *   fields, read-only, for the Search admin page. The page changes settings
+ *   through EmDash's own /_emdash/api/search/{enable,rebuild,stats}
+ *   endpoints, so EmDash's permission checks (search:manage) apply.
+ */
+import { type PluginContext, PluginRouteError, definePluginRoute } from "emdash";
+import { z } from "zod";
+
+import { requireCachedFeature, requireFeature } from "../core/features.js";
+import { COLLECTION_SLUG, readCollections } from "../core/content-url.js";
+import { parseInput, workerEnv } from "../shared.js";
+import { liveSearchD1, loadSearchMeta } from "./engine.js";
+import { normalizeCollections, normalizeLiveQuery, normalizeLocale } from "./live-cache.js";
+import { INDEX_ENDPOINT, LIVE_ENDPOINT, bumpSearchVersion, configureSearchLive, liveScriptFragment, searchVersion } from "./live-serve.js";
+import { searchWithFallback } from "./query.js";
+import { TITLE_INDEX_MAX, buildTitleIndex } from "./title-index.js";
+
+export { INDEX_ENDPOINT, LIVE_ENDPOINT };
+
+export interface SearchOptions {
+	/** D1 binding of the site database. Default "DB". */
+	database?: string;
+	/** Requests per minute per visitor for search.rateLimit's in-memory fallback. Default 120; 0 turns it off. */
+	requestsPerMinute?: number;
+	/** Workers Rate Limiting binding name for search.rateLimit. Default none (per-isolate memory only). */
+	rateLimiter?: string;
+	/** Live results dropdown (feature "search.live") on the site's search forms. */
+	live?: LiveOptions;
+}
+
+export interface LiveOptions {
+	/** Results in the dropdown. Default 8 (1–20). */
+	limit?: number;
+	/** Characters typed before results show. Default 2. */
+	minChars?: number;
+	/** Milliseconds to wait after the last keystroke before asking the server. Default 120 (title matches show at once). */
+	debounce?: number;
+	/** Instant title matches from a title index loaded in the browser on first focus. Default true. */
+	instant?: boolean;
+	/** Most entries in the title index (newest kept). Default 5000. */
+	indexMax?: number;
+	/** Select the first result as results appear, so Enter opens it (Enter otherwise submits the form). Default true. */
+	enterOpensTop?: boolean;
+}
+
+const clampInt = (value: number | undefined, min: number, max: number, fallback: number) =>
+	typeof value === "number" && Number.isFinite(value) ? Math.min(max, Math.max(min, Math.round(value))) : fallback;
+
+/** Most collections one search may name. */
+const MAX_COLLECTIONS = 10;
+
+const liveInput = z.object({
+	q: z.string().trim().min(1, "Enter a search.").max(200, "That search is too long."),
+	collections: z.string().max(500).optional(),
+	locale: z.string().max(35).optional(),
+	limit: z.coerce.number().int().min(1).max(20).optional(),
+});
+
+const indexInput = z.object({
+	collections: z.string().max(500).optional(),
+	locale: z.string().max(35).optional(),
+});
+
+const queryInput = z.object({
+	q: z.string().trim().min(1, "Enter a search.").max(200, "That search is too long."),
+	mode: z.enum(["search", "suggest"]).optional(),
+	collections: z.string().max(500).optional(),
+	locale: z.string().max(35).optional(),
+	limit: z.coerce.number().int().min(1).max(20).optional(),
+	cursor: z.string().max(500).optional(),
+});
+
+interface CollectionRow {
+	id: string;
+	slug: string;
+	label: string;
+	search_config: string | null;
+	title_field: string | null;
+}
+
+interface FieldRow {
+	collection_id: string;
+	slug: string;
+	label: string;
+	type: string;
+	searchable: number;
+}
+
+export function searchModule(options: SearchOptions) {
+	const database = options.database ?? "DB";
+	const live = {
+		endpoint: LIVE_ENDPOINT,
+		limit: clampInt(options.live?.limit, 1, 20, 8),
+		minChars: clampInt(options.live?.minChars, 1, 20, 2),
+		debounce: clampInt(options.live?.debounce, 0, 2000, 120),
+		enterOpensTop: options.live?.enterOpensTop ?? true,
+	};
+	const instant = options.live?.instant ?? true;
+	const indexMax = clampInt(options.live?.indexMax, 1, 20_000, TITLE_INDEX_MAX);
+	configureSearchLive({ database, limit: live.limit, indexMax });
+
+	/** Only collections that exist; asking for nothing real finds nothing rather than everything. Undefined means all. */
+	async function knownCollections(list: string | undefined): Promise<string[] | undefined> {
+		if (!list) return undefined;
+		const requested = [...new Set(list.split(",").map((c) => c.trim()))].filter((c) => COLLECTION_SLUG.test(c)).slice(0, MAX_COLLECTIONS);
+		const known = requested.length ? await readCollections(await db(), requested) : new Map();
+		return requested.filter((c) => known.has(c));
+	}
+
+	async function db() {
+		const env = await workerEnv();
+		const d1 = env[database] as D1Database | undefined;
+		if (!d1) throw PluginRouteError.badRequest("Search: missing database binding.");
+		return d1;
+	}
+
+	const routes = {
+		"search/query": definePluginRoute({
+			public: true,
+			methods: ["GET"],
+			request: { body: "none" },
+			cacheControl: "public, max-age=60",
+			handler: async (ctx) => {
+				await requireFeature(ctx, "search.box");
+				const input = parseInput(queryInput, ctx.input);
+				const collections = await knownCollections(input.collections);
+				if (collections && !collections.length) return { items: [], fallback: false };
+				return searchWithFallback(input.q, {
+					mode: input.mode,
+					collections,
+					locale: input.locale,
+					limit: input.limit ?? 8,
+					cursor: input.cursor,
+					database,
+				});
+			},
+		}),
+
+		"search/live": definePluginRoute({
+			public: true,
+			methods: ["GET"],
+			request: { body: "none" },
+			// Published content only, the same for every visitor; a minute keeps a burst of identical keystrokes cheap.
+			cacheControl: "public, max-age=60",
+			handler: async (ctx) => {
+				await requireCachedFeature(ctx, "search.live");
+				const raw = (ctx.input ?? {}) as Record<string, unknown>;
+				const version = await searchVersion(database);
+				if (raw.warm === "1") {
+					await loadSearchMeta(await db(), database, version).catch(() => undefined);
+					return { items: [], fallback: false };
+				}
+				const input = parseInput(liveInput, raw);
+				return liveSearchD1(await db(), normalizeLiveQuery(input.q), {
+					collections: normalizeCollections(input.collections),
+					locale: normalizeLocale(input.locale),
+					limit: input.limit ?? live.limit,
+					database,
+					version,
+				});
+			},
+		}),
+
+		"search/index": definePluginRoute({
+			public: true,
+			methods: ["GET"],
+			request: { body: "none" },
+			cacheControl: "public, max-age=300",
+			handler: async (ctx) => {
+				await requireCachedFeature(ctx, "search.live");
+				const input = parseInput(indexInput, ctx.input ?? {});
+				const version = await searchVersion(database);
+				const d1 = await db();
+				const meta = await loadSearchMeta(d1, database, version);
+				return buildTitleIndex(d1, meta, { collections: normalizeCollections(input.collections), locale: normalizeLocale(input.locale), version, max: indexMax });
+			},
+		}),
+
+		"search/touch": definePluginRoute({
+			permission: "search:manage",
+			methods: ["POST"],
+			request: { body: "none" },
+			handler: async (ctx) => {
+				await requireFeature(ctx, "search");
+				return { version: await bumpSearchVersion(ctx) };
+			},
+		}),
+
+		"search/config": {
+			permission: "search:manage" as const,
+			handler: async (ctx: Parameters<typeof requireFeature>[0]) => {
+				await requireFeature(ctx, "search.settings");
+				const d1 = await db();
+				const [collections, fields] = await Promise.all([
+					d1.prepare("SELECT id, slug, label, search_config, title_field FROM _emdash_collections ORDER BY label").all<CollectionRow>(),
+					d1.prepare("SELECT collection_id, slug, label, type, searchable FROM _emdash_fields ORDER BY sort_order").all<FieldRow>(),
+				]);
+				return {
+					collections: collections.results.map((c) => {
+						let config: { enabled?: boolean; weights?: Record<string, number>; tokenize?: string } = {};
+						try {
+							config = c.search_config ? JSON.parse(c.search_config) : {};
+						} catch {
+							config = {};
+						}
+						return {
+							slug: c.slug,
+							label: c.label,
+							enabled: config.enabled === true,
+							weights: config.weights ?? {},
+							tokenize: config.tokenize ?? "porter unicode61",
+							titleField: c.title_field,
+							fields: fields.results
+								.filter((f) => f.collection_id === c.id)
+								.map((f) => ({ slug: f.slug, label: f.label, type: f.type, searchable: f.searchable === 1 })),
+						};
+					}),
+				};
+			},
+		},
+	};
+
+	/** Published content changed: cached live answers and title indexes for the old version retire. */
+	const touch = async (ctx: { settings: { set(key: string, value: unknown): Promise<void> } }) => {
+		await bumpSearchVersion(ctx);
+	};
+	const isPublished = (content: Record<string, unknown> | undefined) => !content || content.status === undefined || content.status === "published";
+
+	const hooks = {
+		/**
+		 * The live results script, on every public page (it attaches only where there's a search form):
+		 * a deferred, versioned file browsers cache, with this page's config in an attribute, when the
+		 * pack middleware serves that file; otherwise the same client inline (see liveScriptFragment).
+		 */
+		"page:fragments": async (event: { page: { locale: string | null } }) =>
+			liveScriptFragment({ ...live, indexEndpoint: instant ? INDEX_ENDPOINT : null, version: await searchVersion(database), locale: event.page.locale ?? null }),
+		"content:afterSave": (event: { content?: Record<string, unknown> }, ctx: PluginContext) => (isPublished(event.content) ? touch(ctx) : undefined),
+		"content:afterPublish": (_event: unknown, ctx: PluginContext) => touch(ctx),
+		"content:afterUnpublish": (_event: unknown, ctx: PluginContext) => touch(ctx),
+		"content:afterDelete": (_event: unknown, ctx: PluginContext) => touch(ctx),
+		"content:afterRestore": (_event: unknown, ctx: PluginContext) => touch(ctx),
+	};
+
+	return { routes, hooks };
+}

package/src/search/pack.ts

@@ -0,0 +1,57 @@
+import { registerFeatures } from "../core/features.js";
+import type { PackModule } from "../core/module.js";
+import { type SearchOptions, searchModule } from "./module.js";
+import { configureSearchRateLimit } from "./ratelimit.js";
+
+export { searchRateLimitMiddleware } from "./ratelimit.js";
+export { searchLiveMiddleware } from "./live-serve.js";
+
+export const FEATURES = [
+	{
+		id: "search",
+		label: "Search",
+		description: "Tools on top of EmDash's built-in full-text search.",
+		default: false,
+	},
+	{
+		id: "search.settings",
+		label: "Search settings",
+		description: "An admin page for which collections are searchable, field weights, the tokenizer, and index rebuilds.",
+		default: false,
+	},
+	{
+		id: "search.live",
+		label: "Live results",
+		description: "Show matching posts in a dropdown as visitors type.",
+		// On with Search, including sites that turned Search on before this existed (an unsaved choice takes the default).
+		default: true,
+	},
+	{
+		id: "search.box",
+		label: "Search box",
+		description:
+			"The SearchBox component: a search form with a clear button, live results (with Live results on), and results for any of the words when nothing matches all of them.",
+		default: false,
+	},
+	{
+		id: "search.rateLimit",
+		label: "Search rate limit",
+		description: "Limits how often one visitor can search (120 a minute by default), answering 429 beyond that.",
+		default: false,
+	},
+];
+registerFeatures(FEATURES);
+
+export function searchPack(options: SearchOptions): PackModule {
+	configureSearchRateLimit({ requestsPerMinute: options.requestsPerMinute, rateLimiter: options.rateLimiter });
+	const module = searchModule(options);
+	return {
+		id: "search",
+		label: "Search",
+		features: FEATURES,
+		routes: module.routes,
+		hooks: module.hooks,
+		hookFeature: { "page:fragments": "search.live" },
+		adminPages: [{ path: "/search", label: "Search", icon: "magnifying-glass" }],
+	};
+}