@coywolf/emdash 0.0.0-stage → 0.35.14

package/src/search/query.ts

@@ -0,0 +1,132 @@
+/**
+ * EmDash search with an OR fallback, plus resolved public URLs and type
+ * labels for each result. Used by the pack's public search route (and so by
+ * the SearchBox typeahead), and exported for site search pages:
+ *
+ * ```astro
+ * ---
+ * import { searchWithFallback } from "@coywolf/emdash/astro";
+ * const q = Astro.url.searchParams.get("q") ?? "";
+ * const { items, fallback } = q ? await searchWithFallback(q) : { items: [], fallback: false };
+ * ---
+ * ```
+ */
+import { type SearchResult, search } from "emdash";
+
+import { COLLECTION_SLUG, type CollectionInfo, createEntryUrlResolver, interpolateUrlPattern, readCollections } from "../core/content-url.js";
+import { workerEnv } from "../shared.js";
+import { buildOrQuery, rankByCoverage } from "./fallback.js";
+import { type LiveSearchResponse, liveSearchD1 } from "./engine.js";
+
+export interface PackSearchResult extends SearchResult {
+	/** Public path of the entry: the site's `urls` override for the collection, or its URL pattern. */
+	url: string;
+	/** The collection's (singular) label, e.g. "Post". */
+	type: string;
+}
+
+export interface PackSearchResponse {
+	items: PackSearchResult[];
+	nextCursor?: string;
+	/** True when nothing matched every word, so these results match any word. */
+	fallback: boolean;
+}
+
+export interface PackSearchOptions {
+	collections?: string[];
+	locale?: string;
+	/** Default 10. */
+	limit?: number;
+	cursor?: string;
+	/** "suggest" matches titles first (typeahead), then full text. Default "search". */
+	mode?: "search" | "suggest";
+	/** D1 binding of the site database, for URL patterns and terms. Default "DB". */
+	database?: string;
+}
+
+/** How many OR results to rank in one go (the fallback isn't paginated). */
+const FALLBACK_POOL = 50;
+
+export async function searchWithFallback(query: string, options: PackSearchOptions = {}): Promise<PackSearchResponse> {
+	const limit = Math.min(Math.max(options.limit ?? 10, 1), 50);
+	const base = {
+		collections: options.collections ? [...new Set(options.collections)].filter((c) => COLLECTION_SLUG.test(c)).slice(0, 10) : undefined,
+		locale: options.locale,
+	};
+
+	// EmDash treats an empty list as "every collection"; a list with nothing valid in it should find nothing.
+	if (base.collections && base.collections.length === 0) return { items: [], fallback: false };
+
+	if (options.mode === "suggest" && !options.cursor) {
+		const titles = await search(query, { ...base, limit, scope: "title" });
+		if (titles.items.length) return { items: await withUrls(titles.items, options.database), fallback: false };
+	}
+
+	const all = await search(query, { ...base, limit, cursor: options.cursor });
+	if (all.items.length || options.cursor) {
+		return { items: await withUrls(all.items, options.database), nextCursor: all.nextCursor, fallback: false };
+	}
+
+	const orQuery = buildOrQuery(query);
+	if (!orQuery) return { items: [], fallback: false };
+	const any = await search(orQuery, { ...base, limit: FALLBACK_POOL });
+	const ranked = rankByCoverage(any.items, query).slice(0, limit);
+	return { items: await withUrls(ranked, options.database), fallback: ranked.length > 0 };
+}
+
+export type { LiveSearchResponse, LiveSearchResult } from "./engine.js";
+
+/**
+ * Live results (as-you-type dropdown): title matches first, then full-text
+ * matches (with the OR fallback) to fill the list, each with an excerpt from
+ * the entry's indexed text. Same SQL, ranking, fallback and URLs as
+ * searchWithFallback, run by the batched D1 engine (src/search/engine.ts).
+ * Published entries only.
+ */
+export async function liveSearch(query: string, options: Omit<PackSearchOptions, "cursor" | "mode"> & { version?: string } = {}): Promise<LiveSearchResponse> {
+	const database = options.database ?? "DB";
+	let db: D1Database | undefined;
+	try {
+		db = (await workerEnv())[database] as D1Database | undefined;
+	} catch {
+		db = undefined;
+	}
+	if (!db) return { items: [], fallback: false };
+	return liveSearchD1(db, query, { collections: options.collections, locale: options.locale, limit: options.limit, database, version: options.version });
+}
+
+async function withUrls(items: SearchResult[], database = "DB"): Promise<PackSearchResult[]> {
+	if (!items.length) return [];
+	const slugs = [...new Set(items.map((i) => i.collection))];
+	let db: D1Database | undefined;
+	try {
+		db = (await workerEnv())[database] as D1Database | undefined;
+	} catch {
+		db = undefined;
+	}
+	const collections = db ? await readCollections(db, slugs).catch(() => new Map<string, CollectionInfo>()) : new Map<string, CollectionInfo>();
+
+	// Paths from the pack-wide resolver: the site's `urls` overrides (terms read in one batch per
+	// collection) or the collection's url_pattern (publish dates read only when it has date tokens).
+	const urls = new Map<string, string | null>();
+	if (db) {
+		const resolver = createEntryUrlResolver(db);
+		for (const slug of slugs) {
+			const entries = items.filter((i) => i.collection === slug).map((i) => ({ id: i.id, slug: i.slug ?? i.id, locale: i.locale }));
+			try {
+				for (const [id, url] of await resolver.urls(slug, entries)) urls.set(`${slug}:${id}`, url);
+			} catch {
+				// Fall back to the default route below rather than fail the search.
+			}
+		}
+	}
+
+	return items.map((item) => {
+		const info = collections.get(item.collection);
+		return {
+			...item,
+			url: urls.get(`${item.collection}:${item.id}`) ?? interpolateUrlPattern({ pattern: null, collection: item.collection, slug: item.slug ?? item.id, id: item.id }),
+			type: info?.labelSingular || info?.label || item.collection,
+		};
+	});
+}

package/src/search/ratelimit-core.ts

@@ -0,0 +1,118 @@
+/**
+ * Fixed-window rate limiting: the pure parts (no imports, unit tested in Node).
+ */
+
+export const WINDOW_MS = 60_000;
+
+export interface Window {
+	/** Start of the current window (ms since epoch). */
+	start: number;
+	/** When the window ends and the count resets. */
+	resetAt: number;
+}
+
+export function currentWindow(now: number, windowMs = WINDOW_MS): Window {
+	const start = Math.floor(now / windowMs) * windowMs;
+	return { start, resetAt: start + windowMs };
+}
+
+export interface Decision {
+	allowed: boolean;
+	/** Requests counted in this window, including this one when allowed. */
+	count: number;
+	/** Whole seconds until the window resets (for Retry-After), at least 1. */
+	retryAfter: number;
+}
+
+/** Decide on a request given how many were already counted in its window. A limit of 0 disables limiting. */
+export function decide(previousCount: number, limit: number, now: number, windowMs = WINDOW_MS): Decision {
+	const { resetAt } = currentWindow(now, windowMs);
+	const retryAfter = Math.max(1, Math.ceil((resetAt - now) / 1000));
+	if (limit <= 0) return { allowed: true, count: previousCount + 1, retryAfter };
+	if (previousCount >= limit) return { allowed: false, count: previousCount, retryAfter };
+	return { allowed: true, count: previousCount + 1, retryAfter };
+}
+
+/**
+ * Per-isolate counter. Best effort on its own (Workers spread traffic across
+ * isolates), and the first layer in front of KV, which is eventually
+ * consistent and catches bursts late.
+ */
+export class MemoryWindowCounter {
+	private readonly counts = new Map<string, { start: number; count: number }>();
+	private readonly maxKeys: number;
+	private readonly windowMs: number;
+
+	constructor(maxKeys = 10_000, windowMs = WINDOW_MS) {
+		this.maxKeys = maxKeys;
+		this.windowMs = windowMs;
+	}
+
+	/** Count a request for `key` and return the decision. */
+	hit(key: string, limit: number, now: number): Decision {
+		const { start } = currentWindow(now, this.windowMs);
+		const entry = this.counts.get(key);
+		const previous = entry && entry.start === start ? entry.count : 0;
+		const decision = decide(previous, limit, now, this.windowMs);
+		if (decision.allowed) {
+			if (!entry && this.counts.size >= this.maxKeys) this.prune(start);
+			this.counts.set(key, { start, count: decision.count });
+		}
+		return decision;
+	}
+
+	/** Drop entries from earlier windows; if still full, drop the oldest half. */
+	prune(currentStart: number): void {
+		for (const [key, entry] of this.counts) if (entry.start !== currentStart) this.counts.delete(key);
+		if (this.counts.size >= this.maxKeys) {
+			let drop = Math.ceil(this.counts.size / 2);
+			for (const key of this.counts.keys()) {
+				if (drop-- <= 0) break;
+				this.counts.delete(key);
+			}
+		}
+	}
+
+	get size(): number {
+		return this.counts.size;
+	}
+}
+
+/** The Workers Rate Limiting binding's API (wrangler "ratelimits"). */
+export interface RateLimitBinding {
+	limit(options: { key: string }): Promise<{ success: boolean }>;
+}
+
+/**
+ * Decide on one request for a client. With a Rate Limiting binding the
+ * binding decides (its limit and period come from the wrangler config, and it
+ * counts per Cloudflare location); without one, the per-isolate counter does.
+ * If the binding errors, fall back to the counter rather than fail open.
+ */
+export async function limitClient(
+	clientKey: string,
+	options: { limit: number; now: number; memory: MemoryWindowCounter; binding?: RateLimitBinding; bindingPeriod?: number },
+): Promise<{ allowed: boolean; retryAfter: number }> {
+	if (options.binding) {
+		try {
+			const { success } = await options.binding.limit({ key: clientKey });
+			return { allowed: success, retryAfter: options.bindingPeriod ?? 60 };
+		} catch {
+			// Use the in-memory counter below.
+		}
+	}
+	if (options.limit <= 0) return { allowed: true, retryAfter: 0 };
+	const decision = options.memory.hit(clientKey, options.limit, options.now);
+	return { allowed: decision.allowed, retryAfter: decision.retryAfter };
+}
+
+/** Search URLs the limiter covers: EmDash's public search and suggest endpoints, and the pack's search and live results routes. Admin endpoints (enable, rebuild, stats) aren't limited. */
+export function isLimitedPath(pathname: string): boolean {
+	const path = pathname.length > 1 ? pathname.replace(/\/+$/, "") : pathname;
+	return (
+		path === "/_emdash/api/search" ||
+		path === "/_emdash/api/search/suggest" ||
+		path === "/_emdash/api/plugins/coywolf-pack/search/query" ||
+		path === "/_emdash/api/plugins/coywolf-pack/search/live"
+	);
+}

package/src/search/ratelimit.ts

@@ -0,0 +1,79 @@
+/**
+ * Rate limiting for search (feature "search.rateLimit"), served through the
+ * pack middleware. Each client is keyed by a salted SHA-256 of its IP address
+ * (Cloudflare's CF-Connecting-IP, which visitors can't spoof), never the
+ * address itself. With a Workers Rate Limiting binding (option
+ * `rateLimiter`), Cloudflare counts across isolates; without one, a
+ * per-isolate in-memory counter does, best effort.
+ */
+import type { PackMiddleware } from "../core/module.js";
+import { MemoryWindowCounter, type RateLimitBinding, isLimitedPath, limitClient } from "./ratelimit-core.js";
+
+export interface SearchRateLimitOptions {
+	/** Requests per minute per visitor for the in-memory fallback. Default 120; 0 turns the fallback off. With a binding, the binding's own limit applies. */
+	requestsPerMinute?: number;
+	/** Name of a Workers Rate Limiting binding (wrangler "ratelimits"). Default none (per-isolate memory only). */
+	rateLimiter?: string;
+}
+
+const DEFAULT_RPM = 120;
+const SALT_SECRET = "SEARCH_RATE_LIMIT_SALT";
+/** Used when no secret is set. Keys must agree across isolates for the binding, so this can't be random per isolate. */
+const DEFAULT_SALT = "coywolf-pack:search-rate-limit";
+
+/**
+ * Options from coywolfPlugin({ search }). EmDash instantiates plugins when the
+ * Worker starts (the generated plugins module calls createPlugin at import),
+ * so this is set before any request reaches the middleware.
+ */
+let config: SearchRateLimitOptions = {};
+export function configureSearchRateLimit(options: SearchRateLimitOptions): void {
+	config = { ...options };
+}
+
+const memory = new MemoryWindowCounter();
+
+async function hashClient(ip: string, salt: string): Promise<string> {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(`${salt}:${ip}`));
+	return [...new Uint8Array(digest).slice(0, 16)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+function clientIp(request: Request, fallback: () => string | undefined): string | null {
+	const header = request.headers.get("cf-connecting-ip");
+	if (header) return header.trim();
+	try {
+		return fallback() ?? null;
+	} catch {
+		return null;
+	}
+}
+
+/** Every limited path is a JSON API, so answer in EmDash's error shape. */
+function tooMany(retryAfter: number): Response {
+	return Response.json(
+		{ success: false, error: { code: "RATE_LIMITED", message: "Too many searches. Try again shortly." } },
+		{ status: 429, headers: { "Retry-After": String(retryAfter), "Cache-Control": "no-store" } },
+	);
+}
+
+/** The 429 response when this client is over the limit, else undefined. */
+export async function rateLimitResponse(context: Parameters<PackMiddleware["handle"]>[0], env: Record<string, unknown>): Promise<Response | undefined> {
+	const binding = config.rateLimiter ? (env[config.rateLimiter] as RateLimitBinding | undefined) : undefined;
+	const limit = config.requestsPerMinute ?? DEFAULT_RPM;
+	if (!binding && limit <= 0) return undefined;
+	const ip = clientIp(context.request, () => context.clientAddress);
+	if (!ip) return undefined;
+	const secret = env[SALT_SECRET];
+	const client = await hashClient(ip, typeof secret === "string" && secret ? secret : DEFAULT_SALT);
+	const result = await limitClient(client, { limit, now: Date.now(), memory, binding });
+	return result.allowed ? undefined : tooMany(result.retryAfter);
+}
+
+export const searchRateLimitMiddleware: PackMiddleware = {
+	module: "search",
+	feature: "search.rateLimit",
+	handle: async (context, env) => {
+		if (!isLimitedPath(context.url.pathname)) return undefined;
+		return rateLimitResponse(context, env);
+	},
+};

package/src/search/snippet.ts

@@ -0,0 +1,135 @@
+/**
+ * Live results highlighting: the excerpt under each result and the matched
+ * words in titles. Ported from the Coywolf Search WordPress plugin (a
+ * window of text around the first match, ellipses at cut ends, matches
+ * wrapped in <mark>), with two changes: matching is by word prefix, the
+ * way EmDash's FTS5 prefix search matched the entry, and the text is
+ * escaped piece by piece around the matches rather than highlighted after
+ * escaping, so a typed "amp" can never land inside "&amp;".
+ *
+ * The output is escaped HTML whose only tags are <mark> and </mark>.
+ *
+ * Pure functions (no imports) so they can be unit tested in Node.
+ */
+
+/** Characters of text in a snippet (as in Coywolf Search). */
+export const SNIPPET_WIDTH = 180;
+/** Characters of context kept before the first match. */
+export const SNIPPET_LEAD = 40;
+/** Most words highlighted from one query. */
+export const MAX_HIGHLIGHT_WORDS = 10;
+
+const ESCAPES: Record<string, string> = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
+
+export function escapeHtml(text: string): string {
+	return text.replace(/[&<>"']/g, (c) => ESCAPES[c] ?? c);
+}
+
+/**
+ * The words to highlight: what the visitor typed (not index terms, which
+ * stemming changes), two characters or longer, longest first so "photograph"
+ * wins over "photo" and the shorter word can't split the longer one's mark.
+ */
+export function highlightWords(query: string): string[] {
+	const seen = new Set<string>();
+	for (const part of query.toLowerCase().split(/[^\p{L}\p{N}]+/u)) {
+		if ([...part].length >= 2) seen.add(part);
+	}
+	return [...seen].sort((a, b) => b.length - a.length).slice(0, MAX_HIGHLIGHT_WORDS);
+}
+
+const escapeRegExp = (text: string) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+/** Matches any of the words at the start of a word (case-insensitive). Null when there are none. */
+export function wordPattern(words: string[]): RegExp | null {
+	if (!words.length) return null;
+	return new RegExp(`(?<![\\p{L}\\p{N}])(?:${words.map(escapeRegExp).join("|")})`, "giu");
+}
+
+/** Escape `text` and wrap each match of the words in <mark>. */
+export function highlightHtml(text: string, words: string[]): string {
+	const pattern = wordPattern(words);
+	if (!pattern) return escapeHtml(text);
+	let out = "";
+	let last = 0;
+	for (const match of text.matchAll(pattern)) {
+		const start = match.index ?? 0;
+		out += `${escapeHtml(text.slice(last, start))}<mark>${escapeHtml(match[0])}</mark>`;
+		last = start + match[0].length;
+	}
+	return out + escapeHtml(text.slice(last));
+}
+
+/** Collapse whitespace (indexed Portable Text is spans joined by spaces). */
+export function cleanText(text: string): string {
+	return text.replace(/\s+/gu, " ").trim();
+}
+
+const isLowSurrogate = (text: string, i: number) => {
+	const c = text.charCodeAt(i);
+	return c >= 0xdc00 && c <= 0xdfff;
+};
+
+/**
+ * A window of about `width` characters around the first match of any of the
+ * words (or the start, when none match), cut at word boundaries where the
+ * text has them, with "…" where it was cut, highlighted and escaped.
+ */
+export function buildSnippet(text: string, words: string[], width = SNIPPET_WIDTH, lead = SNIPPET_LEAD): string {
+	const clean = cleanText(text);
+	if (!clean) return "";
+	const pattern = wordPattern(words);
+	const first = pattern ? pattern.exec(clean) : null;
+
+	let start = first ? Math.max(0, first.index - lead) : 0;
+	let end = Math.min(clean.length, start + width);
+	// Pull the window back when the end of the text leaves room, so a match near the end keeps its context.
+	if (end === clean.length) start = Math.max(0, end - width);
+
+	// Snap inward to word boundaries (not past the match), so no word is shown cut in half.
+	if (start > 0) {
+		const space = clean.indexOf(" ", start);
+		if (space !== -1 && space < (first ? first.index : end) && space - start < 20) start = space + 1;
+		else if (isLowSurrogate(clean, start)) start++;
+	}
+	if (end < clean.length) {
+		const space = clean.lastIndexOf(" ", end);
+		if (space > start && end - space < 20 && (!first || space >= first.index + first[0].length)) end = space;
+		else if (isLowSurrogate(clean, end)) end--;
+	}
+
+	const body = highlightHtml(clean.slice(start, end).trim(), words);
+	return `${start > 0 ? "…" : ""}${body}${end < clean.length ? "…" : ""}`;
+}
+
+/**
+ * The readable text of a Portable Text field (stored as JSON): the spans of
+ * text blocks (paragraphs, headings, lists) only. Image alt text, captions
+ * and other blocks' data, which EmDash's search index includes, are left out
+ * so excerpts read like the post. Returns "" for anything that isn't Portable
+ * Text.
+ */
+export function portableTextProse(value: unknown, maxChars = 20_000): string {
+	let blocks: unknown = value;
+	if (typeof value === "string") {
+		try {
+			blocks = JSON.parse(value);
+		} catch {
+			return "";
+		}
+	}
+	if (!Array.isArray(blocks)) return "";
+	const parts: string[] = [];
+	let length = 0;
+	for (const block of blocks) {
+		if (!block || typeof block !== "object" || (block as { _type?: unknown })._type !== "block") continue;
+		const children = (block as { children?: unknown }).children;
+		if (!Array.isArray(children)) continue;
+		const text = children.map((c) => (c && typeof c === "object" && typeof (c as { text?: unknown }).text === "string" ? (c as { text: string }).text : "")).join("");
+		if (!text.trim()) continue;
+		parts.push(text);
+		length += text.length + 1;
+		if (length >= maxChars) break;
+	}
+	return parts.join(" ").slice(0, maxChars);
+}

package/src/search/title-index.ts

@@ -0,0 +1,139 @@
+/**
+ * The title index behind instant live results: every published entry of
+ * the searchable collections as [title, url, type], newest first, capped.
+ * The browser downloads it once per content version (lazily, on first focus
+ * of a search field) and matches titles locally while the server's full-text
+ * answer is on its way.
+ *
+ * Compact on purpose: no content, root-relative URLs, type labels listed
+ * once and referenced by position, and plain arrays that compress well.
+ */
+import { COLLECTION_SLUG, type PrimaryTermRow, type SqlQuery, collectPrimaryTerms, hostDefaultLocale, patternTaxonomies, primaryTermsQuery, urlOverride } from "../core/content-url.js";
+import { type CollectionMeta, type SearchMeta, entryUrlsFromMeta, runBatch, searchTargets, titleExpression } from "./engine.js";
+
+/** Most entries in an index (newest kept). */
+export const TITLE_INDEX_MAX = 5000;
+/** Longest title kept (characters); longer ones are cut. */
+const MAX_TITLE = 200;
+
+export interface TitleIndex {
+	/** The search content version it was built from. */
+	v: string;
+	/** Type labels; each entry's third item is a position in this list. */
+	types: string[];
+	/** [title, root-relative URL, type index], newest first. */
+	entries: Array<[string, string, number]>;
+}
+
+export interface IndexEntry {
+	title: string;
+	url: string;
+	type: string;
+	/** Publish date (ISO or SQLite datetime); newer first. */
+	date: string | null;
+}
+
+/** Pack entries into the index: newest first, one per URL, titles trimmed, at most `max`. */
+export function packTitleIndex(entries: IndexEntry[], version: string, max = TITLE_INDEX_MAX): TitleIndex {
+	const sorted = entries
+		.map((e, i) => ({ e, i }))
+		.filter(({ e }) => e.title.trim() && e.url)
+		.sort((a, b) => (b.e.date ?? "").localeCompare(a.e.date ?? "") || a.i - b.i);
+	const types: string[] = [];
+	const typeIndex = new Map<string, number>();
+	const seen = new Set<string>();
+	const out: Array<[string, string, number]> = [];
+	for (const { e } of sorted) {
+		if (out.length >= max) break;
+		if (seen.has(e.url)) continue;
+		seen.add(e.url);
+		let t = typeIndex.get(e.type);
+		if (t === undefined) {
+			t = types.length;
+			types.push(e.type);
+			typeIndex.set(e.type, t);
+		}
+		out.push([e.title.replace(/\s+/g, " ").trim().slice(0, MAX_TITLE), e.url, t]);
+	}
+	return { v: version, types, entries: out };
+}
+
+/** One collection's published entries for the index, newest first. */
+export function indexEntriesQuery(meta: CollectionMeta, options: { locale?: string; max: number }): SqlQuery | null {
+	if (!COLLECTION_SLUG.test(meta.slug)) return null;
+	const title = titleExpression(meta);
+	if (title === "NULL") return null;
+	const binds: unknown[] = [];
+	let where = "c.status = 'published' AND c.deleted_at IS NULL AND c.slug IS NOT NULL";
+	if (options.locale) {
+		where += " AND c.locale = ? COLLATE NOCASE";
+		binds.push(options.locale);
+	}
+	binds.push(options.max);
+	return {
+		sql: `SELECT c.id AS id, c.slug AS slug, c.locale AS locale, c.published_at AS published_at, ${title} AS title FROM "ec_${meta.slug}" c WHERE ${where} ORDER BY c.published_at DESC LIMIT ?`,
+		binds,
+	};
+}
+
+interface IndexRow {
+	id: string;
+	slug: string;
+	locale: string | null;
+	published_at: string | null;
+	title: string | null;
+}
+
+/**
+ * Build the index from D1: one batch with each collection's entries (and,
+ * for collections whose URLs use terms, every published entry's terms in one
+ * query), then URLs from the cached metadata.
+ */
+export async function buildTitleIndex(db: D1Database, meta: SearchMeta, options: { collections?: string[]; locale?: string; version: string; max?: number }): Promise<TitleIndex> {
+	const max = options.max ?? TITLE_INDEX_MAX;
+	const targets = searchTargets(meta, options.collections);
+	const defaultLocale = await hostDefaultLocale();
+	const plan: Array<{ kind: "entries" | "terms"; slug: string }> = [];
+	const queries: SqlQuery[] = [];
+	for (const t of targets) {
+		const q = indexEntriesQuery(t, { locale: options.locale, max });
+		if (!q) continue;
+		plan.push({ kind: "entries", slug: t.slug });
+		queries.push(q);
+		const taxonomies = patternTaxonomies(urlOverride(t.slug));
+		if (taxonomies.length) {
+			plan.push({ kind: "terms", slug: t.slug });
+			queries.push(primaryTermsQuery(t.slug, null, taxonomies, defaultLocale));
+		}
+	}
+	const results = await runBatch(db, queries);
+	const rows = new Map<string, IndexRow[]>();
+	const terms = new Map<string, Map<string, Record<string, string>>>();
+	plan.forEach((p, i) => {
+		if (p.kind === "entries") rows.set(p.slug, (results[i] ?? []) as unknown as IndexRow[]);
+		else terms.set(p.slug, collectPrimaryTerms((results[i] ?? []) as unknown as PrimaryTermRow[]));
+	});
+
+	const slugs = [...rows.keys()];
+	const urls = await entryUrlsFromMeta(db, meta, slugs, (slug) =>
+		(rows.get(slug) ?? []).map((r) => ({
+			id: String(r.id),
+			slug: r.slug,
+			locale: r.locale,
+			publishedAt: r.published_at,
+			terms: terms.has(slug) ? (terms.get(slug)?.get(String(r.id)) ?? {}) : undefined,
+		})),
+	);
+
+	const entries: IndexEntry[] = [];
+	for (const slug of slugs) {
+		const info = meta.collections.get(slug);
+		const type = info?.labelSingular || info?.label || slug;
+		for (const r of rows.get(slug) ?? []) {
+			const url = urls.get(`${slug}:${String(r.id)}`);
+			if (!url || !r.title) continue;
+			entries.push({ title: String(r.title), url, type, date: r.published_at });
+		}
+	}
+	return packTitleIndex(entries, options.version, max);
+}