emdash 0.32.0 → 0.34.0

package/src/search/fts-manager.ts

@@ -10,7 +10,22 @@ import { sql } from "kysely";
 import { isSqlite, tableExists as dialectTableExists } from "../database/dialect-helpers.js";
 import type { Database } from "../database/types.js";
 import { validateIdentifier } from "../database/validate.js";
-import type { SearchConfig } from "./types.js";
+import { SEARCH_TOKENIZERS } from "./types.js";
+import type { SearchConfig, SearchTokenizer } from "./types.js";
+
+const DEFAULT_SEARCH_TOKENIZER: SearchTokenizer = "porter unicode61";
+
+function isSearchTokenizer(value: unknown): value is SearchTokenizer {
+	return SEARCH_TOKENIZERS.some((tokenizer) => tokenizer === value);
+}
+
+function resolveSearchTokenizer(tokenize?: SearchTokenizer): SearchTokenizer {
+	if (tokenize === undefined) return DEFAULT_SEARCH_TOKENIZER;
+	if (!isSearchTokenizer(tokenize)) {
+		throw new Error(`Unsupported FTS5 tokenizer: "${String(tokenize)}"`);
+	}
+	return tokenize;
+}
 
 /**
  * FTS5 Manager
@@ -66,36 +81,36 @@ export class FTSManager {
 	 * @param collectionSlug - The collection slug
 	 * @param searchableFields - Array of field names to index
 	 * @param weights - Optional field weights for ranking
+	 * @param tokenize - Optional FTS5 tokenizer configuration
 	 */
 	async createFtsTable(
 		collectionSlug: string,
 		searchableFields: string[],
 		_weights?: Record<string, number>,
+		tokenize?: SearchTokenizer,
 	): Promise<void> {
+		const tokenizer = resolveSearchTokenizer(tokenize);
 		if (!isSqlite(this.db)) return;
 		this.validateInputs(collectionSlug, searchableFields);
 		const ftsTable = this.getFtsTableName(collectionSlug);
-		const contentTable = this.getContentTableName(collectionSlug);
 
 		// Build the column list for FTS5
 		// id and locale are UNINDEXED (used for joining/filtering, not searched)
 		const columns = ["id UNINDEXED", "locale UNINDEXED", ...searchableFields].join(", ");
 
-		// Create the FTS5 virtual table.
-		// `content='<table>'` makes this an *external content* FTS5 table:
-		// the inverted index lives in the FTS shadow tables, but the actual
-		// row data lives in the backing content table. The triggers in
-		// `createTriggers` keep the index in sync; they MUST use the
-		// external-content-safe `'delete'` command (see notes there) to
-		// avoid `SQLITE_CORRUPT_VTAB` on UPDATE/DELETE.
-		// tokenize='porter unicode61' enables stemming (run matches running, ran, etc.)
+		// Create the FTS5 virtual table. The table stores its own copy of the
+		// indexed values (no `content=` option): Portable Text fields are
+		// indexed as extracted plain text — see searchValueExpr — which cannot
+		// mirror the raw JSON in the ec_* column, and external-content FTS5
+		// requires the index to exactly mirror the backing table's values
+		// (snippet() reads them, and the 'delete' command must be fed the
+		// inserted values or the index corrupts — see migration 039's history).
+		// Storing the extracted text also makes snippet() return prose.
 		await sql
 			.raw(`
 			CREATE VIRTUAL TABLE IF NOT EXISTS "${ftsTable}" USING fts5(
 				${columns},
-				content='${contentTable}',
-				content_rowid='rowid',
-				tokenize='porter unicode61'
+				tokenize='${tokenizer}'
 			)
 		`)
 			.execute(this.db);
@@ -104,6 +119,55 @@ export class FTSManager {
 		await this.createTriggers(collectionSlug, searchableFields);
 	}
 
+	/**
+	 * SQL expression producing the indexed value for one searchable field.
+	 *
+	 * Portable Text fields are stored as JSON; indexing the raw JSON pollutes
+	 * the index with structural tokens (`_type`, style values like `normal`,
+	 * `_key` ULIDs) and makes snippets show JSON fragments. Extract the prose
+	 * instead: every JSON string under a `text`, `alt`, `caption`, or `code`
+	 * key (span text, image alt/caption, code blocks). This is a superset of
+	 * `extractPlainText` in text-extraction.ts, which walks only known block
+	 * shapes — the SQL variant takes those keys at any depth, so search and
+	 * the extractPlainText consumers (vectorize/ai-search) can see different
+	 * text for the same document. Only JSON documents
+	 * (arrays/objects) are extracted; legacy rows holding a bare string or a
+	 * JSON scalar (`Some title`, `2024`) are indexed as-is. Extraction must
+	 * live in SQL because the sync triggers cannot call into JS.
+	 *
+	 * `ref` must be a validated column reference (`NEW.x`, `OLD.x`, `"x"`).
+	 */
+	private searchValueExpr(ref: string, fieldType: string | undefined): string {
+		if (fieldType !== "portableText") return ref;
+		return (
+			`CASE WHEN ${ref} IS NULL THEN NULL ` +
+			`WHEN json_valid(${ref}) AND json_type(${ref}) IN ('array', 'object') THEN (` +
+			`SELECT group_concat(j.value, ' ') FROM json_tree(${ref}) AS j ` +
+			`WHERE j.key IN ('text', 'alt', 'caption', 'code') AND j.type = 'text') ` +
+			`ELSE ${ref} END`
+		);
+	}
+
+	/**
+	 * Field type per slug for a collection, for choosing the indexed-value
+	 * expression. Fields missing from the schema fall back to raw indexing.
+	 */
+	private async getFieldTypes(collectionSlug: string): Promise<Map<string, string>> {
+		const collection = await this.db
+			.selectFrom("_emdash_collections")
+			.select("id")
+			.where("slug", "=", collectionSlug)
+			.executeTakeFirst();
+		if (!collection) return new Map();
+
+		const rows = await this.db
+			.selectFrom("_emdash_fields")
+			.select(["slug", "type"])
+			.where("collection_id", "=", collection.id)
+			.execute();
+		return new Map(rows.map((r) => [r.slug, r.type]));
+	}
+
 	/**
 	 * Create triggers to keep FTS table in sync with content table.
 	 *
@@ -112,31 +176,20 @@ export class FTSManager {
 	 * search index and ensures the FTS row count matches the non-deleted
 	 * content count (which `verifyAndRepairIndex` relies on).
 	 *
-	 * IMPORTANT: The FTS5 virtual table is created with `content='ec_<slug>'`
-	 * which makes it an *external content* FTS5 table. For external-content
-	 * tables, removing a row must use the documented `'delete'` command and
-	 * supply the OLD column values explicitly, e.g.:
+	 * The FTS table stores its own values (no `content=` option), so removal
+	 * is a plain `DELETE FROM fts WHERE rowid = OLD.rowid` — a harmless no-op
+	 * for rows that were never indexed (soft-deleted content). The
+	 * external-content `'delete'`-command choreography and its corruption
+	 * modes (migration 039) do not apply to self-contained tables.
 	 *
-	 *     INSERT INTO fts(fts, rowid, col1, col2)
-	 *     VALUES('delete', OLD.rowid, OLD.col1, OLD.col2);
+	 * `INSERT OR REPLACE` keeps the insert path idempotent: re-running a
+	 * populate (D1 has no migration lock, so two isolates can race) converges
+	 * on one index row per content row instead of failing on the rowid
+	 * constraint.
 	 *
-	 * Using `DELETE FROM fts WHERE rowid = OLD.rowid` is the correct form
-	 * for *contentless* tables but is unsafe for external-content tables:
-	 * FTS5 then reads column values from the backing content table, which
-	 * in an AFTER UPDATE trigger already holds the NEW values. The wrong
-	 * tokens get removed and the inverted index drifts out of sync until
-	 * SQLite raises `SQLITE_CORRUPT_VTAB` on the next mutation. See
-	 * https://www.sqlite.org/fts5.html#external_content_tables.
-	 *
-	 * The UPDATE and DELETE triggers gate the `'delete'` on
-	 * `OLD.deleted_at IS NULL` because the INSERT trigger never indexed
-	 * rows that were already soft-deleted. Issuing `'delete'` for a rowid
-	 * that was never inserted into the FTS index is itself a corruption
-	 * trigger -- FTS5's `'delete'` is not a no-op on missing rowids and
-	 * raises `SQLITE_CORRUPT_VTAB`. Affected paths include restore-from-
-	 * trash (UPDATE where `OLD.deleted_at IS NOT NULL`), permanent-delete
-	 * from trash (DELETE on a soft-deleted row), and any edit on a row
-	 * that's currently in the trash.
+	 * The trigger SQL emitted here MUST stay in lock-step with migration
+	 * `064_fts_plain_text.ts`. If this changes again, add a new migration
+	 * rather than editing shipped ones — migrations are forward-only.
 	 */
 	private async createTriggers(collectionSlug: string, searchableFields: string[]): Promise<void> {
 		this.validateInputs(collectionSlug, searchableFields);
@@ -148,64 +201,60 @@ export class FTSManager {
 		}
 		const ftsTable = this.getFtsTableName(collectionSlug);
 		const contentTable = this.getContentTableName(collectionSlug);
+		const fieldTypes = await this.getFieldTypes(collectionSlug);
 		const fieldList = searchableFields.join(", ");
-		const newFieldList = searchableFields.map((f) => `NEW.${f}`).join(", ");
-		// `'delete'` takes the FTS5 virtual table name as the first column,
-		// then the rowid being removed, then the OLD value of every column
-		// declared on the FTS5 table (in declaration order: id, locale,
-		// then each searchable field).
-		const oldFieldList = searchableFields.map((f) => `OLD.${f}`).join(", ");
+		const newValueList = searchableFields
+			.map((f) => this.searchValueExpr(`NEW.${f}`, fieldTypes.get(f)))
+			.join(", ");
 
 		// Insert trigger - only index non-deleted content
 		await sql
 			.raw(`
-			CREATE TRIGGER IF NOT EXISTS "${ftsTable}_insert" 
-			AFTER INSERT ON "${contentTable}" 
+			CREATE TRIGGER IF NOT EXISTS "${ftsTable}_insert"
+			AFTER INSERT ON "${contentTable}"
 			WHEN NEW.deleted_at IS NULL
 			BEGIN
-				INSERT INTO "${ftsTable}"(rowid, id, locale, ${fieldList})
-				VALUES (NEW.rowid, NEW.id, NEW.locale, ${newFieldList});
+				INSERT OR REPLACE INTO "${ftsTable}"(rowid, id, locale, ${fieldList})
+				VALUES (NEW.rowid, NEW.id, NEW.locale, ${newValueList});
 			END
 		`)
 			.execute(this.db);
 
-		// Update trigger - remove the old row from the FTS index using the
-		// external-content-safe `'delete'` command (which uses OLD column
-		// values, captured before the row was modified), then re-insert
-		// the new values when the row is still visible.
+		// Update trigger - drop the old index row, re-insert when the row is
+		// still visible. Trash (deleted_at set) ends at DELETE only; restore
+		// ends at DELETE (no-op) + re-insert.
 		//
-		// `'delete'` is gated on `OLD.deleted_at IS NULL` because rows that
-		// were soft-deleted are not in the FTS index (the INSERT trigger
-		// skips them). Issuing `'delete'` for a missing rowid raises
-		// `SQLITE_CORRUPT_VTAB`, which would break restore-from-trash and
-		// edits to soft-deleted rows.
+		// The WHEN guard compares raw column values (null-safe IS NOT) so the
+		// trigger fires only when an indexed value, the row's locale, or its
+		// trash state actually changed. Without it every UPDATE re-tokenizes
+		// the whole document — metadata-only saves (status flips, scheduling,
+		// version bumps) and the publish path's rewrite-identical-values
+		// UPDATEs dominate save CPU and WAL volume. deleted_at must stay in
+		// the guard or trash/restore stop syncing the index.
+		const changedCondition = ["deleted_at", "locale", ...searchableFields]
+			.map((f) => `OLD.${f} IS NOT NEW.${f}`)
+			.join(" OR ");
 		await sql
 			.raw(`
-			CREATE TRIGGER IF NOT EXISTS "${ftsTable}_update" 
-			AFTER UPDATE ON "${contentTable}" 
+			CREATE TRIGGER IF NOT EXISTS "${ftsTable}_update"
+			AFTER UPDATE ON "${contentTable}"
+			WHEN ${changedCondition}
 			BEGIN
-				INSERT INTO "${ftsTable}"("${ftsTable}", rowid, id, locale, ${fieldList})
-				SELECT 'delete', OLD.rowid, OLD.id, OLD.locale, ${oldFieldList}
-				WHERE OLD.deleted_at IS NULL;
+				DELETE FROM "${ftsTable}" WHERE rowid = OLD.rowid;
 				INSERT INTO "${ftsTable}"(rowid, id, locale, ${fieldList})
-				SELECT NEW.rowid, NEW.id, NEW.locale, ${newFieldList}
+				SELECT NEW.rowid, NEW.id, NEW.locale, ${newValueList}
 				WHERE NEW.deleted_at IS NULL;
 			END
 		`)
 			.execute(this.db);
 
-		// Delete trigger - same external-content-safe `'delete'` form,
-		// gated on `OLD.deleted_at IS NULL` for the same reason as the
-		// UPDATE trigger: permanent-delete from trash hits a row whose
-		// `deleted_at` is already set and which was never indexed.
+		// Delete trigger
 		await sql
 			.raw(`
-			CREATE TRIGGER IF NOT EXISTS "${ftsTable}_delete" 
-			AFTER DELETE ON "${contentTable}" 
+			CREATE TRIGGER IF NOT EXISTS "${ftsTable}_delete"
+			AFTER DELETE ON "${contentTable}"
 			BEGIN
-				INSERT INTO "${ftsTable}"("${ftsTable}", rowid, id, locale, ${fieldList})
-				SELECT 'delete', OLD.rowid, OLD.id, OLD.locale, ${oldFieldList}
-				WHERE OLD.deleted_at IS NULL;
+				DELETE FROM "${ftsTable}" WHERE rowid = OLD.rowid;
 			END
 		`)
 			.execute(this.db);
@@ -247,33 +296,45 @@ export class FTSManager {
 		collectionSlug: string,
 		searchableFields: string[],
 		weights?: Record<string, number>,
+		tokenize?: SearchTokenizer,
 	): Promise<void> {
+		resolveSearchTokenizer(tokenize);
 		if (!isSqlite(this.db)) return;
 		// Drop existing table and triggers
 		await this.dropFtsTable(collectionSlug);
 
 		// Recreate table and triggers
-		await this.createFtsTable(collectionSlug, searchableFields, weights);
+		await this.createFtsTable(collectionSlug, searchableFields, weights, tokenize);
 
 		// Populate from existing content
 		await this.populateFromContent(collectionSlug, searchableFields);
 	}
 
 	/**
-	 * Populate the FTS table from existing content
+	 * Populate the FTS table from existing content.
+	 *
+	 * `INSERT OR REPLACE` so a concurrent double-populate (D1 has no
+	 * migration lock) converges instead of failing on the rowid constraint.
 	 */
 	async populateFromContent(collectionSlug: string, searchableFields: string[]): Promise<void> {
 		if (!isSqlite(this.db)) return;
 		this.validateInputs(collectionSlug, searchableFields);
 		const ftsTable = this.getFtsTableName(collectionSlug);
 		const contentTable = this.getContentTableName(collectionSlug);
+		const fieldTypes = await this.getFieldTypes(collectionSlug);
 		const fieldList = searchableFields.join(", ");
+		// Table-qualified references: json_tree exposes columns named
+		// key/value/type/path/..., and inside the extraction subquery a bare
+		// column reference binds to those instead of the ec_* column.
+		const valueList = searchableFields
+			.map((f) => this.searchValueExpr(`"${contentTable}"."${f}"`, fieldTypes.get(f)))
+			.join(", ");
 
 		// Insert all existing content into FTS table
 		await sql
 			.raw(`
-			INSERT INTO "${ftsTable}"(rowid, id, locale, ${fieldList})
-			SELECT rowid, id, locale, ${fieldList} FROM "${contentTable}"
+			INSERT OR REPLACE INTO "${ftsTable}"(rowid, id, locale, ${fieldList})
+			SELECT rowid, id, locale, ${valueList} FROM "${contentTable}"
 			WHERE deleted_at IS NULL
 		`)
 			.execute(this.db);
@@ -285,7 +346,7 @@ export class FTSManager {
 	async getSearchConfig(collectionSlug: string): Promise<SearchConfig | null> {
 		const result = await this.db
 			.selectFrom("_emdash_collections")
-			.select("search_config")
+			.select(["search_config", "title_field"])
 			.where("slug", "=", collectionSlug)
 			.executeTakeFirst();
 
@@ -304,6 +365,7 @@ export class FTSManager {
 				return null;
 			}
 			const config: SearchConfig = { enabled: parsed.enabled };
+			if (result.title_field) config.titleField = result.title_field;
 			if ("weights" in parsed && typeof parsed.weights === "object" && parsed.weights !== null) {
 				// weights is a JSON-parsed object — safe to treat as Record<string, number>
 				const weights: Record<string, number> = {};
@@ -314,6 +376,12 @@ export class FTSManager {
 				}
 				config.weights = weights;
 			}
+			if ("tokenize" in parsed) {
+				if (!isSearchTokenizer(parsed.tokenize)) {
+					return null;
+				}
+				config.tokenize = parsed.tokenize;
+			}
 			return config;
 		} catch {
 			return null;
@@ -324,6 +392,9 @@ export class FTSManager {
 	 * Update the search configuration for a collection
 	 */
 	async setSearchConfig(collectionSlug: string, config: SearchConfig): Promise<void> {
+		if (config.tokenize !== undefined) {
+			resolveSearchTokenizer(config.tokenize);
+		}
 		await this.db
 			.updateTable("_emdash_collections")
 			.set({ search_config: JSON.stringify(config) })
@@ -361,7 +432,7 @@ export class FTSManager {
 	 * `title` is not a system column on `ec_*` tables -- it exists only when a
 	 * collection defines a field with slug `title`. Search and suggestion SQL
 	 * that selects `c.title` must check this first; otherwise collections
-	 * without a title field raise "no such column: c.title" (#1178).
+	 * without a title field raise "no such column: c.title".
 	 */
 	async hasTitleColumn(collectionSlug: string): Promise<boolean> {
 		const withTitle = await this.getCollectionsWithTitleColumn([collectionSlug]);
@@ -399,8 +470,11 @@ export class FTSManager {
 	 */
 	async enableSearch(
 		collectionSlug: string,
-		options?: { weights?: Record<string, number> },
+		options?: { weights?: Record<string, number>; tokenize?: SearchTokenizer },
 	): Promise<void> {
+		if (options?.tokenize !== undefined) {
+			resolveSearchTokenizer(options.tokenize);
+		}
 		if (!isSqlite(this.db)) {
 			throw new Error("Full-text search is only available with SQLite databases");
 		}
@@ -414,13 +488,18 @@ export class FTSManager {
 			);
 		}
 
+		const existing = await this.getSearchConfig(collectionSlug);
+		const weights = options?.weights ?? existing?.weights;
+		const tokenize = options?.tokenize ?? existing?.tokenize;
+
 		// Rebuild from scratch to ensure clean state (no duplicate rows)
-		await this.rebuildIndex(collectionSlug, searchableFields, options?.weights);
+		await this.rebuildIndex(collectionSlug, searchableFields, weights, tokenize);
 
 		// Update search config
 		await this.setSearchConfig(collectionSlug, {
 			enabled: true,
-			weights: options?.weights,
+			weights,
+			tokenize,
 		});
 	}
 
@@ -433,7 +512,11 @@ export class FTSManager {
 		if (!isSqlite(this.db)) return;
 		await this.dropFtsTable(collectionSlug);
 		const existing = await this.getSearchConfig(collectionSlug);
-		await this.setSearchConfig(collectionSlug, { enabled: false, weights: existing?.weights });
+		await this.setSearchConfig(collectionSlug, {
+			enabled: false,
+			weights: existing?.weights,
+			tokenize: existing?.tokenize,
+		});
 	}
 
 	/**
@@ -490,14 +573,12 @@ export class FTSManager {
 			}
 
 			console.warn(`FTS index for "${collectionSlug}" is missing. Rebuilding.`);
-			await this.rebuildIndex(collectionSlug, fields, config.weights);
+			await this.rebuildIndex(collectionSlug, fields, config.weights, config.tokenize);
 			return true;
 		}
 
-		// Row count parity check. For external-content FTS tables, COUNT(*)
-		// on the virtual table is answered from the backing content table
-		// (including soft-deleted rows), so we use the docsize shadow table
-		// which tracks rows actually present in the full-text index.
+		// Row count parity check against the docsize shadow table, which
+		// tracks rows actually present in the full-text index.
 		const contentCount = await sql<{ count: number }>`
 			SELECT COUNT(*) as count FROM ${sql.ref(contentTable)}
 			WHERE deleted_at IS NULL
@@ -515,7 +596,7 @@ export class FTSManager {
 				`FTS index for "${collectionSlug}" has ${ftsRows} rows but content table has ${contentRows}. Rebuilding.`,
 			);
 			if (fields.length > 0) {
-				await this.rebuildIndex(collectionSlug, fields, config?.weights);
+				await this.rebuildIndex(collectionSlug, fields, config?.weights, config?.tokenize);
 			}
 			return true;
 		}

package/src/search/index.ts

@@ -7,6 +7,7 @@
 // Types
 export type {
 	SearchConfig,
+	SearchTokenizer,
 	SearchOptions,
 	CollectionSearchOptions,
 	SearchResult,
@@ -15,6 +16,7 @@ export type {
 	Suggestion,
 	SearchStats,
 } from "./types.js";
+export { SEARCH_TOKENIZERS } from "./types.js";
 
 // FTS Manager
 export { FTSManager } from "./fts-manager.js";

package/src/search/query.ts

@@ -165,6 +165,7 @@ export async function searchWithDb(
 			},
 			config.weights,
 			titleColumns.has(collection),
+			config.titleField,
 		);
 
 		allResults.push(...collectionResults);
@@ -223,6 +224,8 @@ export async function searchCollection(
 		query,
 		{ status: options.status, locale: options.locale, limit: offset + limit + 1 },
 		config.weights,
+		undefined,
+		config.titleField,
 	);
 
 	const items = fetched.slice(offset, offset + limit);
@@ -242,6 +245,7 @@ async function searchSingleCollection(
 	options: CollectionSearchOptions,
 	weights?: Record<string, number>,
 	hasTitle?: boolean,
+	titleField?: string,
 ): Promise<SearchResult[]> {
 	// Validate before any raw SQL interpolation
 	validateIdentifier(collection, "collection slug");
@@ -269,11 +273,20 @@ async function searchSingleCollection(
 
 	// `title` is an optional user-defined field, not a system column. Only
 	// select it when the collection actually has one; otherwise the query
-	// errors with "no such column: c.title" (#1178). Multi-collection callers
+	// errors with "no such column: c.title". Multi-collection callers
 	// precompute this in bulk and pass it in; single-collection callers fall
 	// back to the per-collection check.
-	const collectionHasTitle = hasTitle ?? (await ftsManager.hasTitleColumn(collection));
-	const titleExpr = collectionHasTitle ? sql`c.title` : sql`NULL`;
+	// A configured titleField drives the result title so search shows
+	// the same value as the content list. It's a validated existing field, so
+	// the column exists; otherwise fall back to the optional `title` column.
+	let titleExpr;
+	if (titleField) {
+		validateIdentifier(titleField, "title field");
+		titleExpr = sql`c.${sql.ref(titleField)}`;
+	} else {
+		const collectionHasTitle = hasTitle ?? (await ftsManager.hasTitleColumn(collection));
+		titleExpr = collectionHasTitle ? sql`c.title` : sql`NULL`;
+	}
 
 	// Build weight string for bm25 if weights provided
 	// Format: bm25(table, weight1, weight2, ...)
@@ -420,11 +433,19 @@ export async function getSuggestions(
 			continue;
 		}
 
-		// Suggestions are title-based (Suggestion.title is required and the
-		// query filters on `c.title IS NOT NULL`). Collections without a
-		// `title` field can't produce one, and selecting `c.title` would
-		// error, so skip them. See #1178.
-		if (!titleColumns.has(collection)) {
+		// Suggestions are title-based (Suggestion.title is required). A configured
+		// titleField supplies it -- a validated existing column -- so it
+		// takes precedence and keeps autocomplete consistent with search results.
+		// Otherwise fall back to the optional `title` field; collections with
+		// neither can't produce a suggestion and are skipped (selecting a missing
+		// column would error).
+		let titleExpr;
+		if (config.titleField) {
+			validateIdentifier(config.titleField, "title field");
+			titleExpr = sql`c.${sql.ref(config.titleField)}`;
+		} else if (titleColumns.has(collection)) {
+			titleExpr = sql`c.title`;
+		} else {
 			continue;
 		}
 
@@ -448,16 +469,16 @@ export async function getSuggestions(
 				slug: string | null;
 				title: string;
 			}>`
-				SELECT 
+				SELECT
 					c.id,
 					c.slug,
-					c.title
+					${titleExpr} AS title
 				FROM "${sql.raw(ftsTable)}" f
 				JOIN "${sql.raw(contentTable)}" c ON f.id = c.id
 				WHERE "${sql.raw(ftsTable)}" MATCH ${prefixQuery}
 				AND c.status = 'published'
 				AND c.deleted_at IS NULL
-				AND c.title IS NOT NULL
+				AND ${titleExpr} IS NOT NULL
 				${locale ? sql`AND c.locale = ${locale}` : sql``}
 				ORDER BY bm25("${sql.raw(ftsTable)}")
 				LIMIT ${limit}

package/src/search/types.ts

@@ -7,11 +7,19 @@
 /**
  * Search configuration for a collection
  */
+export const SEARCH_TOKENIZERS = ["porter unicode61", "unicode61", "trigram"] as const;
+
+export type SearchTokenizer = (typeof SEARCH_TOKENIZERS)[number];
+
 export interface SearchConfig {
 	/** Whether search is enabled for this collection */
 	enabled: boolean;
 	/** Field weights for ranking (higher = more important) */
 	weights?: Record<string, number>;
+	/** Field slug used as the result title, from the collection's titleField. */
+	titleField?: string;
+	/** FTS5 tokenizer configuration (defaults to English Porter stemming) */
+	tokenize?: SearchTokenizer;
 }
 
 /**