emdash 0.33.0 → 0.34.0

package/src/database/migrations/064_fts_plain_text.ts

@@ -0,0 +1,253 @@
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+
+import { isSqlite } from "../dialect-helpers.js";
+import { validateIdentifier } from "../validate.js";
+
+/**
+ * Migration: Rebuild FTS5 indexes as self-contained tables indexing
+ * extracted Portable Text prose
+ *
+ * Background: FTS tables were external-content (`content='ec_<slug>'`),
+ * which forces the index to mirror the raw column values — and Portable
+ * Text fields store JSON, so the index was polluted with structural tokens
+ * (`_type`, `span`, style values like `normal`, `_key` ULIDs). Searches for
+ * those tokens matched nearly every document and snippets showed JSON
+ * fragments.
+ *
+ * The fix rebuilds each search-enabled collection's FTS table as a
+ * self-contained FTS5 table (no `content=` option) whose Portable Text
+ * columns hold extracted prose — every JSON string under a `text`, `alt`,
+ * `caption`, or `code` key — with sync triggers computing the same
+ * extraction in SQL. The update trigger carries a WHEN guard so only real
+ * value changes re-tokenize; shipping the guard inside this rebuild spares
+ * existing sites a second full re-tokenization from a follow-up migration.
+ * Self-contained tables also retire the external-content
+ * `'delete'` choreography and its corruption modes (see migration 039).
+ * The rebuilt table keeps the collection's configured `tokenize` from
+ * search_config rather than resetting it to the default.
+ *
+ * The SQL emitted here MUST stay in lock-step with
+ * `FTSManager.createTriggers` / `createFtsTable` / `populateFromContent` in
+ * `src/search/fts-manager.ts`. If those change again, add a new migration
+ * rather than editing this one — migrations are forward-only.
+ *
+ * Postgres: no-op. FTS5 is SQLite-only.
+ *
+ * D1: idempotent at the granularity we care about (drop-then-create +
+ * repopulate with `INSERT OR REPLACE`, so concurrent migrators converge).
+ * A partial apply that drops the FTS table without recreating it is healed
+ * by the next `verifyAndRepairIndex` call at runtime.
+ */
+
+interface CollectionRow {
+	slug: string;
+	search_config: string | null;
+}
+
+interface FieldRow {
+	slug: string;
+	type: string;
+}
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	if (!isSqlite(db)) return;
+
+	const collections = await sql<CollectionRow>`
+		SELECT slug, search_config FROM _emdash_collections
+		WHERE search_config IS NOT NULL
+	`.execute(db);
+
+	for (const collection of collections.rows) {
+		if (!isSearchEnabled(collection.search_config)) continue;
+
+		// Defensive re-validation before raw SQL interpolation, mirroring 039.
+		try {
+			validateIdentifier(collection.slug, "collection slug");
+		} catch (error) {
+			console.warn(
+				`[migration 064] skipping FTS rebuild for collection "${collection.slug}": ${
+					error instanceof Error ? error.message : String(error)
+				}`,
+			);
+			continue;
+		}
+
+		const fields = await getSearchableFields(db, collection.slug);
+		if (fields.length === 0) continue;
+
+		await rebuildIndex(db, collection.slug, fields, searchTokenizer(collection.search_config));
+	}
+}
+
+/**
+ * Forward-only. Down is a no-op: the FTS tables are managed by FTSManager
+ * at runtime and the self-contained shape remains fully functional for
+ * older code paths that only MATCH and join on id.
+ */
+export async function down(_db: Kysely<unknown>): Promise<void> {
+	// no-op
+}
+
+function isSearchEnabled(searchConfig: string | null): boolean {
+	if (!searchConfig) return false;
+	try {
+		const parsed: unknown = JSON.parse(searchConfig);
+		return (
+			typeof parsed === "object" &&
+			parsed !== null &&
+			"enabled" in parsed &&
+			parsed.enabled === true
+		);
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Tokenizers this migration knows how to carry across the rebuild — a frozen
+ * copy of SEARCH_TOKENIZERS as of this migration, not an import: a replay
+ * after the live allowlist changes must not reinterpret configs this
+ * migration never shipped with.
+ */
+const KNOWN_TOKENIZERS = ["porter unicode61", "unicode61", "trigram"];
+
+/**
+ * Tokenizer for the rebuilt table, from the collection's search_config.
+ * Values outside the allowlist (or unparsable config) fall back to the
+ * default rather than reaching the raw CREATE VIRTUAL TABLE statement.
+ */
+function searchTokenizer(searchConfig: string | null): string {
+	if (!searchConfig) return "porter unicode61";
+	try {
+		const parsed: unknown = JSON.parse(searchConfig);
+		if (typeof parsed === "object" && parsed !== null && "tokenize" in parsed) {
+			const configured = KNOWN_TOKENIZERS.find((tokenizer) => tokenizer === parsed.tokenize);
+			if (configured !== undefined) return configured;
+		}
+	} catch {
+		return "porter unicode61";
+	}
+	return "porter unicode61";
+}
+
+async function getSearchableFields(
+	db: Kysely<unknown>,
+	collectionSlug: string,
+): Promise<FieldRow[]> {
+	const rows = await sql<FieldRow>`
+		SELECT f.slug, f.type FROM _emdash_fields f
+		INNER JOIN _emdash_collections c ON c.id = f.collection_id
+		WHERE c.slug = ${collectionSlug} AND f.searchable = 1
+	`.execute(db);
+
+	const out: FieldRow[] = [];
+	for (const row of rows.rows) {
+		try {
+			validateIdentifier(row.slug, "searchable field name");
+			out.push(row);
+		} catch {
+			console.warn(
+				`[migration 064] skipping invalid searchable field "${row.slug}" on collection "${collectionSlug}"`,
+			);
+		}
+	}
+	return out;
+}
+
+/** Indexed-value expression for one field; lock-step with FTSManager.searchValueExpr. */
+function searchValueExpr(ref: string, fieldType: string): 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`
+	);
+}
+
+async function rebuildIndex(
+	db: Kysely<unknown>,
+	collectionSlug: string,
+	fields: FieldRow[],
+	tokenizer: string,
+): Promise<void> {
+	const ftsTable = `_emdash_fts_${collectionSlug}`;
+	const contentTable = `ec_${collectionSlug}`;
+	const slugs = fields.map((f) => f.slug);
+	const columnList = ["id UNINDEXED", "locale UNINDEXED", ...slugs].join(", ");
+	const fieldList = slugs.join(", ");
+	const newValueList = fields.map((f) => searchValueExpr(`NEW.${f.slug}`, f.type)).join(", ");
+	// The WHEN guard compares raw column values (null-safe IS NOT) so the
+	// update 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. deleted_at must stay in the guard or trash and
+	// restore stop syncing the index.
+	const changedCondition = ["deleted_at", "locale", ...slugs]
+		.map((f) => `OLD.${f} IS NOT NEW.${f}`)
+		.join(" OR ");
+	// Table-qualified: a bare column reference inside the json_tree extraction
+	// subquery binds to json_tree's own key/value/type/... columns.
+	const selectValueList = fields
+		.map((f) => searchValueExpr(`"${contentTable}"."${f.slug}"`, f.type))
+		.join(", ");
+
+	await sql.raw(`DROP TRIGGER IF EXISTS "${ftsTable}_insert"`).execute(db);
+	await sql.raw(`DROP TRIGGER IF EXISTS "${ftsTable}_update"`).execute(db);
+	await sql.raw(`DROP TRIGGER IF EXISTS "${ftsTable}_delete"`).execute(db);
+	await sql.raw(`DROP TABLE IF EXISTS "${ftsTable}"`).execute(db);
+
+	await sql
+		.raw(`
+		CREATE VIRTUAL TABLE IF NOT EXISTS "${ftsTable}" USING fts5(
+			${columnList},
+			tokenize='${tokenizer}'
+		)
+	`)
+		.execute(db);
+
+	await sql
+		.raw(`
+		CREATE TRIGGER IF NOT EXISTS "${ftsTable}_insert"
+		AFTER INSERT ON "${contentTable}"
+		WHEN NEW.deleted_at IS NULL
+		BEGIN
+			INSERT OR REPLACE INTO "${ftsTable}"(rowid, id, locale, ${fieldList})
+			VALUES (NEW.rowid, NEW.id, NEW.locale, ${newValueList});
+		END
+	`)
+		.execute(db);
+
+	await sql
+		.raw(`
+		CREATE TRIGGER IF NOT EXISTS "${ftsTable}_update"
+		AFTER UPDATE ON "${contentTable}"
+		WHEN ${changedCondition}
+		BEGIN
+			DELETE FROM "${ftsTable}" WHERE rowid = OLD.rowid;
+			INSERT INTO "${ftsTable}"(rowid, id, locale, ${fieldList})
+			SELECT NEW.rowid, NEW.id, NEW.locale, ${newValueList}
+			WHERE NEW.deleted_at IS NULL;
+		END
+	`)
+		.execute(db);
+
+	await sql
+		.raw(`
+		CREATE TRIGGER IF NOT EXISTS "${ftsTable}_delete"
+		AFTER DELETE ON "${contentTable}"
+		BEGIN
+			DELETE FROM "${ftsTable}" WHERE rowid = OLD.rowid;
+		END
+	`)
+		.execute(db);
+
+	await sql
+		.raw(`
+		INSERT OR REPLACE INTO "${ftsTable}"(rowid, id, locale, ${fieldList})
+		SELECT rowid, id, locale, ${selectValueList} FROM "${contentTable}"
+		WHERE deleted_at IS NULL
+	`)
+		.execute(db);
+}

package/src/database/migrations/065_media_usage_collection_deletion.ts

@@ -0,0 +1,85 @@
+import { sql, type Kysely, type RawBuilder } from "kysely";
+
+import { isPostgres } from "../dialect-helpers.js";
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await db.schema
+		.createTable("_emdash_media_usage_collection_deletions")
+		.ifNotExists()
+		.addColumn("collection_id", "text", (column) => column.notNull().primaryKey())
+		.addColumn("collection_slug", "text", (column) => column.notNull().unique())
+		.addColumn("force_delete", "integer", (column) => column.notNull())
+		.addColumn("state", "text", (column) => column.notNull().defaultTo("pending"))
+		.addColumn("phase", "text", (column) => column.notNull().defaultTo("fence"))
+		.addColumn("work_cursor", "text")
+		.addColumn("source_key", "text")
+		.addColumn("occurrence_cursor", "text")
+		.addColumn("attempt_count", "integer", (column) => column.notNull().defaultTo(0))
+		.addColumn("next_attempt_at", "text", (column) => column.notNull())
+		.addColumn("lease_token", "text")
+		.addColumn("lease_expires_at", "text")
+		.addColumn("last_error_code", "text")
+		.addColumn("created_at", "text", (column) =>
+			column.notNull().defaultTo(sortableUtcTimestamp(db)),
+		)
+		.addColumn("updated_at", "text", (column) =>
+			column.notNull().defaultTo(sortableUtcTimestamp(db)),
+		)
+		.execute();
+
+	await db.schema
+		.createIndex("idx__emdash_media_usage_collection_deletions_due")
+		.ifNotExists()
+		.on("_emdash_media_usage_collection_deletions")
+		.columns(["state", "next_attempt_at", "updated_at", "collection_id"])
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_media_usage_collection_deletions_lease")
+		.ifNotExists()
+		.on("_emdash_media_usage_collection_deletions")
+		.columns(["state", "lease_expires_at", "updated_at", "collection_id"])
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_media_usage_collection_deletions_operator")
+		.ifNotExists()
+		.on("_emdash_media_usage_collection_deletions")
+		.columns(["state", "updated_at", "collection_id"])
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_media_usage_sources_collection_cursor")
+		.ifNotExists()
+		.on("_emdash_media_usage_sources")
+		.columns(["source_type", "collection_id", "source_key"])
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_media_usage_source_cursor")
+		.ifNotExists()
+		.on("_emdash_media_usage")
+		.columns(["source_key", "id"])
+		.execute();
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	const deletion = await sql<{ present: number }>`
+		SELECT 1 AS present
+		FROM _emdash_media_usage_collection_deletions
+		LIMIT 1
+	`.execute(db);
+	if (deletion.rows.length > 0) {
+		throw new Error("Cannot roll back while durable collection deletion evidence exists");
+	}
+
+	await db.schema.dropIndex("idx__emdash_media_usage_source_cursor").ifExists().execute();
+	await db.schema
+		.dropIndex("idx__emdash_media_usage_sources_collection_cursor")
+		.ifExists()
+		.execute();
+	await db.schema.dropTable("_emdash_media_usage_collection_deletions").ifExists().execute();
+}
+
+function sortableUtcTimestamp(db: Kysely<unknown>): RawBuilder<string> {
+	if (isPostgres(db)) {
+		return sql`to_char(clock_timestamp() AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')`;
+	}
+	return sql`(strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`;
+}

package/src/database/migrations/066_media_usage_reconciliation.ts

@@ -0,0 +1,115 @@
+import { sql, type Kysely, type RawBuilder } from "kysely";
+
+import { columnExists, isPostgres, tableExists } from "../dialect-helpers.js";
+
+const ACTIVATION_KEY = "incremental_capture";
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await db.schema
+		.createTable("_emdash_media_usage_reconciliations")
+		.ifNotExists()
+		.addColumn("collection_id", "text", (column) => column.notNull().primaryKey())
+		.addColumn("collection_slug", "text", (column) => column.notNull())
+		.addColumn("run_token", "text", (column) => column.notNull())
+		.addColumn("target_epoch", "bigint")
+		.addColumn("field_fingerprint", "text")
+		.addColumn("state", "text", (column) => column.notNull().defaultTo("pending"))
+		.addColumn("phase", "text", (column) => column.notNull().defaultTo("scan"))
+		.addColumn("scan_cursor", "text")
+		.addColumn("scan_upper_id", "text")
+		.addColumn("source_cursor", "text")
+		.addColumn("source_upper_key", "text")
+		.addColumn("attempt_count", "integer", (column) => column.notNull().defaultTo(0))
+		.addColumn("next_attempt_at", "text", (column) => column.notNull())
+		.addColumn("lease_token", "text")
+		.addColumn("lease_expires_at", "text")
+		.addColumn("last_error_code", "text")
+		.addColumn("created_at", "text", (column) =>
+			column.notNull().defaultTo(sortableUtcTimestamp(db)),
+		)
+		.addColumn("updated_at", "text", (column) =>
+			column.notNull().defaultTo(sortableUtcTimestamp(db)),
+		)
+		.execute();
+
+	await db.schema
+		.createIndex("idx__emdash_media_usage_reconciliations_due")
+		.ifNotExists()
+		.on("_emdash_media_usage_reconciliations")
+		.columns(["state", "next_attempt_at", "updated_at", "collection_id"])
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_media_usage_reconciliations_lease")
+		.ifNotExists()
+		.on("_emdash_media_usage_reconciliations")
+		.columns(["state", "lease_expires_at", "updated_at", "collection_id"])
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_media_usage_reconciliations_failed")
+		.ifNotExists()
+		.on("_emdash_media_usage_reconciliations")
+		.columns(["state", "updated_at", "collection_id"])
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_media_usage_status_reconciliation")
+		.ifNotExists()
+		.on("_emdash_media_usage_index_status")
+		.columns([
+			"adapter_id",
+			"scope_type",
+			"capture_state",
+			"reconciliation_required",
+			"collection_id",
+		])
+		.execute();
+
+	if (!(await columnExists(db, "_emdash_media_usage_activation", "media_usage_maintenance_turn"))) {
+		await db.schema
+			.alterTable("_emdash_media_usage_activation")
+			.addColumn("media_usage_maintenance_turn", "integer", (column) =>
+				column.notNull().defaultTo(2),
+			)
+			.execute();
+	}
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	if (await tableExists(db, "_emdash_media_usage_reconciliations")) {
+		const evidence = await sql<{ present: number }>`
+			SELECT 1 AS present
+			FROM _emdash_media_usage_reconciliations
+			LIMIT 1
+		`.execute(db);
+		if (evidence.rows.length > 0) {
+			throw new Error("Cannot roll back while durable reconciliation evidence exists");
+		}
+	}
+
+	const activation = await sql<{ state: string }>`
+		SELECT state
+		FROM _emdash_media_usage_activation
+		WHERE task_key = ${ACTIVATION_KEY}
+	`.execute(db);
+	if (activation.rows[0]?.state !== "expanded") {
+		throw new Error("Cannot roll back media usage reconciliation after activation has started");
+	}
+
+	await db.schema.dropIndex("idx__emdash_media_usage_status_reconciliation").ifExists().execute();
+	await db.schema.dropIndex("idx__emdash_media_usage_reconciliations_failed").ifExists().execute();
+	await db.schema.dropIndex("idx__emdash_media_usage_reconciliations_lease").ifExists().execute();
+	await db.schema.dropIndex("idx__emdash_media_usage_reconciliations_due").ifExists().execute();
+	await db.schema.dropTable("_emdash_media_usage_reconciliations").ifExists().execute();
+	if (await columnExists(db, "_emdash_media_usage_activation", "media_usage_maintenance_turn")) {
+		await db.schema
+			.alterTable("_emdash_media_usage_activation")
+			.dropColumn("media_usage_maintenance_turn")
+			.execute();
+	}
+}
+
+function sortableUtcTimestamp(db: Kysely<unknown>): RawBuilder<string> {
+	if (isPostgres(db)) {
+		return sql`to_char(clock_timestamp() AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')`;
+	}
+	return sql`(strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`;
+}

package/src/database/migrations/067_indexed_content_fields.ts

@@ -0,0 +1,39 @@
+import { sql, type Kysely } from "kysely";
+
+import { columnExists } from "../dialect-helpers.js";
+
+const FIELD_ID_PATTERN = /^[0-9A-Z]{26}$/;
+
+/** Mark custom fields whose structured list queries are backed by a physical index. */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	if (!(await columnExists(db, "_emdash_fields", "indexed"))) {
+		await db.schema
+			.alterTable("_emdash_fields")
+			.addColumn("indexed", "integer", (column) => column.notNull().defaultTo(0))
+			.execute();
+	}
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	if (!(await columnExists(db, "_emdash_fields", "indexed"))) {
+		return;
+	}
+
+	const indexedFields = await sql<{ id: string }>`
+		SELECT id FROM _emdash_fields WHERE indexed = 1
+	`.execute(db);
+
+	for (const field of indexedFields.rows) {
+		if (!FIELD_ID_PATTERN.test(field.id)) {
+			throw new Error(`Invalid indexed field id "${field.id}"`);
+		}
+		await sql`
+			DROP INDEX IF EXISTS ${sql.ref(`idx_cf_${field.id.toLowerCase()}`)}
+		`.execute(db);
+		await sql`
+			DROP INDEX IF EXISTS ${sql.ref(`idx_cf_${field.id.toLowerCase()}_loc`)}
+		`.execute(db);
+	}
+
+	await db.schema.alterTable("_emdash_fields").dropColumn("indexed").execute();
+}

package/src/database/migrations/068_content_taxonomy_entry_groups.ts

@@ -0,0 +1,61 @@
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+
+import { listTablesLike } from "../dialect-helpers.js";
+import { validateIdentifier } from "../validate.js";
+
+const LEGACY_DENORM_INDEXES = [
+	"idx_content_taxonomies_pub",
+	"idx_content_taxonomies_crt",
+	"idx_content_taxonomies_loc_pub",
+	"idx_content_taxonomies_loc_crt",
+] as const;
+
+/**
+ * Store the content translation_group in content_taxonomies.entry_id.
+ * Existing per-locale rows are merged into one assignment per content group
+ * and term group. Rows whose content table or content entry no longer exists
+ * are left untouched.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	const tableNames = await listTablesLike(db, "ec_%");
+	for (const tableName of tableNames) {
+		validateIdentifier(tableName, "content table name");
+		const collection = tableName.slice("ec_".length);
+
+		await sql`
+			INSERT INTO content_taxonomies (collection, entry_id, taxonomy_id)
+			SELECT DISTINCT ${collection}, content.translation_group, pivot.taxonomy_id
+			FROM content_taxonomies AS pivot
+			INNER JOIN ${sql.ref(tableName)} AS content ON content.id = pivot.entry_id
+			WHERE pivot.collection = ${collection}
+				AND content.translation_group IS NOT NULL
+			ON CONFLICT (collection, entry_id, taxonomy_id) DO NOTHING
+		`.execute(db);
+
+		await sql`
+			DELETE FROM content_taxonomies
+			WHERE collection = ${collection}
+				AND entry_id IN (
+					SELECT id
+					FROM ${sql.ref(tableName)}
+					WHERE translation_group IS NOT NULL AND id != translation_group
+				)
+		`.execute(db);
+	}
+
+	for (const indexName of LEGACY_DENORM_INDEXES) {
+		await sql`DROP INDEX IF EXISTS ${sql.ref(indexName)}`.execute(db);
+	}
+	await db.schema
+		.createIndex("idx_content_taxonomies_group_lookup")
+		.ifNotExists()
+		.on("content_taxonomies")
+		.columns(["taxonomy_id", "collection", "entry_id"])
+		.execute();
+}
+
+/** The collapsed per-locale rows cannot be reconstructed. */
+export async function down(_db: Kysely<unknown>): Promise<void> {
+	// no-op
+}

package/src/database/migrations/069_collection_title_date_fields.ts

@@ -0,0 +1,45 @@
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+
+import { columnExists } from "../dialect-helpers.js";
+
+/**
+ * Migration: configurable title and date fields for collections
+ *
+ * Adds `title_field` and `date_field` columns to `_emdash_collections` so a
+ * collection can override which field powers the Title column and which field
+ * powers the Date column in the admin content list. Both are nullable — NULL
+ * preserves the current defaults (title-style display, last-updated date).
+ *
+ * Column adds/drops are guarded by `columnExists`: D1 has no transactions, so a
+ * migration can partially apply without being recorded and later re-run.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	if (!(await columnExists(db, "_emdash_collections", "title_field"))) {
+		await sql`
+			ALTER TABLE _emdash_collections
+			ADD COLUMN title_field TEXT
+		`.execute(db);
+	}
+	if (!(await columnExists(db, "_emdash_collections", "date_field"))) {
+		await sql`
+			ALTER TABLE _emdash_collections
+			ADD COLUMN date_field TEXT
+		`.execute(db);
+	}
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	if (await columnExists(db, "_emdash_collections", "date_field")) {
+		await sql`
+			ALTER TABLE _emdash_collections
+			DROP COLUMN date_field
+		`.execute(db);
+	}
+	if (await columnExists(db, "_emdash_collections", "title_field")) {
+		await sql`
+			ALTER TABLE _emdash_collections
+			DROP COLUMN title_field
+		`.execute(db);
+	}
+}

package/src/database/migrations/070_collection_routable.ts

@@ -0,0 +1,18 @@
+import type { Kysely } from "kysely";
+
+import { columnExists } from "../dialect-helpers.js";
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	if (!(await columnExists(db, "_emdash_collections", "routable"))) {
+		await db.schema
+			.alterTable("_emdash_collections")
+			.addColumn("routable", "integer", (col) => col.notNull().defaultTo(1))
+			.execute();
+	}
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	if (await columnExists(db, "_emdash_collections", "routable")) {
+		await db.schema.alterTable("_emdash_collections").dropColumn("routable").execute();
+	}
+}

package/src/database/migrations/runner.ts

@@ -62,6 +62,17 @@ import * as m056 from "./056_taxonomy_term_sort_order.js";
 import * as m057 from "./057_collection_hidden.js";
 import * as m058 from "./058_collection_sort_order.js";
 import * as m059 from "./059_revision_prune_queue.js";
+import * as m060 from "./060_collection_admin_config.js";
+import * as m061 from "./061_media_usage_cleanup.js";
+import * as m062 from "./062_media_usage_cleanup_fence.js";
+import * as m063 from "./063_media_usage_incremental_work.js";
+import * as m064 from "./064_fts_plain_text.js";
+import * as m065 from "./065_media_usage_collection_deletion.js";
+import * as m066 from "./066_media_usage_reconciliation.js";
+import * as m067 from "./067_indexed_content_fields.js";
+import * as m068 from "./068_content_taxonomy_entry_groups.js";
+import * as m069 from "./069_collection_title_date_fields.js";
+import * as m070 from "./070_collection_routable.js";
 
 const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"001_initial": m001,
@@ -122,6 +133,17 @@ const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"057_collection_hidden": m057,
 	"058_collection_sort_order": m058,
 	"059_revision_prune_queue": m059,
+	"060_collection_admin_config": m060,
+	"061_media_usage_cleanup": m061,
+	"062_media_usage_cleanup_fence": m062,
+	"063_media_usage_incremental_work": m063,
+	"064_fts_plain_text": m064,
+	"065_media_usage_collection_deletion": m065,
+	"066_media_usage_reconciliation": m066,
+	"067_indexed_content_fields": m067,
+	"068_content_taxonomy_entry_groups": m068,
+	"069_collection_title_date_fields": m069,
+	"070_collection_routable": m070,
 });
 
 /** Total number of registered migrations. Exported for use in tests. */