emdash 0.28.1 → 0.30.0

package/src/plugins/types.ts

@@ -9,6 +9,7 @@
  *
  */
 
+import type { Permission } from "@emdash-cms/auth";
 import type { Element } from "@emdash-cms/blocks";
 // The plugin capability vocabulary, the legacy-rename map, and the manifest
 // shape are authored once in @emdash-cms/plugin-types and shared between core
@@ -28,7 +29,9 @@ import {
 	type DeclaredAccess,
 	type DeprecatedPluginCapability,
 	type ManifestHookEntry,
+	type ManifestMcpTool,
 	type ManifestRouteEntry,
+	type PluginMcpManifestConfig,
 	type PluginCapability,
 	type PluginStorageConfig,
 	type StorageCollectionConfig,
@@ -52,7 +55,9 @@ export {
 	type DeclaredAccess,
 	type DeprecatedPluginCapability,
 	type ManifestHookEntry,
+	type ManifestMcpTool,
 	type ManifestRouteEntry,
+	type PluginMcpManifestConfig,
 	type PluginCapability,
 	type PluginStorageConfig,
 	type StorageCollectionConfig,
@@ -213,6 +218,8 @@ export interface ContentItem {
 	createdAt: string;
 	updatedAt: string;
 	publishedAt: string | null;
+	/** Scheduled publication time, if set (e.g. scheduled items or scheduled draft changes). */
+	scheduledAt?: string | null;
 }
 
 export interface ContentListWhere {
@@ -244,6 +251,45 @@ export type ContentWriteInput = Record<string, unknown> & {
 	seo?: ContentItemSeoInput;
 };
 
+/**
+ * Taxonomy definition returned from the taxonomy API (e.g. "category", "tag").
+ */
+export interface TaxonomyDefInfo {
+	name: string;
+	label: string;
+	labelSingular: string | null;
+	hierarchical: boolean;
+	/** Collections this taxonomy is attached to (e.g. `["posts"]`). */
+	collections: string[];
+	locale: string;
+}
+
+/**
+ * Taxonomy term returned from the taxonomy API. Flat shape — for hierarchical
+ * taxonomies the tree is reconstructed via `parentId` (which stores the
+ * parent's locale-agnostic `translationGroup`).
+ */
+export interface TaxonomyTermInfo {
+	id: string;
+	/** Taxonomy name this term belongs to (e.g. "category"). */
+	taxonomy: string;
+	slug: string;
+	label: string;
+	parentId: string | null;
+	/** Term metadata as edited in the admin (`description` etc.). */
+	data: Record<string, unknown> | null;
+	locale: string;
+	translationGroup: string | null;
+}
+
+/**
+ * Options accepted by taxonomy read operations. Omitting `locale` returns
+ * rows for every locale.
+ */
+export interface TaxonomyReadOptions {
+	locale?: string;
+}
+
 /**
  * Content access interface - capability-gated
  */
@@ -258,6 +304,23 @@ export interface ContentAccess {
 	delete?(collection: string, id: string): Promise<boolean>;
 }
 
+/**
+ * Taxonomy access interface — capability-gated on `taxonomies:read`.
+ * Read-only: there is no plugin-facing taxonomy write API.
+ */
+export interface TaxonomyAccess {
+	/** List taxonomy definitions. */
+	getAll(options?: TaxonomyReadOptions): Promise<TaxonomyDefInfo[]>;
+	/** All terms of a taxonomy, ordered by label. */
+	getTerms(taxonomy: string, options?: TaxonomyReadOptions): Promise<TaxonomyTermInfo[]>;
+	/** Terms assigned to a content entry, optionally scoped to one taxonomy. */
+	getEntryTerms(
+		collection: string,
+		entryId: string,
+		options?: TaxonomyReadOptions & { taxonomy?: string },
+	): Promise<TaxonomyTermInfo[]>;
+}
+
 /**
  * Full content access with write operations
  */
@@ -361,6 +424,14 @@ export interface SiteInfo {
 	url: string;
 	/** Site locale (from settings, defaults to "en") */
 	locale: string;
+	/**
+	 * Astro's `trailingSlash` routing policy, from the host's Astro config.
+	 * Plugins that build absolute URLs (sitemap, canonical, hreflang) should
+	 * honor this so the URLs they emit match what the site serves. `createSiteInfo`
+	 * always populates it (defaulting to `"ignore"`, Astro's default); it is
+	 * optional on the type so pre-existing `SiteInfo` construction stays valid.
+	 */
+	trailingSlash?: "always" | "never" | "ignore";
 }
 
 /**
@@ -413,6 +484,9 @@ export interface PluginContext<TStorage extends PluginStorageConfig = PluginStor
 	/** Content access - only if read:content or write:content capability */
 	content?: ContentAccess | ContentAccessWithWrite;
 
+	/** Taxonomy access (read-only) - only if taxonomies:read capability */
+	taxonomies?: TaxonomyAccess;
+
 	/** Media access - only if read:media or write:media capability */
 	media?: MediaAccess | MediaAccessWithWrite;
 
@@ -1114,10 +1188,31 @@ export interface PluginRoute<TInput = unknown> {
 	 * Public routes skip session/token auth and CSRF checks.
 	 */
 	public?: boolean;
+	/** RBAC permission required to invoke the route. Legacy routes default to plugins:manage. */
+	permission?: Permission;
+	/**
+	 * `Cache-Control` header value for successful GET responses, e.g.
+	 * `"public, max-age=60, stale-while-revalidate=300"`. Only honored on
+	 * routes that are also `public: true` — authenticated responses always
+	 * keep the default `private, no-store`. Errors are never cached.
+	 */
+	cacheControl?: string;
 	/** Route handler */
 	handler: (ctx: RouteContext<TInput>) => Promise<unknown>;
 }
 
+export interface PluginMcpToolDefinition {
+	description: string;
+	route: string;
+	input: z.ZodType;
+	output?: z.ZodType;
+	destructive?: boolean;
+}
+
+export interface PluginMcpConfig {
+	tools: Record<string, PluginMcpToolDefinition>;
+}
+
 // =============================================================================
 // Plugin Definition
 // =============================================================================
@@ -1299,6 +1394,9 @@ export interface PluginDefinition<TStorage extends PluginStorageConfig = PluginS
 	/** API routes */
 	routes?: Record<string, PluginRoute>;
 
+	/** Routes explicitly exposed as agent-callable MCP tools. */
+	mcp?: PluginMcpConfig;
+
 	/** Admin UI configuration */
 	admin?: PluginAdminConfig;
 }
@@ -1314,6 +1412,7 @@ export interface ResolvedPlugin<TStorage extends PluginStorageConfig = PluginSto
 	storage: TStorage;
 	hooks: ResolvedPluginHooks;
 	routes: Record<string, PluginRoute>;
+	mcp?: PluginMcpConfig;
 	admin: PluginAdminConfig;
 }
 
@@ -1394,6 +1493,7 @@ export interface PluginManifest {
 	hooks: Array<ManifestHookEntry | HookName>;
 	/** Route declarations — either plain name strings or structured objects */
 	routes: Array<ManifestRouteEntry | string>;
+	mcp?: PluginMcpManifestConfig;
 	admin: PluginAdminConfig;
 }
 

package/src/schema/byline-registry.ts

@@ -627,7 +627,7 @@ export class BylineSchemaRegistry {
 		// payload silently. Today's `BylineFieldValidation` is `{ options? }`
 		// only, so this branch is a pass-through; left explicit for clarity.
 		const { options: _drop, ...rest } = validation;
-		return Object.keys(rest).length === 0 ? null : (rest as BylineFieldValidation);
+		return Object.keys(rest).length === 0 ? null : rest;
 	}
 }
 

package/src/schema/registry.ts

@@ -1,5 +1,4 @@
-import type { Kysely } from "kysely";
-import type { Selectable } from "kysely";
+import type { ColumnDataType, CreateTableBuilder, Insertable, Kysely, Selectable } from "kysely";
 import { sql } from "kysely";
 import { ulid } from "ulidx";
 
@@ -39,6 +38,12 @@ const WORD_BOUNDARY_PATTERN = /\b\w/g;
 
 /** Valid column types for runtime validation */
 const COLUMN_TYPES: ReadonlySet<string> = new Set(["TEXT", "REAL", "INTEGER", "JSON"]);
+const COLUMN_TYPE_TO_DATA_TYPE = {
+	TEXT: "text",
+	REAL: "real",
+	INTEGER: "integer",
+	JSON: "json",
+} satisfies Record<ColumnType, ColumnDataType>;
 
 /** Valid collection source prefixes/values */
 const VALID_SOURCES: ReadonlySet<string> = new Set(["manual", "discovered", "seed"]);
@@ -64,6 +69,10 @@ const VALID_COLLECTION_SUPPORTS: ReadonlySet<string> = new Set<CollectionSupport
 	"seo",
 ]);
 
+// Each _emdash_fields row uses 15 bound parameters. Six rows keep every
+// multi-row INSERT below D1's 100-parameter statement limit.
+const SEED_FIELD_INSERT_BATCH_SIZE = 6;
+
 function isCollectionSupport(value: unknown): value is CollectionSupport {
 	return typeof value === "string" && VALID_COLLECTION_SUPPORTS.has(value);
 }
@@ -264,6 +273,113 @@ export class SchemaRegistry {
 		return collection;
 	}
 
+	/**
+	 * Create a seed-owned collection and all of its fields in bulk.
+	 *
+	 * Fresh seeds can define dozens of fields. Creating them through
+	 * `createField` performs multiple reads, one ALTER TABLE, and one media
+	 * usage invalidation per field, which can exhaust D1's per-request query
+	 * budget. This path validates the full schema before mutating it, creates
+	 * the complete content table in one statement, and inserts field metadata
+	 * in parameter-safe batches.
+	 */
+	async createSeedCollection(
+		input: Omit<CreateCollectionInput, "source">,
+		fields: readonly CreateFieldInput[],
+	): Promise<void> {
+		this.validateSlug(input.slug, "collection");
+		if (RESERVED_COLLECTION_SLUGS.includes(input.slug)) {
+			throw new SchemaError(`Collection slug "${input.slug}" is reserved`, "RESERVED_SLUG");
+		}
+
+		const existing = await this.getCollection(input.slug);
+		if (existing) {
+			throw new SchemaError(`Collection "${input.slug}" already exists`, "COLLECTION_EXISTS");
+		}
+
+		const fieldSlugs = new Set<string>();
+		for (const field of fields) {
+			this.validateSlug(field.slug, "field");
+			if (RESERVED_FIELD_SLUGS.includes(field.slug)) {
+				throw new SchemaError(`Field slug "${field.slug}" is reserved`, "RESERVED_SLUG");
+			}
+			if (fieldSlugs.has(field.slug)) {
+				throw new SchemaError(
+					`Field "${field.slug}" already exists in collection "${input.slug}"`,
+					"FIELD_EXISTS",
+				);
+			}
+			fieldSlugs.add(field.slug);
+		}
+
+		const collectionId = ulid();
+		const supports = input.supports ?? ["drafts", "revisions"];
+		const hasSeo = input.hasSeo ?? supports.includes("seo") ?? false;
+		let maxSortOrder = -1;
+		const fieldRows: Insertable<FieldTable>[] = fields.map((field) => {
+			const sortOrder = field.sortOrder ?? maxSortOrder + 1;
+			maxSortOrder = Math.max(maxSortOrder, sortOrder);
+
+			return {
+				id: ulid(),
+				collection_id: collectionId,
+				slug: field.slug,
+				label: field.label,
+				type: field.type,
+				column_type: FIELD_TYPE_TO_COLUMN[field.type],
+				required: field.required ? 1 : 0,
+				unique: field.unique ? 1 : 0,
+				default_value: field.defaultValue !== undefined ? JSON.stringify(field.defaultValue) : null,
+				validation: field.validation ? JSON.stringify(field.validation) : null,
+				widget: field.widget ?? null,
+				options: field.options ? JSON.stringify(field.options) : null,
+				sort_order: sortOrder,
+				searchable: field.searchable ? 1 : 0,
+				translatable: field.translatable === false ? 0 : 1,
+			};
+		});
+
+		let schemaMutated = false;
+		try {
+			await withTransaction(this.db, async (trx) => {
+				await trx
+					.insertInto("_emdash_collections")
+					.values({
+						id: collectionId,
+						slug: input.slug,
+						label: input.label,
+						label_singular: input.labelSingular ?? null,
+						description: input.description ?? null,
+						icon: input.icon ?? null,
+						supports: JSON.stringify(supports),
+						source: "seed",
+						has_seo: hasSeo ? 1 : 0,
+						comments_enabled: input.commentsEnabled ? 1 : 0,
+						url_pattern: input.urlPattern ?? null,
+					})
+					.execute();
+				schemaMutated = true;
+
+				await this.createContentTable(input.slug, trx, fields);
+
+				for (const fieldBatch of chunks(fieldRows, SEED_FIELD_INSERT_BATCH_SIZE)) {
+					await trx.insertInto("_emdash_fields").values(fieldBatch).execute();
+				}
+			});
+
+			await markContentMediaUsageCollectionStaleSafely(this.db, input.slug, "CONTENT_USAGE_STALE");
+		} catch (error) {
+			if (schemaMutated) {
+				await markContentMediaUsageCollectionStaleSafely(
+					this.db,
+					input.slug,
+					"CONTENT_USAGE_STALE",
+				);
+			}
+			throw error;
+		}
+	}
+
 	/**
 	 * Update a collection
 	 */
@@ -787,11 +903,15 @@ export class SchemaRegistry {
 	/**
 	 * Create a content table for a collection
 	 */
-	private async createContentTable(slug: string, db?: Kysely<Database>): Promise<void> {
+	private async createContentTable(
+		slug: string,
+		db?: Kysely<Database>,
+		fields: readonly CreateFieldInput[] = [],
+	): Promise<void> {
 		const conn = db ?? this.db;
 		const tableName = this.getTableName(slug);
 
-		await conn.schema
+		let table: CreateTableBuilder<string, string> = conn.schema
 			.createTable(tableName)
 			.addColumn("id", "text", (col) => col.primaryKey())
 			.addColumn("slug", "text")
@@ -807,7 +927,23 @@ export class SchemaRegistry {
 			.addColumn("live_revision_id", "text", (col) => col.references("revisions.id"))
 			.addColumn("draft_revision_id", "text", (col) => col.references("revisions.id"))
 			.addColumn("locale", "text", (col) => col.notNull().defaultTo("en"))
-			.addColumn("translation_group", "text")
+			.addColumn("translation_group", "text");
+
+		for (const field of fields) {
+			const columnName = this.getColumnName(field.slug);
+			const columnType = COLUMN_TYPE_TO_DATA_TYPE[FIELD_TYPE_TO_COLUMN[field.type]];
+			table = table.addColumn(columnName, columnType, (column) => {
+				if (!field.required) return column;
+
+				const defaultValue =
+					field.defaultValue !== undefined
+						? this.formatDefaultValue(field.defaultValue, field.type)
+						: this.getEmptyDefault(field.type);
+				return column.notNull().defaultTo(sql.raw(defaultValue));
+			});
+		}
+
+		await table
 			.addUniqueConstraint(`${tableName}_slug_locale_unique`, ["slug", "locale"])
 			.execute();
 

package/src/search/fts-manager.ts

@@ -355,6 +355,40 @@ export class FTSManager {
 		return fields.map((f) => f.slug);
 	}
 
+	/**
+	 * Whether a collection has a user-defined `title` field.
+	 *
+	 * `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).
+	 */
+	async hasTitleColumn(collectionSlug: string): Promise<boolean> {
+		const withTitle = await this.getCollectionsWithTitleColumn([collectionSlug]);
+		return withTitle.has(collectionSlug);
+	}
+
+	/**
+	 * Bulk variant of `hasTitleColumn()`: which of the given collections have
+	 * a user-defined `title` field. One query instead of one `hasTitleColumn`
+	 * round-trip pair per collection -- callers that check this once per
+	 * collection in a loop (multi-collection search, suggestions) should use
+	 * this instead (AGENTS.md: "one query beats two").
+	 */
+	async getCollectionsWithTitleColumn(collectionSlugs: string[]): Promise<Set<string>> {
+		if (collectionSlugs.length === 0) return new Set();
+
+		const rows = await this.db
+			.selectFrom("_emdash_fields as f")
+			.innerJoin("_emdash_collections as c", "c.id", "f.collection_id")
+			.select(["c.slug as collection_slug"])
+			.where("f.slug", "=", "title")
+			.execute();
+
+		const withTitle = new Set(rows.map((r) => r.collection_slug));
+		return new Set(collectionSlugs.filter((slug) => withTitle.has(slug)));
+	}
+
 	/**
 	 * Enable search for a collection.
 	 *

package/src/search/match.ts

@@ -0,0 +1,50 @@
+/**
+ * FTS5 match-expression builder for structured (non-user-syntax) queries.
+ *
+ * Unlike `escapeQuery` in `query.ts` (which powers the public search API and
+ * deliberately passes through FTS5 operators like AND/OR/NOT), this builder
+ * treats the input as plain words: every term is double-quoted with interior
+ * quotes escaped, so the result can never produce an FTS5 syntax error. Used
+ * by the admin content-list filter, where the input is a filter box, not a
+ * search-syntax field.
+ */
+
+const WHITESPACE_RE = /\s+/;
+const DOUBLE_QUOTE_RE = /"/g;
+const GLOB_SPECIAL_RE = /[[\]*?]/g;
+
+/**
+ * Build a prefix-matching FTS5 MATCH expression from free-form input.
+ *
+ * `hello wor` becomes `"hello"* "wor"*` — implicit AND with per-term prefix
+ * matching. Returns `""` when the input contains no usable terms; callers
+ * must fall back to their non-FTS path in that case.
+ */
+export function buildFtsPrefixMatch(input: string): string {
+	const terms = input
+		.trim()
+		.split(WHITESPACE_RE)
+		.map((term) => term.replace(DOUBLE_QUOTE_RE, '""'))
+		.filter((term) => term.length > 0);
+
+	if (terms.length === 0) return "";
+	return terms.map((term) => `"${term}"*`).join(" ");
+}
+
+/**
+ * Build a GLOB prefix pattern from free-form input, treating GLOB
+ * metacharacters (`* ? [ ]`) literally by wrapping each in a character
+ * class (GLOB has no ESCAPE clause).
+ *
+ * GLOB (unlike default LIKE) is case-sensitive, so with a lowercased
+ * pattern it matches slugs (lowercase by construction) while staying
+ * servable by the ordinary BINARY-collated slug index — SQLite's GLOB
+ * optimization turns a `prefix*` pattern into an index range scan.
+ */
+export function buildSlugGlobPrefix(input: string): string {
+	const escaped = input
+		.trim()
+		.toLowerCase()
+		.replace(GLOB_SPECIAL_RE, (c) => `[${c}]`);
+	return `${escaped}*`;
+}

package/src/search/query.ts

@@ -7,6 +7,7 @@
 import type { Kysely } from "kysely";
 import { sql } from "kysely";
 
+import { encodeCursor, decodeCursor, InvalidCursorError } from "../database/repositories/types.js";
 import type { Database } from "../database/types.js";
 import { validateIdentifier } from "../database/validate.js";
 import { getDb } from "../loader.js";
@@ -21,6 +22,44 @@ import type {
 	SearchStats,
 } from "./types.js";
 
+/**
+ * Marker stored in the `id` slot of a search pagination cursor.
+ *
+ * Search results are merged from per-collection FTS queries and re-sorted by
+ * score, so there is no single stable keyset column to encode (the way
+ * `getEmDashCollection` encodes `(orderValue, id)`). We page over the merged,
+ * score-sorted set by offset instead, carried as the cursor's `orderValue`.
+ * Reusing `encodeCursor`/`decodeCursor` keeps the opaque base64-JSON shape and
+ * the `InvalidCursorError` handling consistent with the rest of the API.
+ */
+const SEARCH_CURSOR_MARKER = "search";
+
+/** Encode the next-page offset into an opaque search cursor. */
+function encodeSearchCursor(offset: number): string {
+	return encodeCursor(String(offset), SEARCH_CURSOR_MARKER);
+}
+
+/**
+ * Decode a search cursor back to its offset. Throws `InvalidCursorError` for a
+ * malformed cursor or one that doesn't carry a non-negative integer offset, so
+ * a client pagination bug surfaces immediately rather than silently restarting
+ * from the first page.
+ */
+/** Upper bound on a decoded search offset, to cap the per-collection row fetch a forged cursor can trigger. */
+const MAX_SEARCH_OFFSET = 10_000;
+
+function decodeSearchOffset(cursor: string): number {
+	const { orderValue, id } = decodeCursor(cursor);
+	if (id !== SEARCH_CURSOR_MARKER) {
+		throw new InvalidCursorError(cursor);
+	}
+	const offset = Number(orderValue);
+	if (!Number.isInteger(offset) || offset < 0 || offset > MAX_SEARCH_OFFSET) {
+		throw new InvalidCursorError(cursor);
+	}
+	return offset;
+}
+
 /** Pattern to split on whitespace for query term extraction */
 const WHITESPACE_SPLIT_PATTERN = /\s+/;
 const FTS_OPERATORS_PATTERN = /\b(AND|OR|NOT|NEAR)\b/i;
@@ -86,6 +125,7 @@ export async function searchWithDb(
 	const ftsManager = new FTSManager(db);
 	const limit = options.limit ?? 20;
 	const status = options.status ?? "published";
+	const offset = options.cursor ? decodeSearchOffset(options.cursor) : 0;
 
 	// Get searchable collections
 	let collections = options.collections;
@@ -97,8 +137,15 @@ export async function searchWithDb(
 		return { items: [] };
 	}
 
+	// To rank the merged window [offset, offset + limit) correctly, each
+	// collection must contribute its own top (offset + limit) rows — in the
+	// worst case the entire window comes from one collection. The extra +1
+	// row detects whether a further page exists.
+	const perCollectionLimit = offset + limit + 1;
+
 	// Search each collection and merge results
 	const allResults: SearchResult[] = [];
+	const titleColumns = await ftsManager.getCollectionsWithTitleColumn(collections);
 
 	for (const collection of collections) {
 		const config = await ftsManager.getSearchConfig(collection);
@@ -113,9 +160,10 @@ export async function searchWithDb(
 			{
 				status,
 				locale: options.locale,
-				limit: limit * 2, // Get extra for merging
+				limit: perCollectionLimit,
 			},
 			config.weights,
+			titleColumns.has(collection),
 		);
 
 		allResults.push(...collectionResults);
@@ -124,10 +172,13 @@ export async function searchWithDb(
 	// Sort by score descending
 	allResults.sort((a, b) => b.score - a.score);
 
-	// Apply limit
-	const items = allResults.slice(0, limit);
+	// Page the merged set by offset. A nextCursor is issued only when at least
+	// one result exists past this page.
+	const items = allResults.slice(offset, offset + limit);
+	const hasMore = allResults.length > offset + limit;
+	const nextCursor = hasMore ? encodeSearchCursor(offset + limit) : undefined;
 
-	return { items };
+	return { items, nextCursor };
 }
 
 /**
@@ -159,9 +210,25 @@ export async function searchCollection(
 		return { items: [] };
 	}
 
-	const items = await searchSingleCollection(db, collection, query, options, config.weights);
+	const limit = options.limit ?? 20;
+	const offset = options.cursor ? decodeSearchOffset(options.cursor) : 0;
+
+	// Over-fetch the [offset, offset + limit) window plus one row to detect a
+	// further page, then slice. Keeps the FTS SQL (LIMIT-only) unchanged and
+	// the cursor contract identical to the cross-collection path.
+	const fetched = await searchSingleCollection(
+		db,
+		collection,
+		query,
+		{ status: options.status, locale: options.locale, limit: offset + limit + 1 },
+		config.weights,
+	);
+
+	const items = fetched.slice(offset, offset + limit);
+	const hasMore = fetched.length > offset + limit;
+	const nextCursor = hasMore ? encodeSearchCursor(offset + limit) : undefined;
 
-	return { items };
+	return { items, nextCursor };
 }
 
 /**
@@ -173,6 +240,7 @@ async function searchSingleCollection(
 	query: string,
 	options: CollectionSearchOptions,
 	weights?: Record<string, number>,
+	hasTitle?: boolean,
 ): Promise<SearchResult[]> {
 	// Validate before any raw SQL interpolation
 	validateIdentifier(collection, "collection slug");
@@ -198,6 +266,14 @@ async function searchSingleCollection(
 	// Get searchable fields for snippet generation
 	const searchableFields = await ftsManager.getSearchableFields(collection);
 
+	// `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
+	// 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`;
+
 	// Build weight string for bm25 if weights provided
 	// Format: bm25(table, weight1, weight2, ...)
 	// First two weights are for 'id' and 'locale' columns (UNINDEXED, so 0)
@@ -225,11 +301,11 @@ async function searchSingleCollection(
 			snippet: string | null;
 			score: number;
 		}>`
-		SELECT 
+		SELECT
 			c.id,
 			c.slug,
 			c.locale,
-			c.title,
+			${titleExpr} as title,
 			snippet("${sql.raw(ftsTable)}", 2, '<mark>', '</mark>', '...', 32) as snippet,
 			${sql.raw(bm25Expr)} as score
 		FROM "${sql.raw(ftsTable)}" f
@@ -334,14 +410,23 @@ export async function getSuggestions(
 	}
 
 	const suggestions: Suggestion[] = [];
+	const ftsManager = new FTSManager(db);
+	const titleColumns = await ftsManager.getCollectionsWithTitleColumn(collections);
 
 	for (const collection of collections) {
-		const ftsManager = new FTSManager(db);
 		const config = await ftsManager.getSearchConfig(collection);
 		if (!config?.enabled) {
 			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)) {
+			continue;
+		}
+
 		// Validate before raw SQL interpolation
 		validateIdentifier(collection, "collection slug");