emdash 0.41.0 → 0.42.0

package/src/content/converters/portable-text-to-prosemirror.ts

@@ -645,6 +645,10 @@ function imageAlignment(value: unknown): PortableTextImageBlock["alignment"] {
 		: undefined;
 }
 
+function imageDimension(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+
 /**
  * Convert image block to ProseMirror
  */
@@ -656,13 +660,14 @@ function convertImage(block: PortableTextImageBlock, preserveIdentity: boolean):
 			{
 				src: asset.url || asset._ref,
 				alt: alt || "",
-				title: block.caption || "",
+				title: block.title || "",
+				caption: Object.hasOwn(block, "caption") ? block.caption || "" : block.title || "",
 				mediaId: asset._ref,
 				provider: asset.provider,
-				width,
-				height,
-				displayWidth: block.displayWidth,
-				displayHeight: block.displayHeight,
+				width: imageDimension(width),
+				height: imageDimension(height),
+				displayWidth: imageDimension(block.displayWidth),
+				displayHeight: imageDimension(block.displayHeight),
 				alignment: imageAlignment(block.alignment),
 				link: normalizeImageLink(block.link),
 			},
@@ -684,24 +689,25 @@ function convertMalformedImage(
 	// PortableTextUnknownBlock allows indexed access via [key: string]: unknown
 	const url = "url" in block && typeof block.url === "string" ? block.url : "";
 	const alt = "alt" in block && typeof block.alt === "string" ? block.alt : "";
-	const caption = "caption" in block && typeof block.caption === "string" ? block.caption : "";
-	const width = "width" in block && typeof block.width === "number" ? block.width : undefined;
-	const height = "height" in block && typeof block.height === "number" ? block.height : undefined;
-	const displayWidth =
-		"displayWidth" in block && typeof block.displayWidth === "number"
-			? block.displayWidth
-			: undefined;
-	const displayHeight =
-		"displayHeight" in block && typeof block.displayHeight === "number"
-			? block.displayHeight
-			: undefined;
+	const title = "title" in block && typeof block.title === "string" ? block.title : "";
+	const rawCaption = "caption" in block ? block.caption : undefined;
+	const caption = Object.hasOwn(block, "caption")
+		? typeof rawCaption === "string"
+			? rawCaption
+			: ""
+		: title;
+	const width = imageDimension("width" in block ? block.width : undefined);
+	const height = imageDimension("height" in block ? block.height : undefined);
+	const displayWidth = imageDimension("displayWidth" in block ? block.displayWidth : undefined);
+	const displayHeight = imageDimension("displayHeight" in block ? block.displayHeight : undefined);
 	return {
 		type: "image",
 		attrs: identityAttrs(
 			{
 				src: url,
 				alt,
-				title: caption,
+				title,
+				caption,
 				mediaId: undefined,
 				provider: undefined,
 				width,

package/src/content/converters/prosemirror-to-portable-text.ts

@@ -359,6 +359,10 @@ function convertHtmlBlock(node: ProseMirrorNode): PortableTextHtmlBlock {
 	};
 }
 
+function imageDimension(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+
 /**
  * Convert image to Portable Text
  */
@@ -369,10 +373,16 @@ function convertImage(node: ProseMirrorNode): PortableTextImageBlock {
 	const src = typeof attrs?.src === "string" ? attrs.src : "";
 	const alt = typeof attrs?.alt === "string" ? attrs.alt : undefined;
 	const title = typeof attrs?.title === "string" ? attrs.title : undefined;
-	const width = typeof attrs?.width === "number" ? attrs.width : undefined;
-	const height = typeof attrs?.height === "number" ? attrs.height : undefined;
-	const displayWidth = typeof attrs?.displayWidth === "number" ? attrs.displayWidth : undefined;
-	const displayHeight = typeof attrs?.displayHeight === "number" ? attrs.displayHeight : undefined;
+	const caption =
+		attrs && Object.hasOwn(attrs, "caption")
+			? typeof attrs.caption === "string"
+				? attrs.caption
+				: undefined
+			: title;
+	const width = imageDimension(attrs?.width);
+	const height = imageDimension(attrs?.height);
+	const displayWidth = imageDimension(attrs?.displayWidth);
+	const displayHeight = imageDimension(attrs?.displayHeight);
 	const alignment = attrs?.alignment;
 
 	// Normalise link: drop entirely when href is missing or empty so half-populated
@@ -400,7 +410,8 @@ function convertImage(node: ProseMirrorNode): PortableTextImageBlock {
 			provider: provider && provider !== "local" ? provider : undefined,
 		},
 		alt: alt || undefined,
-		caption: title || undefined,
+		caption: caption || (title ? "" : undefined),
+		title: title || undefined,
 		width: width || undefined,
 		height: height || undefined,
 		displayWidth: displayWidth || undefined,

package/src/content/converters/types.ts

@@ -71,6 +71,7 @@ export interface PortableTextImageBlock {
 	};
 	alt?: string;
 	caption?: string;
+	title?: string;
 	/** Original image width */
 	width?: number;
 	/** Original image height */

package/src/database/content-datetime.ts

@@ -6,16 +6,24 @@ import {
 	normalizeDatetime,
 	type DatetimeFieldDescriptor,
 } from "../datetime-normalization.js";
-import type { RepeaterSubField } from "../schema/types.js";
+import { requestCached } from "../request-cache.js";
+import type { FieldType, RepeaterSubField } from "../schema/types.js";
+import { isSafeUrlFieldWriteValue } from "../utils/url.js";
 import { EmDashValidationError } from "./repositories/types.js";
 import type { Database } from "./types.js";
 
+interface UrlFieldDescriptor {
+	slug: string;
+	urlSubFields?: readonly string[];
+}
+
 interface DatetimeContext {
 	timezone: string;
 	fields: DatetimeFieldDescriptor[];
+	urlFields: UrlFieldDescriptor[];
 }
 
-function repeaterDatetimeFields(validation: string | null): string[] {
+function repeaterSubFieldsOfType(validation: string | null, type: FieldType): string[] {
 	if (!validation) return [];
 	let parsed: unknown;
 	try {
@@ -32,7 +40,7 @@ function repeaterDatetimeFields(validation: string | null): string[] {
 				typeof field === "object" &&
 				field !== null &&
 				"type" in field &&
-				field.type === "datetime" &&
+				field.type === type &&
 				"slug" in field &&
 				typeof field.slug === "string",
 		)
@@ -54,13 +62,18 @@ export class ContentDatetimeNormalizer {
 	) {}
 
 	private context(collection: string): Promise<DatetimeContext> {
-		if (!this.contexts) return this.loadContext(collection);
-		let context = this.contexts.get(collection);
-		if (!context) {
-			context = this.loadContext(collection);
-			this.contexts.set(collection, context);
+		if (this.contexts) {
+			let context = this.contexts.get(collection);
+			if (!context) {
+				context = this.loadContext(collection);
+				this.contexts.set(collection, context);
+			}
+			return context;
 		}
-		return context;
+		// Fall back to the per-request cache so repeated writes in the same
+		// invocation (e.g. bulk imports) do not re-query field/timezone metadata
+		// for every item.
+		return requestCached(`datetimeContext:${collection}`, () => this.loadContext(collection));
 	}
 
 	private async loadContext(collection: string): Promise<DatetimeContext> {
@@ -70,7 +83,7 @@ export class ContentDatetimeNormalizer {
 				.innerJoin("_emdash_collections as collection", "collection.id", "field.collection_id")
 				.select(["field.slug", "field.type", "field.validation"])
 				.where("collection.slug", "=", collection)
-				.where("field.type", "in", ["datetime", "repeater"])
+				.where("field.type", "in", ["datetime", "repeater", "url"])
 				.execute(),
 			this.db
 				.selectFrom("options")
@@ -87,18 +100,39 @@ export class ContentDatetimeNormalizer {
 				// The datetime normalizer reports an invalid timezone when it encounters a value.
 			}
 		}
-		return {
-			timezone,
-			fields: rows.map((row) =>
-				row.type === "datetime"
-					? { slug: row.slug, type: "datetime" }
-					: {
-							slug: row.slug,
-							type: "repeater",
-							datetimeSubFields: repeaterDatetimeFields(row.validation),
-						},
-			),
-		};
+		const fields: DatetimeFieldDescriptor[] = [];
+		const urlFields: UrlFieldDescriptor[] = [];
+		for (const row of rows) {
+			if (row.type === "datetime") {
+				fields.push({ slug: row.slug, type: "datetime" });
+			} else if (row.type === "url") {
+				urlFields.push({ slug: row.slug });
+			} else {
+				fields.push({
+					slug: row.slug,
+					type: "repeater",
+					datetimeSubFields: repeaterSubFieldsOfType(row.validation, "datetime"),
+				});
+				const urlSubFields = repeaterSubFieldsOfType(row.validation, "url");
+				if (urlSubFields.length > 0) urlFields.push({ slug: row.slug, urlSubFields });
+			}
+		}
+		return { timezone, fields, urlFields };
+	}
+
+	/**
+	 * Normalizes datetimes in incoming field values and rejects `url` values
+	 * with unsafe schemes, control characters, or off-site path forms. Values
+	 * already stored are not checked, so restoring or syncing existing data
+	 * goes through {@link normalizeData} instead.
+	 */
+	async normalizeInput(
+		collection: string,
+		data: Record<string, unknown>,
+	): Promise<Record<string, unknown>> {
+		const context = await this.context(collection);
+		assertSafeUrlFields(data, context.urlFields);
+		return this.normalizeWithContext(context, [data])[0] ?? data;
 	}
 
 	async normalizeData(
@@ -113,7 +147,13 @@ export class ContentDatetimeNormalizer {
 		collection: string,
 		items: readonly Record<string, unknown>[],
 	): Promise<Record<string, unknown>[]> {
-		const context = await this.context(collection);
+		return this.normalizeWithContext(await this.context(collection), items);
+	}
+
+	private normalizeWithContext(
+		context: DatetimeContext,
+		items: readonly Record<string, unknown>[],
+	): Record<string, unknown>[] {
 		try {
 			return items.map(
 				(data) => normalizeContentDatetimes(data, context.fields, context.timezone).value,
@@ -138,3 +178,51 @@ export class ContentDatetimeNormalizer {
 		}
 	}
 }
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// Reads parse a stored string that looks like JSON, so a repeater written as a JSON string
+// comes back as rows and must be checked as rows.
+function repeaterRows(value: unknown): unknown[] | undefined {
+	let rows = value;
+	if (typeof rows === "string" && rows.startsWith("[")) {
+		try {
+			rows = JSON.parse(rows);
+		} catch {
+			return undefined;
+		}
+	}
+	return Array.isArray(rows) ? rows : undefined;
+}
+
+function assertSafeUrl(path: string, value: unknown): void {
+	if (typeof value === "string" && !isSafeUrlFieldWriteValue(value)) {
+		throw new EmDashValidationError(
+			`Field "${path}" must use http, https, mailto, or tel, or be a safe relative path or fragment`,
+			{ path },
+		);
+	}
+}
+
+function assertSafeUrlFields(
+	data: Record<string, unknown>,
+	urlFields: readonly UrlFieldDescriptor[],
+): void {
+	for (const field of urlFields) {
+		const value = data[field.slug];
+		if (!field.urlSubFields) {
+			assertSafeUrl(field.slug, value);
+			continue;
+		}
+		const rows = repeaterRows(value);
+		if (!rows) continue;
+		for (const [index, row] of rows.entries()) {
+			if (!isRecord(row)) continue;
+			for (const subField of field.urlSubFields) {
+				assertSafeUrl(`${field.slug}.${index}.${subField}`, row[subField]);
+			}
+		}
+	}
+}

package/src/database/migrations/036_i18n_menus_and_taxonomies.ts

@@ -2,7 +2,7 @@ import type { Kysely } from "kysely";
 import { sql } from "kysely";
 
 import { getI18nConfig } from "../../i18n/config.js";
-import { currentTimestamp, isSqlite } from "../dialect-helpers.js";
+import { currentTimestamp, isSqlite, tableExists } from "../dialect-helpers.js";
 import { validateIdentifier } from "../validate.js";
 
 /**
@@ -51,37 +51,53 @@ export async function up(db: Kysely<unknown>): Promise<void> {
 	await remapMenuItemRefs(db);
 }
 
+/**
+ * D1 commits each statement of a rebuild on its own. A run that stopped
+ * between dropping `table` and renaming `<table>_new` leaves the staged copy
+ * as the only one, and the guards below read the old table, so rename the
+ * staged copy back before they run.
+ */
+async function resumeStagedRebuild(db: Kysely<unknown>, table: string): Promise<void> {
+	const staged = `${table}_new`;
+	if ((await tableExists(db, table)) || !(await tableExists(db, staged))) return;
+	await db.schema.alterTable(staged).renameTo(table).execute();
+}
+
 async function rebuildMenus(db: Kysely<unknown>, defaultLocale: string): Promise<void> {
-	if (await hasColumn(db, "_emdash_menus", "locale")) return;
-	await sql.raw(`DROP TABLE IF EXISTS "_emdash_menus_new"`).execute(db);
+	await resumeStagedRebuild(db, "_emdash_menus");
+	if (!(await hasColumn(db, "_emdash_menus", "locale"))) {
+		await sql.raw(`DROP TABLE IF EXISTS "_emdash_menus_new"`).execute(db);
 
-	await db.schema
-		.createTable("_emdash_menus_new")
-		.addColumn("id", "text", (c) => c.primaryKey())
-		.addColumn("name", "text", (c) => c.notNull())
-		.addColumn("label", "text", (c) => c.notNull())
-		.addColumn("created_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
-		.addColumn("updated_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
-		.addColumn("locale", "text", (c) => c.notNull().defaultTo(defaultLocale))
-		.addColumn("translation_group", "text")
-		.addUniqueConstraint("_emdash_menus_name_locale_unique", ["name", "locale"])
-		.execute();
+		await db.schema
+			.createTable("_emdash_menus_new")
+			.addColumn("id", "text", (c) => c.primaryKey())
+			.addColumn("name", "text", (c) => c.notNull())
+			.addColumn("label", "text", (c) => c.notNull())
+			.addColumn("created_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
+			.addColumn("updated_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
+			.addColumn("locale", "text", (c) => c.notNull().defaultTo(defaultLocale))
+			.addColumn("translation_group", "text")
+			.addUniqueConstraint("_emdash_menus_name_locale_unique", ["name", "locale"])
+			.execute();
 
-	await sql`
-		INSERT INTO _emdash_menus_new (id, name, label, created_at, updated_at, locale, translation_group)
-		SELECT id, name, label, created_at, updated_at, ${defaultLocale}, id FROM _emdash_menus
-	`.execute(db);
+		await sql`
+			INSERT INTO _emdash_menus_new (id, name, label, created_at, updated_at, locale, translation_group)
+			SELECT id, name, label, created_at, updated_at, ${defaultLocale}, id FROM _emdash_menus
+		`.execute(db);
 
-	await db.schema.dropTable("_emdash_menus").execute();
-	await sql`ALTER TABLE _emdash_menus_new RENAME TO _emdash_menus`.execute(db);
+		await db.schema.dropTable("_emdash_menus").execute();
+		await sql`ALTER TABLE _emdash_menus_new RENAME TO _emdash_menus`.execute(db);
+	}
 
 	await db.schema
 		.createIndex("idx__emdash_menus_locale")
+		.ifNotExists()
 		.on("_emdash_menus")
 		.column("locale")
 		.execute();
 	await db.schema
 		.createIndex("idx__emdash_menus_translation_group")
+		.ifNotExists()
 		.on("_emdash_menus")
 		.column("translation_group")
 		.execute();
@@ -94,29 +110,30 @@ async function rebuildMenuItems(db: Kysely<unknown>, defaultLocale: string): Pro
 	// on D1 (#1021). The FKs were never load-bearing at runtime — D1
 	// disables FK enforcement, and `MenuRepository` always deletes
 	// children explicitly. Mirrors `rebuildContentTaxonomies` below.
-	if (await hasColumn(db, "_emdash_menu_items", "locale")) return;
-	await sql.raw(`DROP TABLE IF EXISTS "_emdash_menu_items_new"`).execute(db);
+	await resumeStagedRebuild(db, "_emdash_menu_items");
+	if (!(await hasColumn(db, "_emdash_menu_items", "locale"))) {
+		await sql.raw(`DROP TABLE IF EXISTS "_emdash_menu_items_new"`).execute(db);
 
-	await db.schema
-		.createTable("_emdash_menu_items_new")
-		.addColumn("id", "text", (c) => c.primaryKey())
-		.addColumn("menu_id", "text", (c) => c.notNull())
-		.addColumn("parent_id", "text")
-		.addColumn("sort_order", "integer", (c) => c.notNull().defaultTo(0))
-		.addColumn("type", "text", (c) => c.notNull())
-		.addColumn("reference_collection", "text")
-		.addColumn("reference_id", "text")
-		.addColumn("custom_url", "text")
-		.addColumn("label", "text", (c) => c.notNull())
-		.addColumn("title_attr", "text")
-		.addColumn("target", "text")
-		.addColumn("css_classes", "text")
-		.addColumn("created_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
-		.addColumn("locale", "text", (c) => c.notNull().defaultTo(defaultLocale))
-		.addColumn("translation_group", "text")
-		.execute();
+		await db.schema
+			.createTable("_emdash_menu_items_new")
+			.addColumn("id", "text", (c) => c.primaryKey())
+			.addColumn("menu_id", "text", (c) => c.notNull())
+			.addColumn("parent_id", "text")
+			.addColumn("sort_order", "integer", (c) => c.notNull().defaultTo(0))
+			.addColumn("type", "text", (c) => c.notNull())
+			.addColumn("reference_collection", "text")
+			.addColumn("reference_id", "text")
+			.addColumn("custom_url", "text")
+			.addColumn("label", "text", (c) => c.notNull())
+			.addColumn("title_attr", "text")
+			.addColumn("target", "text")
+			.addColumn("css_classes", "text")
+			.addColumn("created_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
+			.addColumn("locale", "text", (c) => c.notNull().defaultTo(defaultLocale))
+			.addColumn("translation_group", "text")
+			.execute();
 
-	await sql`
+		await sql`
 		INSERT INTO _emdash_menu_items_new (
 			id, menu_id, parent_id, sort_order, type, reference_collection,
 			reference_id, custom_url, label, title_attr, target, css_classes,
@@ -129,73 +146,91 @@ async function rebuildMenuItems(db: Kysely<unknown>, defaultLocale: string): Pro
 		FROM _emdash_menu_items
 	`.execute(db);
 
-	await db.schema.dropTable("_emdash_menu_items").execute();
-	await sql`ALTER TABLE _emdash_menu_items_new RENAME TO _emdash_menu_items`.execute(db);
+		await db.schema.dropTable("_emdash_menu_items").execute();
+		await sql`ALTER TABLE _emdash_menu_items_new RENAME TO _emdash_menu_items`.execute(db);
+	}
 
 	// Indexes from migration 005 are dropped with the underlying table; recreate.
 	await db.schema
 		.createIndex("idx_menu_items_menu")
+		.ifNotExists()
 		.on("_emdash_menu_items")
 		.columns(["menu_id", "sort_order"])
 		.execute();
 	await db.schema
 		.createIndex("idx_menu_items_parent")
+		.ifNotExists()
 		.on("_emdash_menu_items")
 		.column("parent_id")
 		.execute();
 	await db.schema
 		.createIndex("idx__emdash_menu_items_locale")
+		.ifNotExists()
 		.on("_emdash_menu_items")
 		.column("locale")
 		.execute();
 	await db.schema
 		.createIndex("idx__emdash_menu_items_translation_group")
+		.ifNotExists()
 		.on("_emdash_menu_items")
 		.column("translation_group")
 		.execute();
 }
 
 async function rebuildTaxonomies(db: Kysely<unknown>, defaultLocale: string): Promise<void> {
-	if (await hasColumn(db, "taxonomies", "locale")) return;
-	await sql.raw(`DROP TABLE IF EXISTS "taxonomies_new"`).execute(db);
-	await sql`DROP INDEX IF EXISTS idx_taxonomies_name`.execute(db);
+	await resumeStagedRebuild(db, "taxonomies");
+	if (!(await hasColumn(db, "taxonomies", "locale"))) {
+		await sql.raw(`DROP TABLE IF EXISTS "taxonomies_new"`).execute(db);
+		await sql`DROP INDEX IF EXISTS idx_taxonomies_name`.execute(db);
 
-	await db.schema
-		.createTable("taxonomies_new")
-		.addColumn("id", "text", (c) => c.primaryKey())
-		.addColumn("name", "text", (c) => c.notNull())
-		.addColumn("slug", "text", (c) => c.notNull())
-		.addColumn("label", "text", (c) => c.notNull())
-		.addColumn("parent_id", "text")
-		.addColumn("data", "text")
-		.addColumn("locale", "text", (c) => c.notNull().defaultTo(defaultLocale))
-		.addColumn("translation_group", "text")
-		.addUniqueConstraint("taxonomies_name_slug_locale_unique", ["name", "slug", "locale"])
-		// Self-FK points at `taxonomies_new` (not `taxonomies`) so dropping
-		// the old table doesn't fire ON DELETE SET NULL against parent_id
-		// values on D1. SQLite's RENAME rewrites the FK target to the new
-		// name automatically.
-		.addForeignKeyConstraint(
-			"taxonomies_parent_fk",
-			["parent_id"],
-			"taxonomies_new",
-			["id"],
-			(cb) => cb.onDelete("set null"),
-		)
-		.execute();
+		await db.schema
+			.createTable("taxonomies_new")
+			.addColumn("id", "text", (c) => c.primaryKey())
+			.addColumn("name", "text", (c) => c.notNull())
+			.addColumn("slug", "text", (c) => c.notNull())
+			.addColumn("label", "text", (c) => c.notNull())
+			.addColumn("parent_id", "text")
+			.addColumn("data", "text")
+			.addColumn("locale", "text", (c) => c.notNull().defaultTo(defaultLocale))
+			.addColumn("translation_group", "text")
+			.addUniqueConstraint("taxonomies_name_slug_locale_unique", ["name", "slug", "locale"])
+			// Self-FK points at `taxonomies_new` (not `taxonomies`) so dropping
+			// the old table doesn't fire ON DELETE SET NULL against parent_id
+			// values on D1. SQLite's RENAME rewrites the FK target to the new
+			// name automatically.
+			.addForeignKeyConstraint(
+				"taxonomies_parent_fk",
+				["parent_id"],
+				"taxonomies_new",
+				["id"],
+				(cb) => cb.onDelete("set null"),
+			)
+			.execute();
 
-	await sql`
+		await sql`
 		INSERT INTO taxonomies_new (id, name, slug, label, parent_id, data, locale, translation_group)
 		SELECT id, name, slug, label, parent_id, data, ${defaultLocale}, id FROM taxonomies
 	`.execute(db);
 
-	await db.schema.dropTable("taxonomies").execute();
-	await sql`ALTER TABLE taxonomies_new RENAME TO taxonomies`.execute(db);
+		await db.schema.dropTable("taxonomies").execute();
+		await sql`ALTER TABLE taxonomies_new RENAME TO taxonomies`.execute(db);
+	}
 
-	await db.schema.createIndex("idx_taxonomies_name").on("taxonomies").column("name").execute();
-	await db.schema.createIndex("idx_taxonomies_locale").on("taxonomies").column("locale").execute();
+	await db.schema
+		.createIndex("idx_taxonomies_name")
+		.ifNotExists()
+		.on("taxonomies")
+		.column("name")
+		.execute();
+	await db.schema
+		.createIndex("idx_taxonomies_locale")
+		.ifNotExists()
+		.on("taxonomies")
+		.column("locale")
+		.execute();
 	await db.schema
 		.createIndex("idx_taxonomies_translation_group")
+		.ifNotExists()
 		.on("taxonomies")
 		.column("translation_group")
 		.execute();
@@ -211,40 +246,44 @@ async function rebuildTaxonomies(db: Kysely<unknown>, defaultLocale: string): Pr
 }
 
 async function rebuildTaxonomyDefs(db: Kysely<unknown>, defaultLocale: string): Promise<void> {
-	if (await hasColumn(db, "_emdash_taxonomy_defs", "locale")) return;
-	await sql.raw(`DROP TABLE IF EXISTS "_emdash_taxonomy_defs_new"`).execute(db);
+	await resumeStagedRebuild(db, "_emdash_taxonomy_defs");
+	if (!(await hasColumn(db, "_emdash_taxonomy_defs", "locale"))) {
+		await sql.raw(`DROP TABLE IF EXISTS "_emdash_taxonomy_defs_new"`).execute(db);
 
-	await db.schema
-		.createTable("_emdash_taxonomy_defs_new")
-		.addColumn("id", "text", (c) => c.primaryKey())
-		.addColumn("name", "text", (c) => c.notNull())
-		.addColumn("label", "text", (c) => c.notNull())
-		.addColumn("label_singular", "text")
-		.addColumn("hierarchical", "integer", (c) => c.defaultTo(0))
-		.addColumn("collections", "text")
-		.addColumn("created_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
-		.addColumn("locale", "text", (c) => c.notNull().defaultTo(defaultLocale))
-		.addColumn("translation_group", "text")
-		.addUniqueConstraint("_emdash_taxonomy_defs_name_locale_unique", ["name", "locale"])
-		.execute();
+		await db.schema
+			.createTable("_emdash_taxonomy_defs_new")
+			.addColumn("id", "text", (c) => c.primaryKey())
+			.addColumn("name", "text", (c) => c.notNull())
+			.addColumn("label", "text", (c) => c.notNull())
+			.addColumn("label_singular", "text")
+			.addColumn("hierarchical", "integer", (c) => c.defaultTo(0))
+			.addColumn("collections", "text")
+			.addColumn("created_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
+			.addColumn("locale", "text", (c) => c.notNull().defaultTo(defaultLocale))
+			.addColumn("translation_group", "text")
+			.addUniqueConstraint("_emdash_taxonomy_defs_name_locale_unique", ["name", "locale"])
+			.execute();
 
-	await sql`
+		await sql`
 		INSERT INTO _emdash_taxonomy_defs_new
 			(id, name, label, label_singular, hierarchical, collections, created_at, locale, translation_group)
 		SELECT id, name, label, label_singular, hierarchical, collections, created_at, ${defaultLocale}, id
 		FROM _emdash_taxonomy_defs
 	`.execute(db);
 
-	await db.schema.dropTable("_emdash_taxonomy_defs").execute();
-	await sql`ALTER TABLE _emdash_taxonomy_defs_new RENAME TO _emdash_taxonomy_defs`.execute(db);
+		await db.schema.dropTable("_emdash_taxonomy_defs").execute();
+		await sql`ALTER TABLE _emdash_taxonomy_defs_new RENAME TO _emdash_taxonomy_defs`.execute(db);
+	}
 
 	await db.schema
 		.createIndex("idx__emdash_taxonomy_defs_locale")
+		.ifNotExists()
 		.on("_emdash_taxonomy_defs")
 		.column("locale")
 		.execute();
 	await db.schema
 		.createIndex("idx__emdash_taxonomy_defs_translation_group")
+		.ifNotExists()
 		.on("_emdash_taxonomy_defs")
 		.column("translation_group")
 		.execute();
@@ -258,6 +297,7 @@ async function rebuildContentTaxonomies(db: Kysely<unknown>): Promise<void> {
 	// translation_group references after the migration completes. This coupling
 	// is load-bearing — if the translation_group seed ever changes, this needs
 	// an explicit remap *after* `rebuildTaxonomies` runs.
+	await resumeStagedRebuild(db, "content_taxonomies");
 	const fks = await sql<{ id: number }>`PRAGMA foreign_key_list(content_taxonomies)`.execute(db);
 	if (fks.rows.length > 0) {
 		await sql.raw(`DROP TABLE IF EXISTS "content_taxonomies_new"`).execute(db);