emdash 0.32.0 → 0.34.0

package/src/schema/registry.ts

@@ -1,4 +1,11 @@
-import type { ColumnDataType, CreateTableBuilder, Insertable, Kysely, Selectable } from "kysely";
+import type {
+	ColumnDataType,
+	CreateTableBuilder,
+	Insertable,
+	Kysely,
+	Selectable,
+	Updateable,
+} from "kysely";
 import { sql } from "kysely";
 import { ulid } from "ulidx";
 
@@ -6,14 +13,27 @@ import { currentTimestamp, listTablesLike, tableExists } from "../database/diale
 import { withTransaction } from "../database/transaction.js";
 import type { CollectionTable, Database, FieldTable } from "../database/types.js";
 import { validateIdentifier } from "../database/validate.js";
+import {
+	canResumeMediaUsageCollectionCapture,
+	finalizeMediaUsageCollectionCapture,
+	installPreparedMediaUsageCollectionCapture,
+	markMediaUsageCollectionCaptureReady,
+	prepareMediaUsageCollectionCapture,
+} from "../media/usage/activation.js";
+import {
+	deleteActivatedMediaUsageCollection,
+	isMediaUsageCollectionSlugDeleting,
+} from "../media/usage/collection-deletion.js";
 import {
 	deleteContentMediaUsageCollection,
+	invalidateContentMediaUsageSchemaChange,
 	markContentMediaUsageCollectionStaleSafely,
 } from "../media/usage/content-refresh.js";
 import { FTSManager } from "../search/fts-manager.js";
 import { chunks, SQL_BATCH_SIZE } from "../utils/chunks.js";
 import {
 	type Collection,
+	type CollectionAdminConfig,
 	type CollectionSource,
 	type CollectionSupport,
 	type ColumnType,
@@ -25,6 +45,7 @@ import {
 	type CollectionWithFields,
 	type FieldType,
 	FIELD_TYPE_TO_COLUMN,
+	isIndexableFieldType,
 	RESERVED_FIELD_SLUGS,
 	RESERVED_COLLECTION_SLUGS,
 } from "./types.js";
@@ -35,6 +56,7 @@ const EC_PREFIX_PATTERN = /^ec_/;
 const SINGLE_QUOTE_PATTERN = /'/g;
 const UNDERSCORE_PATTERN = /_/g;
 const WORD_BOUNDARY_PATTERN = /\b\w/g;
+const FIELD_ID_PATTERN = /^[0-9A-Z]{26}$/;
 
 /** Valid column types for runtime validation */
 const COLUMN_TYPES: ReadonlySet<string> = new Set(["TEXT", "REAL", "INTEGER", "JSON"]);
@@ -44,6 +66,10 @@ const COLUMN_TYPE_TO_DATA_TYPE = {
 	INTEGER: "integer",
 	JSON: "json",
 } satisfies Record<ColumnType, ColumnDataType>;
+const TEXT_ALIAS_FIELD_TYPES: ReadonlySet<FieldType> = new Set(["string", "text", "slug"]);
+
+/** Field types usable as a `titleField` — plain text that reads well as a title. */
+const TITLE_FIELD_TYPES: ReadonlySet<string> = new Set(["string", "text", "slug"]);
 
 /** Valid collection source prefixes/values */
 const VALID_SOURCES: ReadonlySet<string> = new Set(["manual", "discovered", "seed"]);
@@ -69,10 +95,32 @@ const VALID_COLLECTION_SUPPORTS: ReadonlySet<string> = new Set<CollectionSupport
 	"seo",
 ]);
 
-// Each _emdash_fields row uses 15 bound parameters. Six rows keep every
+// Each _emdash_fields row uses 16 bound parameters. Six rows keep every
 // multi-row INSERT below D1's 100-parameter statement limit.
 const SEED_FIELD_INSERT_BATCH_SIZE = 6;
 
+/**
+ * Rank given to collections without an explicit `sort_order`. SQLite sorts
+ * NULL first on ASC while Postgres sorts it last, so the fallback is
+ * materialised with COALESCE rather than left to the dialect.
+ */
+const UNORDERED_COLLECTION_RANK = 2147483647;
+
+/**
+ * Collection ordering shared by every list read: explicit `sort_order`
+ * first (ascending), then alphabetically by slug.
+ */
+const collectionOrder = sql<number>`coalesce(sort_order, ${sql.lit(UNORDERED_COLLECTION_RANK)})`;
+
+function assertIndexableField(type: FieldType, indexed: boolean | undefined, slug: string): void {
+	if (indexed && !isIndexableFieldType(type)) {
+		throw new SchemaError(
+			`Field "${slug}" cannot be indexed because type "${type}" is not a scalar query type`,
+			"FIELD_NOT_INDEXABLE",
+		);
+	}
+}
+
 function isCollectionSupport(value: unknown): value is CollectionSupport {
 	return typeof value === "string" && VALID_COLLECTION_SUPPORTS.has(value);
 }
@@ -92,6 +140,87 @@ function parseSupports(raw: string | null | undefined): CollectionSupport[] {
 	return parsed.filter(isCollectionSupport);
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function parseCollectionAdmin(raw: string | null | undefined): CollectionAdminConfig | undefined {
+	if (!raw) return undefined;
+	const parsed: unknown = JSON.parse(raw);
+	if (!isRecord(parsed)) return undefined;
+	const listColumns = parsed.listColumns;
+	return {
+		listColumns: Array.isArray(listColumns)
+			? listColumns.filter((value): value is string => typeof value === "string")
+			: undefined,
+	};
+}
+
+export async function buildSeedCollectionCaptureFingerprint(
+	input: Omit<CreateCollectionInput, "source">,
+	fields: readonly CreateFieldInput[],
+): Promise<string> {
+	const supports = input.supports ?? ["drafts", "revisions"];
+	const hasSeo = input.hasSeo ?? supports.includes("seo") ?? false;
+	let maxSortOrder = -1;
+	const definitions = fields.map((field) => {
+		const sortOrder = field.sortOrder ?? maxSortOrder + 1;
+		maxSortOrder = Math.max(maxSortOrder, sortOrder);
+		return {
+			slug: field.slug,
+			label: field.label,
+			type: field.type,
+			required: field.required ?? false,
+			unique: field.unique ?? false,
+			defaultValue: field.defaultValue === undefined ? null : JSON.stringify(field.defaultValue),
+			validation: field.validation ? JSON.stringify(field.validation) : null,
+			widget: field.widget ?? null,
+			options: field.options ? JSON.stringify(field.options) : null,
+			sortOrder,
+			searchable: field.searchable ?? false,
+			translatable: field.translatable ?? true,
+		};
+	});
+	const payload = JSON.stringify(
+		canonicalizeFingerprintValue({
+			version: 1,
+			collection: {
+				slug: input.slug,
+				label: input.label,
+				labelSingular: input.labelSingular ?? null,
+				description: input.description ?? null,
+				icon: input.icon ?? null,
+				admin: input.admin ?? null,
+				supports,
+				hasSeo,
+				hidden: input.hidden ?? false,
+				sortOrder: input.sortOrder ?? null,
+				commentsEnabled: input.commentsEnabled ?? false,
+				urlPattern: input.urlPattern ?? null,
+				routable: input.routable ?? true,
+			},
+			fields: definitions,
+		}),
+	);
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(payload));
+	const hex = Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join(
+		"",
+	);
+	return `media-usage-seed:v1:sha256:${hex}`;
+}
+
+function canonicalizeFingerprintValue(value: unknown): unknown {
+	if (value === undefined) return { __emdashUndefined: true };
+	if (Array.isArray(value)) return value.map(canonicalizeFingerprintValue);
+	if (typeof value !== "object" || value === null) return value;
+
+	const canonical: Record<string, unknown> = {};
+	for (const [key, entry] of Object.entries(value).toSorted(([a], [b]) => a.localeCompare(b))) {
+		canonical[key] = canonicalizeFingerprintValue(entry);
+	}
+	return canonical;
+}
+
 /**
  * Error thrown when a schema operation fails
  */
@@ -126,6 +255,7 @@ export class SchemaRegistry {
 		const rows = await this.db
 			.selectFrom("_emdash_collections")
 			.selectAll()
+			.orderBy(collectionOrder, "asc")
 			.orderBy("slug", "asc")
 			.execute();
 
@@ -177,6 +307,7 @@ export class SchemaRegistry {
 		const collectionRows = await this.db
 			.selectFrom("_emdash_collections")
 			.selectAll()
+			.orderBy(collectionOrder, "asc")
 			.orderBy("slug", "asc")
 			.execute();
 
@@ -212,6 +343,61 @@ export class SchemaRegistry {
 		}));
 	}
 
+	/**
+	 * Validate `titleField`/`dateField` against the collection's fields:
+	 * `titleField` must be a text-like field; `dateField` must be a `datetime` field.
+	 * Only truthy values are checked (undefined = unchanged, null/"" = cleared).
+	 */
+	private async validateTitleDateFields(
+		collectionId: string,
+		collectionSlug: string,
+		input: { titleField?: string | null; dateField?: string | null },
+		db: Kysely<Database> = this.db,
+	): Promise<void> {
+		const slugs = [input.titleField, input.dateField].filter((slug): slug is string => !!slug);
+		if (slugs.length === 0) return;
+
+		const rows = await db
+			.selectFrom("_emdash_fields")
+			.where("collection_id", "=", collectionId)
+			.where("slug", "in", slugs)
+			.select(["slug", "type"])
+			.execute();
+		const typeBySlug = new Map(rows.map((row) => [row.slug, row.type]));
+
+		if (input.titleField) {
+			const type = typeBySlug.get(input.titleField);
+			if (type === undefined) {
+				throw new SchemaError(
+					`titleField "${input.titleField}" is not a field on "${collectionSlug}"`,
+					"INVALID_TITLE_FIELD",
+				);
+			}
+			if (!TITLE_FIELD_TYPES.has(type)) {
+				throw new SchemaError(
+					`titleField "${input.titleField}" must be a text field (got "${type}")`,
+					"INVALID_TITLE_FIELD",
+				);
+			}
+		}
+
+		if (input.dateField) {
+			const type = typeBySlug.get(input.dateField);
+			if (type === undefined) {
+				throw new SchemaError(
+					`dateField "${input.dateField}" is not a field on "${collectionSlug}"`,
+					"INVALID_DATE_FIELD",
+				);
+			}
+			if (type !== "datetime") {
+				throw new SchemaError(
+					`dateField "${input.dateField}" must be a datetime field (got "${type}")`,
+					"INVALID_DATE_FIELD",
+				);
+			}
+		}
+	}
+
 	/**
 	 * Create a new collection
 	 */
@@ -221,14 +407,26 @@ export class SchemaRegistry {
 		if (RESERVED_COLLECTION_SLUGS.includes(input.slug)) {
 			throw new SchemaError(`Collection slug "${input.slug}" is reserved`, "RESERVED_SLUG");
 		}
+		if (await isMediaUsageCollectionSlugDeleting(this.db, input.slug)) {
+			throw new SchemaError(`Collection "${input.slug}" already exists`, "COLLECTION_EXISTS");
+		}
 
 		// Check if collection already exists
 		const existing = await this.getCollection(input.slug);
-		if (existing) {
+		if (await isMediaUsageCollectionSlugDeleting(this.db, input.slug)) {
+			throw new SchemaError(`Collection "${input.slug}" already exists`, "COLLECTION_EXISTS");
+		}
+		if (
+			existing &&
+			!(await canResumeMediaUsageCollectionCapture(this.db, {
+				collectionId: existing.id,
+				collectionSlug: existing.slug,
+			}))
+		) {
 			throw new SchemaError(`Collection "${input.slug}" already exists`, "COLLECTION_EXISTS");
 		}
 
-		const id = ulid();
+		const proposedId = existing?.id ?? ulid();
 
 		// Default `supports` to drafts + revisions when the caller didn't
 		// specify it. Explicit empty array (`[]`) is preserved as an opt-out
@@ -244,24 +442,52 @@ export class SchemaRegistry {
 		const hasSeo = input.hasSeo ?? supports.includes("seo") ?? false;
 
 		await withTransaction(this.db, async (trx) => {
-			await trx
-				.insertInto("_emdash_collections")
-				.values({
-					id,
-					slug: input.slug,
-					label: input.label,
-					label_singular: input.labelSingular ?? null,
-					description: input.description ?? null,
-					icon: input.icon ?? null,
-					supports: JSON.stringify(supports),
-					source: input.source ?? "manual",
-					has_seo: hasSeo ? 1 : 0,
-					comments_enabled: input.commentsEnabled ? 1 : 0,
-					url_pattern: input.urlPattern ?? null,
-				})
-				.execute();
+			const capture = await prepareMediaUsageCollectionCapture(trx, {
+				collectionId: proposedId,
+				collectionSlug: input.slug,
+				registeredCollectionId: existing?.id,
+			});
+			const values: Insertable<CollectionTable> = {
+				id: capture.collectionId,
+				slug: input.slug,
+				label: input.label,
+				label_singular: input.labelSingular ?? null,
+				description: input.description ?? null,
+				icon: input.icon ?? null,
+				admin_config: input.admin ? JSON.stringify(input.admin) : null,
+				supports: JSON.stringify(supports),
+				source: input.source ?? "manual",
+				has_seo: hasSeo ? 1 : 0,
+				routable: input.routable === false ? 0 : 1,
+				hidden: input.hidden ? 1 : 0,
+				sort_order: input.sortOrder ?? null,
+				comments_enabled: input.commentsEnabled ? 1 : 0,
+				url_pattern: input.urlPattern ?? null,
+			};
+
+			if (capture.captureRequired) {
+				await this.createContentTable(input.slug, trx, [], {
+					ifNotExists: capture.resuming,
+				});
+				await installPreparedMediaUsageCollectionCapture(trx, {
+					collectionId: capture.collectionId,
+					collectionSlug: input.slug,
+				});
+				await markMediaUsageCollectionCaptureReady(trx, {
+					collectionId: capture.collectionId,
+					collectionSlug: input.slug,
+				});
+				if (!capture.registrationExists) {
+					await trx.insertInto("_emdash_collections").values(values).execute();
+				}
+				await finalizeMediaUsageCollectionCapture(trx, {
+					collectionId: capture.collectionId,
+					collectionSlug: input.slug,
+				});
+				return;
+			}
 
-			// Create the content table for this collection
+			await trx.insertInto("_emdash_collections").values(values).execute();
 			await this.createContentTable(input.slug, trx);
 		});
 
@@ -291,15 +517,14 @@ export class SchemaRegistry {
 		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) {
+		if (await isMediaUsageCollectionSlugDeleting(this.db, input.slug)) {
 			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");
+			assertIndexableField(field.type, field.indexed, field.slug);
 			if (RESERVED_FIELD_SLUGS.includes(field.slug)) {
 				throw new SchemaError(`Field slug "${field.slug}" is reserved`, "RESERVED_SLUG");
 			}
@@ -312,9 +537,25 @@ export class SchemaRegistry {
 			fieldSlugs.add(field.slug);
 		}
 
-		const collectionId = ulid();
 		const supports = input.supports ?? ["drafts", "revisions"];
 		const hasSeo = input.hasSeo ?? supports.includes("seo") ?? false;
+		const creationFingerprint = await buildSeedCollectionCaptureFingerprint(input, fields);
+		const existing = await this.getCollection(input.slug);
+		if (await isMediaUsageCollectionSlugDeleting(this.db, input.slug)) {
+			throw new SchemaError(`Collection "${input.slug}" already exists`, "COLLECTION_EXISTS");
+		}
+		if (
+			existing &&
+			!(await canResumeMediaUsageCollectionCapture(this.db, {
+				collectionId: existing.id,
+				collectionSlug: existing.slug,
+				creationFingerprint,
+			}))
+		) {
+			throw new SchemaError(`Collection "${input.slug}" already exists`, "COLLECTION_EXISTS");
+		}
+
+		const proposedCollectionId = existing?.id ?? ulid();
 		let maxSortOrder = -1;
 		const fieldRows: Insertable<FieldTable>[] = fields.map((field) => {
 			const sortOrder = field.sortOrder ?? maxSortOrder + 1;
@@ -322,7 +563,7 @@ export class SchemaRegistry {
 
 			return {
 				id: ulid(),
-				collection_id: collectionId,
+				collection_id: proposedCollectionId,
 				slug: field.slug,
 				label: field.label,
 				type: field.type,
@@ -335,6 +576,7 @@ export class SchemaRegistry {
 				options: field.options ? JSON.stringify(field.options) : null,
 				sort_order: sortOrder,
 				searchable: field.searchable ? 1 : 0,
+				indexed: field.indexed ? 1 : 0,
 				translatable: field.translatable === false ? 0 : 1,
 			};
 		});
@@ -342,28 +584,79 @@ export class SchemaRegistry {
 		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);
+				const capture = await prepareMediaUsageCollectionCapture(trx, {
+					collectionId: proposedCollectionId,
+					collectionSlug: input.slug,
+					creationFingerprint,
+					registeredCollectionId: existing?.id,
+				});
+				const collectionValues: Insertable<CollectionTable> = {
+					id: capture.collectionId,
+					slug: input.slug,
+					label: input.label,
+					label_singular: input.labelSingular ?? null,
+					description: input.description ?? null,
+					icon: input.icon ?? null,
+					admin_config: input.admin ? JSON.stringify(input.admin) : null,
+					supports: JSON.stringify(supports),
+					source: "seed",
+					has_seo: hasSeo ? 1 : 0,
+					routable: input.routable === false ? 0 : 1,
+					hidden: input.hidden ? 1 : 0,
+					sort_order: input.sortOrder ?? null,
+					comments_enabled: input.commentsEnabled ? 1 : 0,
+					url_pattern: input.urlPattern ?? null,
+				};
+				const rows = fieldRows.map((row) => ({
+					...row,
+					collection_id: capture.collectionId,
+				}));
+
+				if (capture.captureRequired) {
+					await this.createContentTable(input.slug, trx, fields, {
+						ifNotExists: capture.resuming,
+					});
+					await installPreparedMediaUsageCollectionCapture(trx, {
+						collectionId: capture.collectionId,
+						collectionSlug: input.slug,
+					});
+					await markMediaUsageCollectionCaptureReady(trx, {
+						collectionId: capture.collectionId,
+						collectionSlug: input.slug,
+					});
+					if (!capture.registrationExists) {
+						await trx.insertInto("_emdash_collections").values(collectionValues).execute();
+						schemaMutated = true;
+					}
+				} else {
+					await trx.insertInto("_emdash_collections").values(collectionValues).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();
+				for (const fieldBatch of chunks(rows, SEED_FIELD_INSERT_BATCH_SIZE)) {
+					let insert = trx.insertInto("_emdash_fields").values(fieldBatch);
+					if (capture.resuming) {
+						insert = insert.onConflict((conflict) =>
+							conflict.columns(["collection_id", "slug"]).doNothing(),
+						);
+					}
+					await insert.execute();
+				}
+				let indexedRows: readonly { id: string; slug: string; indexed?: number }[] = rows;
+				if (capture.resuming) {
+					indexedRows = await this.assertSeedFieldDefinitions(capture.collectionId, fields, trx);
+				}
+				for (const field of indexedRows) {
+					if (field.indexed === 1) {
+						await this.createFieldIndex(input.slug, field.id, field.slug, trx);
+					}
+				}
+				if (capture.captureRequired) {
+					await finalizeMediaUsageCollectionCapture(trx, {
+						collectionId: capture.collectionId,
+						collectionSlug: input.slug,
+					});
 				}
 			});
 
@@ -380,66 +673,108 @@ export class SchemaRegistry {
 		}
 	}
 
+	private async assertSeedFieldDefinitions(
+		collectionId: string,
+		fields: readonly CreateFieldInput[],
+		db: Kysely<Database>,
+	): Promise<Selectable<FieldTable>[]> {
+		const stored = await db
+			.selectFrom("_emdash_fields")
+			.selectAll()
+			.where("collection_id", "=", collectionId)
+			.execute();
+		if (stored.length !== fields.length) {
+			throw new SchemaError("Interrupted seed collection fields do not match", "CREATE_FAILED");
+		}
+
+		let maxSortOrder = -1;
+		for (const field of fields) {
+			const sortOrder = field.sortOrder ?? maxSortOrder + 1;
+			maxSortOrder = Math.max(maxSortOrder, sortOrder);
+			const row = stored.find((candidate) => candidate.slug === field.slug);
+			if (
+				!row ||
+				row.label !== field.label ||
+				row.type !== field.type ||
+				row.column_type !== FIELD_TYPE_TO_COLUMN[field.type] ||
+				row.required !== (field.required ? 1 : 0) ||
+				row.unique !== (field.unique ? 1 : 0) ||
+				row.default_value !==
+					(field.defaultValue !== undefined ? JSON.stringify(field.defaultValue) : null) ||
+				row.validation !== (field.validation ? JSON.stringify(field.validation) : null) ||
+				row.widget !== (field.widget ?? null) ||
+				row.options !== (field.options ? JSON.stringify(field.options) : null) ||
+				row.sort_order !== sortOrder ||
+				row.searchable !== (field.searchable ? 1 : 0) ||
+				row.indexed !== (field.indexed ? 1 : 0) ||
+				row.translatable !== (field.translatable === false ? 0 : 1)
+			) {
+				throw new SchemaError("Interrupted seed collection fields do not match", "CREATE_FAILED");
+			}
+		}
+		return stored;
+	}
+
 	/**
 	 * Update a collection
 	 */
 	async updateCollection(slug: string, input: UpdateCollectionInput): Promise<Collection> {
-		const existing = await this.getCollection(slug);
-		if (!existing) {
-			throw new SchemaError(`Collection "${slug}" not found`, "COLLECTION_NOT_FOUND");
-		}
-
-		const now = new Date().toISOString();
-
-		// Derive hasSeo from supports array if supports is being updated and hasSeo not explicitly set
-		const supportsArray = input.supports ?? existing.supports;
-		const hasSeo =
-			input.hasSeo !== undefined
-				? input.hasSeo
-				: input.supports !== undefined
-					? supportsArray.includes("seo")
-					: existing.hasSeo;
-
 		return withTransaction(this.db, async (trx) => {
+			const existingRow = await trx
+				.selectFrom("_emdash_collections")
+				.where("slug", "=", slug)
+				.selectAll()
+				.executeTakeFirst();
+			if (!existingRow) {
+				throw new SchemaError(`Collection "${slug}" not found`, "COLLECTION_NOT_FOUND");
+			}
+			const existing = this.mapCollectionRow(existingRow);
+			await this.validateTitleDateFields(
+				existing.id,
+				slug,
+				{
+					titleField: input.titleField,
+					dateField: input.dateField,
+				},
+				trx,
+			);
+			const updates: Updateable<CollectionTable> = {};
+
+			if (input.label !== undefined) updates.label = input.label;
+			if (input.labelSingular !== undefined) updates.label_singular = input.labelSingular;
+			if (input.description !== undefined) updates.description = input.description;
+			if (input.icon !== undefined) updates.icon = input.icon;
+			if (input.admin !== undefined) updates.admin_config = JSON.stringify(input.admin);
+			if (input.supports !== undefined) updates.supports = JSON.stringify(input.supports);
+			if (input.urlPattern !== undefined) updates.url_pattern = input.urlPattern;
+			if (input.routable !== undefined) updates.routable = input.routable ? 1 : 0;
+			if (input.hasSeo !== undefined) {
+				updates.has_seo = input.hasSeo ? 1 : 0;
+			} else if (input.supports !== undefined) {
+				updates.has_seo = input.supports.includes("seo") ? 1 : 0;
+			}
+			if (input.hidden !== undefined) updates.hidden = input.hidden ? 1 : 0;
+			if (input.sortOrder !== undefined) updates.sort_order = input.sortOrder;
+			if (input.titleField !== undefined) updates.title_field = input.titleField || null;
+			if (input.dateField !== undefined) updates.date_field = input.dateField || null;
+			if (input.commentsEnabled !== undefined) {
+				updates.comments_enabled = input.commentsEnabled ? 1 : 0;
+			}
+			if (input.commentsModeration !== undefined) {
+				updates.comments_moderation = input.commentsModeration;
+			}
+			if (input.commentsClosedAfterDays !== undefined) {
+				updates.comments_closed_after_days = input.commentsClosedAfterDays;
+			}
+			if (input.commentsAutoApproveUsers !== undefined) {
+				updates.comments_auto_approve_users = input.commentsAutoApproveUsers ? 1 : 0;
+			}
+
+			updates.updated_at = new Date().toISOString();
 			await trx
 				.updateTable("_emdash_collections")
-				.set({
-					label: input.label ?? existing.label,
-					label_singular: input.labelSingular ?? existing.labelSingular ?? null,
-					description: input.description ?? existing.description ?? null,
-					icon: input.icon ?? existing.icon ?? null,
-					supports: input.supports
-						? JSON.stringify(input.supports)
-						: JSON.stringify(existing.supports),
-					url_pattern:
-						input.urlPattern !== undefined
-							? (input.urlPattern ?? null)
-							: (existing.urlPattern ?? null),
-					has_seo: hasSeo ? 1 : 0,
-					comments_enabled:
-						input.commentsEnabled !== undefined
-							? input.commentsEnabled
-								? 1
-								: 0
-							: existing.commentsEnabled
-								? 1
-								: 0,
-					comments_moderation: input.commentsModeration ?? existing.commentsModeration,
-					comments_closed_after_days:
-						input.commentsClosedAfterDays !== undefined
-							? input.commentsClosedAfterDays
-							: existing.commentsClosedAfterDays,
-					comments_auto_approve_users:
-						input.commentsAutoApproveUsers !== undefined
-							? input.commentsAutoApproveUsers
-								? 1
-								: 0
-							: existing.commentsAutoApproveUsers
-								? 1
-								: 0,
-					updated_at: now,
-				})
-				.where("slug", "=", slug)
+				.set(updates)
+				.where("id", "=", existing.id)
 				.execute();
 
 			const row = await trx
@@ -470,21 +805,31 @@ export class SchemaRegistry {
 	 */
 	async deleteCollection(slug: string, options?: { force?: boolean }): Promise<void> {
 		const existing = await this.getCollection(slug);
+		if (existing && !options?.force && (await this.collectionHasContent(slug))) {
+			throw new SchemaError(
+				`Collection "${slug}" has content. Use force: true to delete.`,
+				"COLLECTION_HAS_CONTENT",
+			);
+		}
+		const activated = await deleteActivatedMediaUsageCollection(this.db, {
+			collectionId: existing?.id,
+			collectionSlug: slug,
+			forceDelete: options?.force === true,
+		});
+		if (activated === "has_content") {
+			throw new SchemaError(
+				`Collection "${slug}" has content. Use force: true to delete.`,
+				"COLLECTION_HAS_CONTENT",
+			);
+		}
+		if (activated === "in_progress") {
+			throw new SchemaError(`Collection "${slug}" deletion is already in progress`, "CONFLICT");
+		}
+		if (activated === "deleted") return;
 		if (!existing) {
 			throw new SchemaError(`Collection "${slug}" not found`, "COLLECTION_NOT_FOUND");
 		}
 
-		// Check if collection has content
-		if (!options?.force) {
-			const hasContent = await this.collectionHasContent(slug);
-			if (hasContent) {
-				throw new SchemaError(
-					`Collection "${slug}" has content. Use force: true to delete.`,
-					"COLLECTION_HAS_CONTENT",
-				);
-			}
-		}
-
 		let contentTableDropped = false;
 		try {
 			await withTransaction(this.db, async (trx) => {
@@ -571,6 +916,7 @@ export class SchemaRegistry {
 
 		const id = ulid();
 		const columnType = FIELD_TYPE_TO_COLUMN[input.type];
+		assertIndexableField(input.type, input.indexed, input.slug);
 
 		// Get max sort order
 		const maxSort = await this.db
@@ -580,6 +926,10 @@ export class SchemaRegistry {
 			.executeTakeFirst();
 
 		const sortOrder = input.sortOrder ?? (maxSort?.max ?? -1) + 1;
+		const activeCoverageInvalidated = await invalidateContentMediaUsageSchemaChange(
+			this.db,
+			collectionSlug,
+		);
 
 		let schemaMutated = false;
 		try {
@@ -603,6 +953,7 @@ export class SchemaRegistry {
 						options: input.options ? JSON.stringify(input.options) : null,
 						sort_order: sortOrder,
 						searchable: input.searchable ? 1 : 0,
+						indexed: input.indexed ? 1 : 0,
 						translatable: input.translatable === false ? 0 : 1,
 					})
 					.execute();
@@ -620,6 +971,10 @@ export class SchemaRegistry {
 					trx,
 				);
 
+				if (input.indexed) {
+					await this.createFieldIndex(collectionSlug, id, input.slug, trx);
+				}
+
 				// Read the created field via trx (not this.db) to avoid connection mutex deadlock
 				const fieldRow = await trx
 					.selectFrom("_emdash_fields")
@@ -641,20 +996,28 @@ export class SchemaRegistry {
 
 				return field;
 			});
-			await markContentMediaUsageCollectionStaleSafely(
-				this.db,
-				collectionSlug,
-				"CONTENT_USAGE_STALE",
-			);
-			return created;
-		} catch (error) {
-			if (schemaMutated) {
+			if (activeCoverageInvalidated) {
+				await invalidateContentMediaUsageSchemaChange(this.db, collectionSlug);
+			} else {
 				await markContentMediaUsageCollectionStaleSafely(
 					this.db,
 					collectionSlug,
 					"CONTENT_USAGE_STALE",
 				);
 			}
+			return created;
+		} catch (error) {
+			if (schemaMutated) {
+				if (activeCoverageInvalidated) {
+					await invalidateContentMediaUsageSchemaChange(this.db, collectionSlug);
+				} else {
+					await markContentMediaUsageCollectionStaleSafely(
+						this.db,
+						collectionSlug,
+						"CONTENT_USAGE_STALE",
+					);
+				}
+			}
 			throw error;
 		}
 	}
@@ -667,87 +1030,126 @@ export class SchemaRegistry {
 		fieldSlug: string,
 		input: UpdateFieldInput,
 	): Promise<Field> {
-		const field = await this.getField(collectionSlug, fieldSlug);
-		if (!field) {
-			throw new SchemaError(
-				`Field "${fieldSlug}" not found in collection "${collectionSlug}"`,
-				"FIELD_NOT_FOUND",
-			);
-		}
-
-		// `input.validation === undefined` means "no change" (keep existing);
-		// an explicit `null` clears the column.
-		const nextValidation = input.validation === undefined ? field.validation : input.validation;
-
-		// A field-type change is only safe when the underlying column type stays
-		// the same. There is no in-place column migration (only addColumn/
-		// dropColumn), so a change that would alter the SQLite column affinity
-		// (e.g. `text` TEXT -> `portableText` JSON) is rejected rather than
-		// silently rewriting only the metadata — which would leave `column_type`
-		// pointing at a column type the real `ec_*` column doesn't have (#1397).
-		let nextType = field.type;
-		let nextColumnType = field.columnType;
-		if (input.type !== undefined && input.type !== field.type) {
-			const newColumnType = FIELD_TYPE_TO_COLUMN[input.type];
-			if (newColumnType !== field.columnType) {
-				throw new SchemaError(
-					`Cannot change field "${fieldSlug}" in collection "${collectionSlug}" from type ` +
-						`"${field.type}" to "${input.type}": the underlying column type would change from ` +
-						`${field.columnType} to ${newColumnType}, which requires a manual content migration. ` +
-						`Drop and re-create the field, or migrate the column data, before changing its type.`,
-					"FIELD_TYPE_COLUMN_CHANGE",
-				);
-			}
-			nextType = input.type;
-			nextColumnType = newColumnType;
-		}
-
+		let activeCoverageInvalidated = false;
 		let schemaMutated = false;
 		try {
 			const updatedField = await withTransaction(this.db, async (trx) => {
-				await trx
-					.updateTable("_emdash_fields")
-					.set({
-						type: nextType,
-						column_type: nextColumnType,
-						label: input.label ?? field.label,
-						required:
-							input.required !== undefined ? (input.required ? 1 : 0) : field.required ? 1 : 0,
-						unique: input.unique !== undefined ? (input.unique ? 1 : 0) : field.unique ? 1 : 0,
-						searchable:
-							input.searchable !== undefined
-								? input.searchable
-									? 1
-									: 0
-								: field.searchable
-									? 1
-									: 0,
-						translatable:
-							input.translatable !== undefined
-								? input.translatable
-									? 1
-									: 0
-								: field.translatable
-									? 1
-									: 0,
-						default_value:
-							input.defaultValue !== undefined
-								? JSON.stringify(input.defaultValue)
-								: field.defaultValue !== undefined
-									? JSON.stringify(field.defaultValue)
-									: null,
-						validation: nextValidation ? JSON.stringify(nextValidation) : null,
-						widget: input.widget ?? field.widget ?? null,
-						options: input.options
-							? JSON.stringify(input.options)
-							: field.options
-								? JSON.stringify(field.options)
-								: null,
-						sort_order: input.sortOrder ?? field.sortOrder,
-					})
-					.where("id", "=", field.id)
-					.execute();
-				schemaMutated = true;
+				const collectionRow = await trx
+					.selectFrom("_emdash_collections")
+					.where("slug", "=", collectionSlug)
+					.select(["id", "title_field", "date_field"])
+					.executeTakeFirst();
+				const fieldRow = collectionRow
+					? await trx
+							.selectFrom("_emdash_fields")
+							.where("collection_id", "=", collectionRow.id)
+							.where("slug", "=", fieldSlug)
+							.selectAll()
+							.executeTakeFirst()
+					: undefined;
+				if (!fieldRow) {
+					throw new SchemaError(
+						`Field "${fieldSlug}" not found in collection "${collectionSlug}"`,
+						"FIELD_NOT_FOUND",
+					);
+				}
+				const field = this.mapFieldRow(fieldRow);
+				const updates: Updateable<FieldTable> = {};
+				let nextType = field.type;
+
+				if (input.type !== undefined && input.type !== field.type) {
+					const newColumnType = FIELD_TYPE_TO_COLUMN[input.type];
+					if (newColumnType !== field.columnType) {
+						throw new SchemaError(
+							`Cannot change field "${fieldSlug}" in collection "${collectionSlug}" from type ` +
+								`"${field.type}" to "${input.type}": the underlying column type would change from ` +
+								`${field.columnType} to ${newColumnType}, which requires a manual content migration.`,
+							"FIELD_TYPE_COLUMN_CHANGE",
+						);
+					}
+					if (!TEXT_ALIAS_FIELD_TYPES.has(field.type) || !TEXT_ALIAS_FIELD_TYPES.has(input.type)) {
+						throw new SchemaError(
+							`Cannot change field "${fieldSlug}" in collection "${collectionSlug}" from type ` +
+								`"${field.type}" to "${input.type}" without a manual content migration.`,
+							"FIELD_TYPE_CHANGE_REQUIRES_MIGRATION",
+						);
+					}
+					if (collectionRow?.title_field === fieldSlug && !TITLE_FIELD_TYPES.has(input.type)) {
+						throw new SchemaError(
+							`titleField "${fieldSlug}" must stay a text field, not "${input.type}"`,
+							"INVALID_TITLE_FIELD",
+						);
+					}
+					if (collectionRow?.date_field === fieldSlug && input.type !== "datetime") {
+						throw new SchemaError(
+							`dateField "${fieldSlug}" must stay a datetime field, not "${input.type}"`,
+							"INVALID_DATE_FIELD",
+						);
+					}
+					nextType = input.type;
+					updates.type = input.type;
+					updates.column_type = newColumnType;
+				}
+
+				if (input.required !== undefined && input.required !== field.required) {
+					throw new SchemaError(
+						`Changing required for field "${fieldSlug}" requires a manual content migration.`,
+						"FIELD_UPDATE_REQUIRES_MIGRATION",
+					);
+				}
+				if (input.unique !== undefined && input.unique !== field.unique) {
+					throw new SchemaError(
+						`Changing unique for field "${fieldSlug}" requires a manual content migration.`,
+						"FIELD_UPDATE_REQUIRES_MIGRATION",
+					);
+				}
+				if (input.translatable === false && field.translatable) {
+					throw new SchemaError(
+						`Changing field "${fieldSlug}" to non-translatable requires a manual content migration.`,
+						"FIELD_UPDATE_REQUIRES_MIGRATION",
+					);
+				}
+
+				if (input.label !== undefined) updates.label = input.label;
+				if (input.required !== undefined) updates.required = input.required ? 1 : 0;
+				if (input.unique !== undefined) updates.unique = input.unique ? 1 : 0;
+				if (input.searchable !== undefined) updates.searchable = input.searchable ? 1 : 0;
+				const indexedChanged = input.indexed !== undefined && input.indexed !== field.indexed;
+				if (indexedChanged) updates.indexed = input.indexed ? 1 : 0;
+				if (input.translatable !== undefined) {
+					updates.translatable = input.translatable ? 1 : 0;
+				}
+				if (input.defaultValue !== undefined) {
+					updates.default_value = JSON.stringify(input.defaultValue);
+				}
+				if (input.validation !== undefined) {
+					updates.validation = input.validation ? JSON.stringify(input.validation) : null;
+				}
+				if (input.widget !== undefined) updates.widget = input.widget;
+				if (input.options !== undefined) updates.options = JSON.stringify(input.options);
+				if (input.sortOrder !== undefined) updates.sort_order = input.sortOrder;
+
+				assertIndexableField(nextType, input.indexed ?? field.indexed, fieldSlug);
+				if (Object.keys(updates).length === 0) return field;
+
+				activeCoverageInvalidated = await invalidateContentMediaUsageSchemaChange(
+					trx,
+					collectionSlug,
+				);
+
+				if (Object.keys(updates).length > 0) {
+					await trx.updateTable("_emdash_fields").set(updates).where("id", "=", field.id).execute();
+					schemaMutated = true;
+				}
+
+				if (indexedChanged) {
+					if (input.indexed) {
+						await this.createFieldIndex(collectionSlug, field.id, fieldSlug, trx);
+					} else {
+						await this.dropFieldIndex(field.id, trx);
+					}
+					schemaMutated = true;
+				}
 
 				// Read the updated field via trx (not this.db) to avoid connection mutex deadlock
 				const updatedRow = await trx
@@ -765,26 +1167,36 @@ export class SchemaRegistry {
 
 				// If searchable changed, sync FTS state for this collection
 				const searchableChanged =
-					input.searchable !== undefined && input.searchable !== field.searchable;
+					schemaMutated && input.searchable !== undefined && input.searchable !== field.searchable;
 				if (searchableChanged) {
 					await this.syncSearchState(collectionSlug, trx);
 				}
 
 				return updated;
 			});
-			await markContentMediaUsageCollectionStaleSafely(
-				this.db,
-				collectionSlug,
-				"CONTENT_USAGE_STALE",
-			);
+			if (schemaMutated) {
+				if (activeCoverageInvalidated) {
+					await invalidateContentMediaUsageSchemaChange(this.db, collectionSlug);
+				} else {
+					await markContentMediaUsageCollectionStaleSafely(
+						this.db,
+						collectionSlug,
+						"CONTENT_USAGE_STALE",
+					);
+				}
+			}
 			return updatedField;
 		} catch (error) {
 			if (schemaMutated) {
-				await markContentMediaUsageCollectionStaleSafely(
-					this.db,
-					collectionSlug,
-					"CONTENT_USAGE_STALE",
-				);
+				if (activeCoverageInvalidated) {
+					await invalidateContentMediaUsageSchemaChange(this.db, collectionSlug);
+				} else {
+					await markContentMediaUsageCollectionStaleSafely(
+						this.db,
+						collectionSlug,
+						"CONTENT_USAGE_STALE",
+					);
+				}
 			}
 			throw error;
 		}
@@ -822,7 +1234,12 @@ export class SchemaRegistry {
 		const ftsActive = config?.enabled === true;
 
 		if (wantsSearch && searchableFields.length > 0 && ftsActive) {
-			await ftsManager.rebuildIndex(collectionSlug, searchableFields, config?.weights);
+			await ftsManager.rebuildIndex(
+				collectionSlug,
+				searchableFields,
+				config?.weights,
+				config?.tokenize,
+			);
 		} else if (ftsActive && (!wantsSearch || searchableFields.length === 0)) {
 			await ftsManager.disableSearch(collectionSlug);
 		}
@@ -839,6 +1256,17 @@ export class SchemaRegistry {
 				"FIELD_NOT_FOUND",
 			);
 		}
+		const activeCoverageInvalidated = await invalidateContentMediaUsageSchemaChange(
+			this.db,
+			collectionSlug,
+		);
+
+		// If this field powers the collection's titleField/dateField,
+		// clear that reference in the same transaction — otherwise the metadata
+		// would point at a dropped column and later crash the content list sort.
+		const collection = await this.getCollection(collectionSlug);
+		const clearTitle = collection?.titleField === fieldSlug;
+		const clearDate = collection?.dateField === fieldSlug;
 
 		let schemaMutated = false;
 		try {
@@ -851,31 +1279,109 @@ export class SchemaRegistry {
 				await trx.deleteFrom("_emdash_fields").where("id", "=", field.id).execute();
 				schemaMutated = true;
 
+				if (clearTitle || clearDate) {
+					await trx
+						.updateTable("_emdash_collections")
+						.set({
+							...(clearTitle ? { title_field: null } : {}),
+							...(clearDate ? { date_field: null } : {}),
+							updated_at: new Date().toISOString(),
+						})
+						.where("slug", "=", collectionSlug)
+						.execute();
+				}
+
 				// If the deleted field was searchable, sync FTS state (removes old triggers)
 				if (field.searchable) {
 					await this.syncSearchState(collectionSlug, trx);
 				}
 
+				if (field.indexed) {
+					await this.dropFieldIndex(field.id, trx);
+				}
+
 				// Drop column from content table — safe now because FTS triggers are gone
 				await this.dropColumn(collectionSlug, fieldSlug, trx);
 			});
-			await markContentMediaUsageCollectionStaleSafely(
-				this.db,
-				collectionSlug,
-				"CONTENT_USAGE_STALE",
-			);
-		} catch (error) {
-			if (schemaMutated) {
+			if (activeCoverageInvalidated) {
+				await invalidateContentMediaUsageSchemaChange(this.db, collectionSlug);
+			} else {
 				await markContentMediaUsageCollectionStaleSafely(
 					this.db,
 					collectionSlug,
 					"CONTENT_USAGE_STALE",
 				);
 			}
+		} catch (error) {
+			if (schemaMutated) {
+				if (activeCoverageInvalidated) {
+					await invalidateContentMediaUsageSchemaChange(this.db, collectionSlug);
+				} else {
+					await markContentMediaUsageCollectionStaleSafely(
+						this.db,
+						collectionSlug,
+						"CONTENT_USAGE_STALE",
+					);
+				}
+			}
 			throw error;
 		}
 	}
 
+	/**
+	 * Reorder collections in the admin sidebar.
+	 *
+	 * `slugs` is the full desired order: every listed collection gets its
+	 * index as `sort_order`, and any collection left out has its explicit
+	 * position cleared, dropping it back to the alphabetical tail. Unknown or
+	 * duplicate slugs throw before anything is written.
+	 */
+	async reorderCollections(slugs: string[]): Promise<void> {
+		const known = new Set((await this.listCollections()).map((collection) => collection.slug));
+
+		const unknown = slugs.filter((slug) => !known.has(slug));
+		if (unknown.length > 0) {
+			throw new SchemaError(
+				`Unknown collection${unknown.length > 1 ? "s" : ""}: ${unknown.join(", ")}`,
+				"COLLECTION_NOT_FOUND",
+				{ slugs: unknown },
+			);
+		}
+
+		const duplicates = slugs.filter((slug, index) => slugs.indexOf(slug) !== index);
+		if (duplicates.length > 0) {
+			throw new SchemaError(
+				`Duplicate collection${duplicates.length > 1 ? "s" : ""}: ${[...new Set(duplicates)].join(", ")}`,
+				"DUPLICATE_SLUG",
+				{ slugs: [...new Set(duplicates)] },
+			);
+		}
+
+		const now = new Date().toISOString();
+		const ordered = new Set(slugs);
+
+		await withTransaction(this.db, async (trx) => {
+			for (const [index, slug] of slugs.entries()) {
+				await trx
+					.updateTable("_emdash_collections")
+					.set({ sort_order: index, updated_at: now })
+					.where("slug", "=", slug)
+					.execute();
+			}
+
+			const cleared = [...known].filter((slug) => !ordered.has(slug));
+			// Chunked to stay under D1's bound-parameter limit; typical sites
+			// clear far fewer than one chunk.
+			for (const slugChunk of chunks(cleared, SQL_BATCH_SIZE)) {
+				await trx
+					.updateTable("_emdash_collections")
+					.set({ sort_order: null, updated_at: now })
+					.where("slug", "in", slugChunk)
+					.execute();
+			}
+		});
+	}
+
 	/**
 	 * Reorder fields
 	 */
@@ -907,6 +1413,7 @@ export class SchemaRegistry {
 		slug: string,
 		db?: Kysely<Database>,
 		fields: readonly CreateFieldInput[] = [],
+		options: { ifNotExists?: boolean } = {},
 	): Promise<void> {
 		const conn = db ?? this.db;
 		const tableName = this.getTableName(slug);
@@ -928,6 +1435,7 @@ export class SchemaRegistry {
 			.addColumn("draft_revision_id", "text", (col) => col.references("revisions.id"))
 			.addColumn("locale", "text", (col) => col.notNull().defaultTo("en"))
 			.addColumn("translation_group", "text");
+		if (options.ifNotExists) table = table.ifNotExists();
 
 		for (const field of fields) {
 			const columnName = this.getColumnName(field.slug);
@@ -947,66 +1455,77 @@ export class SchemaRegistry {
 			.addUniqueConstraint(`${tableName}_slug_locale_unique`, ["slug", "locale"])
 			.execute();
 
+		const createIndex = options.ifNotExists ? sql`CREATE INDEX IF NOT EXISTS` : sql`CREATE INDEX`;
+
 		// Create standard indexes
 		await sql`
-			CREATE INDEX ${sql.ref(`idx_${tableName}_slug`)}
+			${createIndex} ${sql.ref(`idx_${tableName}_slug`)}
 			ON ${sql.ref(tableName)} (slug)
 		`.execute(conn);
 
 		await sql`
-			CREATE INDEX ${sql.ref(`idx_${tableName}_scheduled`)}
+			${createIndex} ${sql.ref(`idx_${tableName}_scheduled`)}
 			ON ${sql.ref(tableName)} (scheduled_at)
 			WHERE scheduled_at IS NOT NULL
 		`.execute(conn);
 
 		await sql`
-			CREATE INDEX ${sql.ref(`idx_${tableName}_live_revision`)}
+			${createIndex} ${sql.ref(`idx_${tableName}_live_revision`)}
 			ON ${sql.ref(tableName)} (live_revision_id)
 		`.execute(conn);
 
 		await sql`
-			CREATE INDEX ${sql.ref(`idx_${tableName}_draft_revision`)}
+			${createIndex} ${sql.ref(`idx_${tableName}_draft_revision`)}
 			ON ${sql.ref(tableName)} (draft_revision_id)
 		`.execute(conn);
 
 		await sql`
-			CREATE INDEX ${sql.ref(`idx_${tableName}_author`)}
+			${createIndex} ${sql.ref(`idx_${tableName}_author`)}
 			ON ${sql.ref(tableName)} (author_id)
 		`.execute(conn);
 
 		await sql`
-			CREATE INDEX ${sql.ref(`idx_${tableName}_primary_byline`)}
+			${createIndex} ${sql.ref(`idx_${tableName}_primary_byline`)}
 			ON ${sql.ref(tableName)} (primary_byline_id)
 		`.execute(conn);
 
 		await sql`
-			CREATE INDEX ${sql.ref(`idx_${tableName}_locale`)}
+			${createIndex} ${sql.ref(`idx_${tableName}_locale`)}
 			ON ${sql.ref(tableName)} (locale)
 		`.execute(conn);
 
+		// Names must stay identical to migration 055, which creates these indexes
+		// on tables that already exist. Lookups that don't constrain `deleted_at`
+		// (menu and reference resolution) need the first; reads that do need the
+		// second.
 		await sql`
-			CREATE INDEX ${sql.ref(`idx_${tableName}_translation_group`)}
-			ON ${sql.ref(tableName)} (translation_group)
+			${createIndex} ${sql.ref(`idx_${tableName}_tg_locale`)}
+			ON ${sql.ref(tableName)} (translation_group, locale)
+		`.execute(conn);
+
+		await sql`
+			${createIndex} ${sql.ref(`idx_${tableName}_del_tg_locale`)}
+			ON ${sql.ref(tableName)} (deleted_at, translation_group, locale)
 		`.execute(conn);
 
 		// Composite indexes for optimized query performance (see migration 033)
 		await sql`
-			CREATE INDEX ${sql.ref(`idx_${tableName}_deleted_updated_id`)}
+			${createIndex} ${sql.ref(`idx_${tableName}_deleted_updated_id`)}
 			ON ${sql.ref(tableName)} (deleted_at, updated_at DESC, id DESC)
 		`.execute(conn);
 
 		await sql`
-			CREATE INDEX ${sql.ref(`idx_${tableName}_deleted_status`)}
+			${createIndex} ${sql.ref(`idx_${tableName}_deleted_status`)}
 			ON ${sql.ref(tableName)} (deleted_at, status)
 		`.execute(conn);
 
 		await sql`
-			CREATE INDEX ${sql.ref(`idx_${tableName}_deleted_created_id`)}
+			${createIndex} ${sql.ref(`idx_${tableName}_deleted_created_id`)}
 			ON ${sql.ref(tableName)} (deleted_at, created_at DESC, id DESC)
 		`.execute(conn);
 
 		await sql`
-			CREATE INDEX ${sql.ref(`idx_${tableName}_deleted_published_id`)}
+			${createIndex} ${sql.ref(`idx_${tableName}_deleted_published_id`)}
 			ON ${sql.ref(tableName)} (deleted_at, published_at DESC, id DESC)
 		`.execute(conn);
 
@@ -1015,16 +1534,67 @@ export class SchemaRegistry {
 		// inside Postgres's 63-byte identifier limit for long slugs; keep these
 		// names identical to migration 041.
 		await sql`
-			CREATE INDEX ${sql.ref(`idx_${tableName}_loc_upd`)}
+			${createIndex} ${sql.ref(`idx_${tableName}_loc_upd`)}
 			ON ${sql.ref(tableName)} (deleted_at, locale, updated_at DESC, id DESC)
 		`.execute(conn);
 
 		await sql`
-			CREATE INDEX ${sql.ref(`idx_${tableName}_loc_crt`)}
+			${createIndex} ${sql.ref(`idx_${tableName}_loc_crt`)}
 			ON ${sql.ref(tableName)} (deleted_at, locale, created_at DESC, id DESC)
 		`.execute(conn);
 	}
 
+	private getFieldIndexName(fieldId: string): string {
+		if (!FIELD_ID_PATTERN.test(fieldId)) {
+			throw new SchemaError(`Invalid field id "${fieldId}"`, "INVALID_FIELD_ID");
+		}
+		return `idx_cf_${fieldId.toLowerCase()}`;
+	}
+
+	private getLocaleFieldIndexName(fieldId: string): string {
+		return `${this.getFieldIndexName(fieldId)}_loc`;
+	}
+
+	private async createFieldIndex(
+		collectionSlug: string,
+		fieldId: string,
+		fieldSlug: string,
+		db?: Kysely<Database>,
+	): Promise<void> {
+		const conn = db ?? this.db;
+		const tableName = this.getTableName(collectionSlug);
+		const columnName = this.getColumnName(fieldSlug);
+		const indexName = this.getFieldIndexName(fieldId);
+		const localeIndexName = this.getLocaleFieldIndexName(fieldId);
+
+		await sql`
+			CREATE INDEX IF NOT EXISTS ${sql.ref(indexName)}
+			ON ${sql.ref(tableName)} (
+				(${sql.ref(columnName)} IS NOT NULL),
+				${sql.ref(columnName)},
+				id
+			)
+			WHERE deleted_at IS NULL
+		`.execute(conn);
+
+		await sql`
+			CREATE INDEX IF NOT EXISTS ${sql.ref(localeIndexName)}
+			ON ${sql.ref(tableName)} (
+				locale,
+				(${sql.ref(columnName)} IS NOT NULL),
+				${sql.ref(columnName)},
+				id
+			)
+			WHERE deleted_at IS NULL
+		`.execute(conn);
+	}
+
+	private async dropFieldIndex(fieldId: string, db?: Kysely<Database>): Promise<void> {
+		const conn = db ?? this.db;
+		await sql`DROP INDEX IF EXISTS ${sql.ref(this.getFieldIndexName(fieldId))}`.execute(conn);
+		await sql`DROP INDEX IF EXISTS ${sql.ref(this.getLocaleFieldIndexName(fieldId))}`.execute(conn);
+	}
+
 	/**
 	 * Add a column to a content table
 	 */
@@ -1224,10 +1794,18 @@ export class SchemaRegistry {
 			labelSingular: row.label_singular ?? undefined,
 			description: row.description ?? undefined,
 			icon: row.icon ?? undefined,
+			admin: parseCollectionAdmin(row.admin_config),
 			supports: parseSupports(row.supports),
 			source: row.source && isCollectionSource(row.source) ? row.source : undefined,
 			hasSeo: row.has_seo === 1,
+			// Raw value; undefined when unset. The admin list resolves the
+			// default (title fallback chain / updatedAt) at the point of use.
+			titleField: row.title_field ?? undefined,
+			dateField: row.date_field ?? undefined,
 			urlPattern: row.url_pattern ?? undefined,
+			routable: row.routable !== 0,
+			hidden: row.hidden === 1,
+			sortOrder: row.sort_order ?? undefined,
 			commentsEnabled: row.comments_enabled === 1,
 			commentsModeration:
 				moderation === "all" || moderation === "first_time" || moderation === "none"
@@ -1259,6 +1837,7 @@ export class SchemaRegistry {
 			options: row.options ? JSON.parse(row.options) : undefined,
 			sortOrder: row.sort_order,
 			searchable: row.searchable === 1,
+			indexed: row.indexed === 1,
 			translatable: row.translatable !== 0,
 			createdAt: row.created_at,
 		};
@@ -1338,6 +1917,9 @@ export class SchemaRegistry {
 	): Promise<Collection> {
 		// Verify table exists
 		const tableName = this.getTableName(slug);
+		if (await isMediaUsageCollectionSlugDeleting(this.db, slug)) {
+			throw new SchemaError(`Collection "${slug}" is already registered`, "COLLECTION_EXISTS");
+		}
 		const exists = await tableExists(this.db, tableName);
 
 		if (!exists) {
@@ -1346,32 +1928,64 @@ export class SchemaRegistry {
 
 		// Check if already registered
 		const existing = await this.getCollection(slug);
-		if (existing) {
+		if (await isMediaUsageCollectionSlugDeleting(this.db, slug)) {
+			throw new SchemaError(`Collection "${slug}" is already registered`, "COLLECTION_EXISTS");
+		}
+		if (
+			existing &&
+			!(await canResumeMediaUsageCollectionCapture(this.db, {
+				collectionId: existing.id,
+				collectionSlug: existing.slug,
+			}))
+		) {
 			throw new SchemaError(`Collection "${slug}" is already registered`, "COLLECTION_EXISTS");
 		}
 
 		// Create collection entry
-		const id = ulid();
+		const proposedId = existing?.id ?? ulid();
 		const label = options?.label || this.slugToLabel(slug);
 
 		let collectionRegistered = false;
 		try {
-			await this.db
-				.insertInto("_emdash_collections")
-				.values({
-					id,
-					slug,
-					label,
-					label_singular: options?.labelSingular ?? null,
-					description: options?.description ?? null,
-					icon: null,
-					supports: JSON.stringify([]),
-					source: "discovered",
-					has_seo: 0,
-					url_pattern: null,
-				})
-				.execute();
-			collectionRegistered = true;
+			const capture = await prepareMediaUsageCollectionCapture(this.db, {
+				collectionId: proposedId,
+				collectionSlug: slug,
+				registeredCollectionId: existing?.id,
+			});
+			if (capture.captureRequired) {
+				await installPreparedMediaUsageCollectionCapture(this.db, {
+					collectionId: capture.collectionId,
+					collectionSlug: slug,
+				});
+				await markMediaUsageCollectionCaptureReady(this.db, {
+					collectionId: capture.collectionId,
+					collectionSlug: slug,
+				});
+			}
+			if (!capture.registrationExists) {
+				await this.db
+					.insertInto("_emdash_collections")
+					.values({
+						id: capture.collectionId,
+						slug,
+						label,
+						label_singular: options?.labelSingular ?? null,
+						description: options?.description ?? null,
+						icon: null,
+						supports: JSON.stringify([]),
+						source: "discovered",
+						has_seo: 0,
+						url_pattern: null,
+					})
+					.execute();
+				collectionRegistered = true;
+			}
+			if (capture.captureRequired) {
+				await finalizeMediaUsageCollectionCapture(this.db, {
+					collectionId: capture.collectionId,
+					collectionSlug: slug,
+				});
+			}
 
 			const collection = await this.getCollection(slug);
 			if (!collection) {