emdash 0.33.0 → 0.34.0

package/src/schema/types.ts

@@ -48,6 +48,23 @@ export const FIELD_TYPES: readonly FieldType[] = [
 	"repeater",
 ] as const;
 
+/** Scalar field types that can be backed by a content-list query index. */
+export const INDEXABLE_FIELD_TYPES: ReadonlySet<FieldType> = new Set([
+	"string",
+	"url",
+	"number",
+	"integer",
+	"boolean",
+	"datetime",
+	"select",
+	"reference",
+	"slug",
+]);
+
+export function isIndexableFieldType(type: FieldType): boolean {
+	return INDEXABLE_FIELD_TYPES.has(type);
+}
+
 /**
  * SQLite column types that map from field types
  */
@@ -155,6 +172,14 @@ export interface FieldWidgetOptions {
 	[key: string]: unknown;
 }
 
+export const MAX_COLLECTION_LIST_COLUMNS = 4;
+
+/** Collection-level admin presentation options. */
+export interface CollectionAdminConfig {
+	/** Custom field slugs to show in the content list. */
+	listColumns?: string[];
+}
+
 /**
  * A collection definition
  */
@@ -165,12 +190,19 @@ export interface Collection {
 	labelSingular?: string;
 	description?: string;
 	icon?: string;
+	admin?: CollectionAdminConfig;
 	supports: CollectionSupport[];
 	source?: CollectionSource;
 	/** Whether this collection has SEO metadata fields enabled */
 	hasSeo: boolean;
+	/** Field slug powering the admin list Title column. Defaults to the standard title display. */
+	titleField?: string;
+	/** Field slug powering the admin list Date column. Must be a `datetime` field. Defaults to last-updated. */
+	dateField?: string;
 	/** URL pattern with {slug} placeholder (e.g. "/{slug}", "/blog/{slug}") */
 	urlPattern?: string;
+	/** Whether published entries require a public slug. Defaults to true. */
+	routable?: boolean;
 	/**
 	 * Omit this collection's auto-generated entry from the admin sidebar.
 	 * The collection stays fully functional everywhere else (API, MCP, hooks,
@@ -214,6 +246,8 @@ export interface Field {
 	options?: FieldWidgetOptions;
 	sortOrder: number;
 	searchable: boolean;
+	/** Whether this field has a physical index for structured list queries. */
+	indexed: boolean;
 	/** Whether this field is translatable (default true). Non-translatable fields are synced across locales. */
 	translatable: boolean;
 	createdAt: string;
@@ -228,9 +262,11 @@ export interface CreateCollectionInput {
 	labelSingular?: string;
 	description?: string;
 	icon?: string;
+	admin?: CollectionAdminConfig;
 	supports?: CollectionSupport[];
 	source?: CollectionSource;
 	urlPattern?: string;
+	routable?: boolean;
 	hasSeo?: boolean;
 	/** Omit the auto-generated admin sidebar entry (defaults to false) */
 	hidden?: boolean;
@@ -247,8 +283,10 @@ export interface UpdateCollectionInput {
 	labelSingular?: string;
 	description?: string;
 	icon?: string;
+	admin?: CollectionAdminConfig;
 	supports?: CollectionSupport[];
-	urlPattern?: string;
+	urlPattern?: string | null;
+	routable?: boolean;
 	hasSeo?: boolean;
 	/** Omit the auto-generated admin sidebar entry */
 	hidden?: boolean;
@@ -258,6 +296,10 @@ export interface UpdateCollectionInput {
 	commentsModeration?: "all" | "first_time" | "none";
 	commentsClosedAfterDays?: number;
 	commentsAutoApproveUsers?: boolean;
+	/** Field slug for the Title column; `null`/`""` clears back to the default. */
+	titleField?: string | null;
+	/** Datetime field slug for the Date column; `null`/`""` clears back to the default. */
+	dateField?: string | null;
 }
 
 /**
@@ -276,6 +318,8 @@ export interface CreateFieldInput {
 	sortOrder?: number;
 	/** Whether this field should be indexed for search */
 	searchable?: boolean;
+	/** Create a physical index for structured sorting. */
+	indexed?: boolean;
 	/** Whether this field is translatable (default true). Non-translatable fields are synced across locales. */
 	translatable?: boolean;
 }
@@ -286,13 +330,9 @@ export interface CreateFieldInput {
 export interface UpdateFieldInput {
 	label?: string;
 	/**
-	 * Change the field's type. Only type changes that keep the same underlying
-	 * column type (per `FIELD_TYPE_TO_COLUMN`) are allowed — e.g. `string` to
-	 * `slug` (both TEXT). A change that would alter the column affinity (e.g.
-	 * `text` TEXT to `portableText` JSON) is rejected, because there is no
-	 * in-place column migration and silently rewriting the metadata would
-	 * desync `column_type` from the real `ec_*` column. Omit to keep the
-	 * current type.
+	 * Change the field's type. Only storage-compatible text aliases (`string`,
+	 * `text`, and `slug`) can be changed in place. Other changes require an
+	 * explicit content migration. Omit to keep the current type.
 	 */
 	type?: FieldType;
 	required?: boolean;
@@ -304,6 +344,8 @@ export interface UpdateFieldInput {
 	sortOrder?: number;
 	/** Whether this field should be indexed for search */
 	searchable?: boolean;
+	/** Create or remove the physical index used by structured sorting. */
+	indexed?: boolean;
 	/** Whether this field is translatable (default true). Non-translatable fields are synced across locales. */
 	translatable?: boolean;
 }

package/src/schema/url-pattern.ts

@@ -0,0 +1,33 @@
+const URL_PARAM_PATTERN = /\{(\w+)\}/g;
+const REGEX_SPECIAL_CHARACTERS = /[.*+?^${}()|[\]\\]/g;
+const INVALID_LITERAL_PATTERN = /[{}]/;
+
+function escapeRegex(literal: string): string {
+	return literal.replace(REGEX_SPECIAL_CHARACTERS, "\\$&");
+}
+
+export function compileUrlPattern(pattern: string): { regex: RegExp; paramNames: string[] } {
+	const paramNames: string[] = [];
+	let regexSource = "";
+	let previousIndex = 0;
+
+	for (const match of pattern.matchAll(URL_PARAM_PATTERN)) {
+		const matchIndex = match.index;
+		const literal = pattern.slice(previousIndex, matchIndex);
+		if (INVALID_LITERAL_PATTERN.test(literal)) throw new Error("Invalid URL pattern placeholder");
+		regexSource += escapeRegex(literal);
+
+		const name = match[1];
+		paramNames.push(name);
+		regexSource += "([^/]+)";
+		previousIndex = matchIndex + match[0].length;
+	}
+
+	const trailingLiteral = pattern.slice(previousIndex);
+	if (INVALID_LITERAL_PATTERN.test(trailingLiteral)) {
+		throw new Error("Invalid URL pattern placeholder");
+	}
+	regexSource += escapeRegex(trailingLiteral);
+
+	return { regex: new RegExp(`^${regexSource}$`), paramNames };
+}

package/src/schema/zod-generator.ts

@@ -1,7 +1,7 @@
 import { z, type ZodTypeAny } from "zod";
 
 import { hashString } from "../utils/hash.js";
-import type { Field, FieldType, CollectionWithFields } from "./types.js";
+import type { CollectionWithFields, Field, FieldType, RepeaterSubField } from "./types.js";
 
 /** Pattern to split on underscores, hyphens, and spaces for PascalCase conversion */
 const PASCAL_CASE_SPLIT_PATTERN = /[_\-\s]+/;
@@ -58,7 +58,7 @@ export function generateFieldSchema(field: Field): ZodTypeAny {
 /**
  * Get base Zod schema for a field type
  */
-function getBaseSchema(type: FieldType, field: Field): ZodTypeAny {
+function getBaseSchema(type: FieldType, field: Pick<Field, "validation">): ZodTypeAny {
 	switch (type) {
 		case "url":
 			return z.string().url();
@@ -114,6 +114,9 @@ function getBaseSchema(type: FieldType, field: Field): ZodTypeAny {
 			return z.array(z.string());
 		}
 
+		case "repeater":
+			return z.array(generateRepeaterRowSchema(field.validation?.subFields ?? []));
+
 		case "portableText":
 			// Portable Text is an array of blocks. We require `_type` because
 			// renderers dispatch on it, but `_key` is intentionally optional:
@@ -139,6 +142,10 @@ function getBaseSchema(type: FieldType, field: Field): ZodTypeAny {
 				alt: z.string().optional(),
 				width: z.number().optional(),
 				height: z.number().optional(),
+				filename: z.string().optional(),
+				mimeType: z.string().optional(),
+				blurhash: z.string().optional(),
+				dominantColor: z.string().optional(),
 				/** Provider ID (e.g. "local", "cloudflare-images") */
 				provider: z.string().optional(),
 				/** Admin-side preview URL for external providers (not persisted by plugins) */
@@ -150,6 +157,7 @@ function getBaseSchema(type: FieldType, field: Field): ZodTypeAny {
 		case "file":
 			return z.object({
 				id: z.string(),
+				url: z.string().optional(),
 				src: z.string().optional(),
 				filename: z.string().optional(),
 				mimeType: z.string().optional(),
@@ -171,6 +179,29 @@ function getBaseSchema(type: FieldType, field: Field): ZodTypeAny {
 	}
 }
 
+function generateRepeaterRowSchema(
+	subFields: readonly RepeaterSubField[],
+): z.ZodObject<Record<string, ZodTypeAny>> {
+	const shape: Record<string, ZodTypeAny> = {};
+
+	for (const subField of subFields) {
+		let schema = getBaseSchema(subField.type, {
+			validation: subField.options ? { options: subField.options } : undefined,
+		});
+
+		if (subField.required && schema instanceof z.ZodString) {
+			schema = schema.min(1, "required (empty value not allowed)");
+		}
+		if (!subField.required) {
+			schema = schema.nullish();
+		}
+
+		shape[subField.slug] = schema;
+	}
+
+	return z.object(shape).passthrough();
+}
+
 /**
  * Apply validation rules to a schema
  */
@@ -205,6 +236,17 @@ function applyValidation(schema: ZodTypeAny, field: Field): ZodTypeAny {
 		return numSchema;
 	}
 
+	if (field.type === "repeater" && schema instanceof z.ZodArray) {
+		let arraySchema = schema;
+		if (validation.minItems !== undefined) {
+			arraySchema = arraySchema.min(validation.minItems);
+		}
+		if (validation.maxItems !== undefined) {
+			arraySchema = arraySchema.max(validation.maxItems);
+		}
+		return arraySchema;
+	}
+
 	return schema;
 }
 
@@ -378,7 +420,10 @@ export async function generateSchemaHash(collections: CollectionWithFields[]): P
 /**
  * Map field type to TypeScript type
  */
-function fieldTypeToTypeScript(field: Field): string {
+function fieldTypeToTypeScript(field: {
+	type: Field["type"];
+	validation?: Field["validation"];
+}): string {
 	switch (field.type) {
 		case "string":
 		case "text":
@@ -408,14 +453,41 @@ function fieldTypeToTypeScript(field: Field): string {
 			}
 			return "string[]";
 
+		case "repeater": {
+			const subFields = field.validation?.subFields;
+			// `validation` is unvalidated JSON on the seed and registry paths.
+			if (!Array.isArray(subFields) || subFields.length === 0) return "unknown";
+
+			// A duplicated slug keeps its first position and last declaration, as
+			// `generateRepeaterRowSchema`'s `shape[subField.slug]` does.
+			const members = new Map<string, string>();
+
+			for (const subField of subFields) {
+				const type = fieldTypeToTypeScript({
+					type: subField.type,
+					validation: subField.options ? { options: subField.options } : undefined,
+				});
+				// A sub-field slug is not guaranteed to be a valid identifier, so it is
+				// quoted rather than emitted bare.
+				const name = JSON.stringify(subField.slug);
+				// A sub-field that is not required may be null at runtime.
+				members.set(
+					subField.slug,
+					subField.required ? `${name}: ${type}` : `${name}?: ${type} | null`,
+				);
+			}
+
+			return `{ ${[...members.values()].join("; ")} }[]`;
+		}
+
 		case "portableText":
 			return "PortableTextBlock[]";
 
 		case "image":
-			return "{ id: string; src?: string; alt?: string; width?: number; height?: number; provider?: string; previewUrl?: string; meta?: Record<string, unknown> }";
+			return "{ id: string; src?: string; alt?: string; width?: number; height?: number; filename?: string; mimeType?: string; blurhash?: string; dominantColor?: string; provider?: string; previewUrl?: string; meta?: Record<string, unknown> }";
 
 		case "file":
-			return "{ id: string; src?: string; filename?: string; mimeType?: string; size?: number; provider?: string; meta?: Record<string, unknown> }";
+			return "{ id: string; url?: string; src?: string; filename?: string; mimeType?: string; size?: number; provider?: string; meta?: Record<string, unknown> }";
 
 		case "reference":
 			// Could be enhanced to include the referenced collection type

package/src/search/fts-manager.ts

@@ -93,25 +93,23 @@ export class FTSManager {
 		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.
+		// 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='${tokenizer}'
 			)
 		`)
@@ -121,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.
 	 *
@@ -129,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);
@@ -165,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);
@@ -279,20 +311,30 @@ export class FTSManager {
 	}
 
 	/**
-	 * 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);
@@ -304,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();
 
@@ -323,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> = {};
@@ -389,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]);
@@ -534,10 +577,8 @@ export class FTSManager {
 			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