emdash 0.31.1 → 0.33.0

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

@@ -5,6 +5,12 @@
  */
 
 import { sanitizeGalleryImages } from "./gallery.js";
+import {
+	deriveLegacyListId,
+	normalizeProseMirrorOrderedListJson,
+	normalizeListId,
+	normalizeListStart,
+} from "./numbered-list.js";
 import type {
 	ProseMirrorDocument,
 	ProseMirrorNode,
@@ -48,12 +54,20 @@ export function portableTextToProsemirror(blocks: PortableTextBlock[]): ProseMir
 			// child).
 			const listBlocks: PortableTextTextBlock[] = [];
 			const listType = block.listItem;
+			const runStart = i;
+			const rootId = listType === "number" ? normalizeListId(block.listId) : undefined;
 
 			while (i < blocks.length) {
 				const current = blocks[i];
 				if (!isTextBlock(current) || !current.listItem) break;
 				const level = current.level || 1;
-				if (level > 1 || current.listItem === listType) {
+				const currentId =
+					current.listItem === "number" ? normalizeListId(current.listId) : undefined;
+				const sameRootIdentity =
+					listType !== "number" ||
+					level > 1 ||
+					(rootId ? currentId === rootId : currentId === undefined);
+				if (level > 1 || (current.listItem === listType && sameRootIdentity)) {
 					listBlocks.push(current);
 					i++;
 				} else {
@@ -61,14 +75,14 @@ export function portableTextToProsemirror(blocks: PortableTextBlock[]): ProseMir
 				}
 			}
 
-			content.push(convertList(listBlocks, listType));
+			content.push(convertList(listBlocks, listType, `root:${runStart}`));
 		} else if (isTextBlock(block) && block.style === "blockquote") {
 			// Collect a blockquote "run": Portable Text is flat, so a
 			// multi-paragraph quote is stored as consecutive blocks with
 			// style "blockquote" (that's what the Gutenberg importer emits
 			// and what prosemirrorToPortableText serializes back to).
 			// Without this grouping each paragraph became its own quote
-			// node, and editor merges reverted on reload (#1884).
+			// node, and editor merges reverted on reload.
 			const quoteBlocks: PortableTextTextBlock[] = [];
 			while (i < blocks.length) {
 				const current = blocks[i];
@@ -102,12 +116,38 @@ export function portableTextToProsemirror(blocks: PortableTextBlock[]): ProseMir
 		}
 	}
 
-	return {
+	return normalizeProseMirrorOrderedListJson({
 		type: "doc",
 		content: content.length > 0 ? content : [{ type: "paragraph" }],
+	});
+}
+
+function getListMetadata(
+	item: PortableTextTextBlock,
+	fallbackSeed: string,
+): { listId: string; listStart?: number } {
+	const listId = normalizeListId(item.listId) ?? deriveLegacyListId(fallbackSeed);
+	const listStart = normalizeListStart(item.listStart);
+	return {
+		listId,
+		...(listStart === undefined ? {} : { listStart }),
 	};
 }
 
+function belongsToNestedGroup(
+	item: PortableTextTextBlock,
+	minLevel: number,
+	parentListType: "bullet" | "number",
+	anchorType: "bullet" | "number",
+	anchorId: string | undefined,
+): boolean {
+	if ((item.level || 2) > minLevel) return true;
+	if ((item.listItem || parentListType) !== anchorType) return false;
+	if (anchorType !== "number") return true;
+	const itemId = normalizeListId(item.listId);
+	return anchorId ? itemId === anchorId : itemId === undefined;
+}
+
 /**
  * Type guard for text blocks
  */
@@ -249,6 +289,7 @@ function convertTextBlock(block: PortableTextTextBlock): ProseMirrorNode | null
 function convertList(
 	items: PortableTextTextBlock[],
 	listType: "bullet" | "number",
+	context: string,
 ): ProseMirrorNode {
 	// Group items by level
 	const rootItems: ProseMirrorNode[] = [];
@@ -268,16 +309,22 @@ function convertList(
 				i++;
 			}
 
-			rootItems.push(convertListItem(item, nestedItems, listType));
+			rootItems.push(
+				convertListItem(item, nestedItems, listType, `${context}:${rootItems.length}`),
+			);
 		} else {
 			// Orphan nested item - treat as root
-			rootItems.push(convertListItem(item, [], listType));
+			rootItems.push(convertListItem(item, [], listType, `${context}:${rootItems.length}`));
 			i++;
 		}
 	}
 
+	const metadata =
+		listType === "number" ? getListMetadata(items[0], `${context}:${items[0]._key}`) : undefined;
+
 	return {
 		type: listType === "bullet" ? "bulletList" : "orderedList",
+		attrs: metadata ? { ...metadata, start: metadata.listStart ?? 1 } : undefined,
 		content: rootItems,
 	};
 }
@@ -289,6 +336,7 @@ function convertListItem(
 	item: PortableTextTextBlock,
 	nestedItems: PortableTextTextBlock[],
 	parentListType: "bullet" | "number",
+	context: string,
 ): ProseMirrorNode {
 	const content: ProseMirrorNode[] = [];
 
@@ -319,6 +367,7 @@ function convertListItem(
 		let j = 0;
 		while (j < nestedItems.length) {
 			const anchorType: "bullet" | "number" = nestedItems[j].listItem || parentListType;
+			const anchorId = anchorType === "number" ? normalizeListId(nestedItems[j].listId) : undefined;
 			const nestedGroup: PortableTextTextBlock[] = [];
 
 			do {
@@ -326,8 +375,7 @@ function convertListItem(
 				j++;
 			} while (
 				j < nestedItems.length &&
-				((nestedItems[j].level || 2) > minLevel ||
-					(nestedItems[j].listItem || parentListType) === anchorType)
+				belongsToNestedGroup(nestedItems[j], minLevel, parentListType, anchorType, anchorId)
 			);
 
 			if (nestedGroup.length > 0) {
@@ -336,7 +384,9 @@ function convertListItem(
 					...ni,
 					level: (ni.level || 2) - 1,
 				}));
-				content.push(convertList(adjustedGroup, anchorType));
+				content.push(
+					convertList(adjustedGroup, anchorType, `${context}:nested:${j - nestedGroup.length}`),
+				);
 			}
 		}
 	}

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

@@ -5,6 +5,7 @@
  */
 
 import { sanitizeGalleryImages } from "./gallery.js";
+import { readOrderedListMetadata, type OrderedListMetadata } from "./numbered-list.js";
 import type {
 	ProseMirrorDocument,
 	ProseMirrorNode,
@@ -36,8 +37,8 @@ export function prosemirrorToPortableText(doc: ProseMirrorDocument): PortableTex
 
 	const blocks: PortableTextBlock[] = [];
 
-	for (const node of doc.content) {
-		const converted = convertNode(node);
+	for (const [i, node] of doc.content.entries()) {
+		const converted = convertNode(node, `root:${i}`);
 		if (converted) {
 			if (Array.isArray(converted)) {
 				blocks.push(...converted);
@@ -53,7 +54,10 @@ export function prosemirrorToPortableText(doc: ProseMirrorDocument): PortableTex
 /**
  * Convert a single ProseMirror node to Portable Text block(s)
  */
-function convertNode(node: ProseMirrorNode): PortableTextBlock | PortableTextBlock[] | null {
+function convertNode(
+	node: ProseMirrorNode,
+	path: string,
+): PortableTextBlock | PortableTextBlock[] | null {
 	switch (node.type) {
 		case "paragraph":
 			return convertParagraph(node);
@@ -62,10 +66,10 @@ function convertNode(node: ProseMirrorNode): PortableTextBlock | PortableTextBlo
 			return convertHeading(node);
 
 		case "bulletList":
-			return convertList(node, "bullet");
+			return convertList(node, "bullet", path);
 
 		case "orderedList":
-			return convertList(node, "number");
+			return convertList(node, "number", path);
 
 		case "blockquote":
 			return convertBlockquote(node);
@@ -175,12 +179,14 @@ function convertHeading(node: ProseMirrorNode): PortableTextTextBlock | null {
 function convertList(
 	node: ProseMirrorNode,
 	listItem: "bullet" | "number",
+	path: string,
 ): PortableTextTextBlock[] {
 	const blocks: PortableTextTextBlock[] = [];
+	const metadata = listItem === "number" ? readOrderedListMetadata(node.attrs, path) : undefined;
 
-	for (const item of node.content || []) {
+	for (const [i, item] of (node.content ?? []).entries()) {
 		if (item.type === "listItem") {
-			const itemBlocks = convertListItem(item, listItem, 1);
+			const itemBlocks = convertListItem(item, listItem, 1, `${path}:${i}`, metadata);
 			blocks.push(...itemBlocks);
 		}
 	}
@@ -195,10 +201,12 @@ function convertListItem(
 	item: ProseMirrorNode,
 	listItem: "bullet" | "number",
 	level: number,
+	path: string,
+	metadata?: OrderedListMetadata,
 ): PortableTextTextBlock[] {
 	const blocks: PortableTextTextBlock[] = [];
 
-	for (const child of item.content || []) {
+	for (const [i, child] of (item.content ?? []).entries()) {
 		if (child.type === "paragraph") {
 			const { children, markDefs } = convertInlineContent(child.content || []);
 
@@ -209,14 +217,15 @@ function convertListItem(
 					style: "normal",
 					listItem,
 					level,
+					...metadata,
 					children,
 					markDefs: markDefs.length > 0 ? markDefs : undefined,
 				});
 			}
 		} else if (child.type === "bulletList") {
-			blocks.push(...convertListItemNested(child, "bullet", level + 1));
+			blocks.push(...convertListItemNested(child, "bullet", level + 1, `${path}:${i}`));
 		} else if (child.type === "orderedList") {
-			blocks.push(...convertListItemNested(child, "number", level + 1));
+			blocks.push(...convertListItemNested(child, "number", level + 1, `${path}:${i}`));
 		}
 	}
 
@@ -230,12 +239,14 @@ function convertListItemNested(
 	node: ProseMirrorNode,
 	listItem: "bullet" | "number",
 	level: number,
+	path: string,
 ): PortableTextTextBlock[] {
 	const blocks: PortableTextTextBlock[] = [];
+	const metadata = listItem === "number" ? readOrderedListMetadata(node.attrs, path) : undefined;
 
-	for (const item of node.content || []) {
+	for (const [i, item] of (node.content ?? []).entries()) {
 		if (item.type === "listItem") {
-			blocks.push(...convertListItem(item, listItem, level));
+			blocks.push(...convertListItem(item, listItem, level, `${path}:${i}`, metadata));
 		}
 	}
 

package/src/content/converters/types.ts

@@ -41,6 +41,8 @@ export interface PortableTextTextBlock {
 	style?: "normal" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "blockquote";
 	listItem?: "bullet" | "number";
 	level?: number;
+	listId?: string;
+	listStart?: number;
 	children: PortableTextSpan[];
 	markDefs?: PortableTextMarkDef[];
 	textAlign?: "left" | "center" | "right" | "justify";

package/src/content/portable-text-lists.ts

@@ -0,0 +1,205 @@
+import {
+	deriveLegacyListId,
+	normalizeListId,
+	normalizeListStart,
+} from "./converters/numbered-list.js";
+
+type ListNestingMode = "html" | "direct";
+type PortableTextNode = Record<string, unknown>;
+
+interface PortableTextListBlock extends PortableTextNode {
+	_type: "block";
+	children: unknown[];
+	level?: number;
+	listId?: unknown;
+	listItem: string;
+	listStart?: unknown;
+}
+
+export interface PortableTextListNode extends PortableTextNode {
+	_type: "@list";
+	_key: string;
+	children: PortableTextNode[];
+	level: number;
+	listItem: string;
+	mode: ListNestingMode;
+	start?: number;
+}
+
+interface ListDescriptor {
+	node: PortableTextListNode;
+	directItems: Array<{
+		original: PortableTextListBlock;
+		rendered: PortableTextListBlock;
+	}>;
+	level: number;
+	parentContext: string;
+	sourceId: string | undefined;
+	segment: number;
+}
+
+interface ParentItem {
+	context: string;
+	list: ListDescriptor;
+	rendered: PortableTextListBlock;
+}
+
+function isListBlock(node: PortableTextNode): node is PortableTextListBlock {
+	return (
+		node._type === "block" && typeof node.listItem === "string" && Array.isArray(node.children)
+	);
+}
+
+function readLevel(value: unknown): number {
+	return typeof value === "number" && Number.isInteger(value) && value >= 1 ? value : 1;
+}
+
+function findParentItem(items: Map<number, ParentItem>, level: number): ParentItem | undefined {
+	let nearestLevel = 0;
+	let nearest: ParentItem | undefined;
+	for (const [candidate, item] of items) {
+		if (candidate < level && candidate > nearestLevel) {
+			nearestLevel = candidate;
+			nearest = item;
+		}
+	}
+	return nearest;
+}
+
+function matchesList(
+	descriptor: ListDescriptor | undefined,
+	listItem: string,
+	sourceId: string | undefined,
+	parentContext: string,
+): descriptor is ListDescriptor {
+	return (
+		descriptor !== undefined &&
+		descriptor.node.listItem === listItem &&
+		descriptor.parentContext === parentContext &&
+		(listItem !== "number" || descriptor.sourceId === sourceId)
+	);
+}
+
+function buildListTree(
+	blocks: PortableTextNode[],
+	mode: ListNestingMode,
+): { tree: PortableTextNode[]; descriptors: ListDescriptor[] } {
+	const tree: PortableTextNode[] = [];
+	const descriptors: ListDescriptor[] = [];
+	const activeLists = new Map<number, ListDescriptor>();
+	const lastItems = new Map<number, ParentItem>();
+	let segment = 0;
+
+	for (let index = 0; index < blocks.length; index++) {
+		const block = blocks[index];
+		if (!isListBlock(block)) {
+			tree.push(block);
+			activeLists.clear();
+			lastItems.clear();
+			continue;
+		}
+
+		const level = readLevel(block.level);
+		for (const activeLevel of activeLists.keys()) {
+			if (activeLevel > level) activeLists.delete(activeLevel);
+		}
+		for (const itemLevel of lastItems.keys()) {
+			if (itemLevel > level) lastItems.delete(itemLevel);
+		}
+
+		const parent = findParentItem(lastItems, level);
+		const parentContext = parent?.context ?? "root";
+		const sourceId = block.listItem === "number" ? normalizeListId(block.listId) : undefined;
+		let descriptor = activeLists.get(level);
+		if (!matchesList(descriptor, block.listItem, sourceId, parentContext)) {
+			const node: PortableTextListNode = {
+				_type: "@list",
+				_key: `${typeof block._key === "string" ? block._key : index}-parent`,
+				children: [],
+				level,
+				listItem: block.listItem,
+				mode,
+			};
+			descriptor = {
+				node,
+				directItems: [],
+				level,
+				parentContext,
+				sourceId,
+				segment: segment++,
+			};
+			descriptors.push(descriptor);
+			activeLists.set(level, descriptor);
+			if (!parent) {
+				tree.push(node);
+			} else if (mode === "direct") {
+				parent.list.node.children.push(node);
+			} else {
+				parent.rendered.children.push(node);
+			}
+		}
+
+		const rendered = { ...block, children: [...block.children] };
+		descriptor.node.children.push(rendered);
+		descriptor.directItems.push({ original: block, rendered });
+		lastItems.set(level, {
+			context: `${parentContext}/item:${index}`,
+			list: descriptor,
+			rendered,
+		});
+	}
+
+	return { tree, descriptors };
+}
+
+function applyNumbering(descriptors: ListDescriptor[]): void {
+	const bases = new Map<string, number>();
+	const scopeKeys = new Map<ListDescriptor, string>();
+	for (const descriptor of descriptors) {
+		if (descriptor.node.listItem !== "number") continue;
+		const identity =
+			descriptor.sourceId ??
+			deriveLegacyListId(
+				`render:${descriptor.segment}:${descriptor.level}:${descriptor.parentContext}`,
+			);
+		const scope = JSON.stringify([identity, descriptor.level, descriptor.parentContext]);
+		scopeKeys.set(descriptor, scope);
+		if (!descriptor.sourceId || bases.has(scope)) continue;
+		for (const { original } of descriptor.directItems) {
+			const base = normalizeListStart(original.listStart);
+			if (base === undefined) continue;
+			bases.set(scope, base);
+			break;
+		}
+	}
+
+	const counts = new Map<string, number>();
+	for (const descriptor of descriptors) {
+		if (descriptor.node.listItem !== "number") continue;
+		const scope = scopeKeys.get(descriptor)!;
+		const base = bases.get(scope) ?? 1;
+		const count = counts.get(scope) ?? 0;
+		descriptor.node.start = normalizeListStart(base + count) ?? 1;
+		counts.set(scope, count + descriptor.directItems.length);
+	}
+}
+
+function preprocessLists(
+	blocks: PortableTextNode[],
+	mode: ListNestingMode,
+): { tree: PortableTextNode[]; descriptors: ListDescriptor[] } {
+	const result = buildListTree(blocks, mode);
+	applyNumbering(result.descriptors);
+	return result;
+}
+
+export function clonePortableTextValue<T>(value: T): T {
+	return structuredClone(value);
+}
+
+export function buildPortableTextListTree(
+	blocks: PortableTextNode[],
+	mode: ListNestingMode = "html",
+): PortableTextNode[] {
+	return preprocessLists(blocks, mode).tree;
+}

package/src/database/dialect-helpers.ts

@@ -37,6 +37,44 @@ export function isPostgres(db: Kysely<any>): boolean {
 	return detectDialect(db) === "postgres";
 }
 
+/**
+ * Declared by an adapter whose backend caps the number of terms in a compound
+ * SELECT (`UNION ALL`, `INTERSECT`, `EXCEPT`). SQLite's own
+ * SQLITE_LIMIT_COMPOUND_SELECT default is 500 — high enough that no query
+ * EmDash builds approaches it — but Cloudflare D1 sets it to 5 and rejects
+ * anything larger with "too many terms in compound SELECT".
+ */
+export interface CompoundSelectLimitedAdapter {
+	/** Maximum terms per compound SELECT. Must be a positive integer. */
+	readonly compoundSelectLimit: number;
+}
+
+/**
+ * The backend's compound-SELECT ceiling, or null when it has none worth
+ * splitting statements for. Only the adapter knows: the limit is a property of
+ * the SQLite build behind the dialect, not of the SQL flavour, so two "sqlite"
+ * dialects can answer differently.
+ *
+ * A declared ceiling must be a positive integer — callers batch by it, and
+ * every other value silently misbehaves rather than failing: 0 and negatives
+ * never advance the batch cursor, fractions overlap batches and double-count,
+ * NaN yields an empty batch. A malformed declaration throws here, where the
+ * message can name the adapter.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
+export function compoundSelectLimit(db: Kysely<any>): number | null {
+	const adapter: object = db.getExecutor().adapter;
+	if (!("compoundSelectLimit" in adapter)) return null;
+
+	const limit: unknown = adapter.compoundSelectLimit;
+	if (typeof limit !== "number" || !Number.isInteger(limit) || limit < 1) {
+		throw new Error(
+			`${adapter.constructor.name} declares compoundSelectLimit ${String(limit)}; it must be a positive integer.`,
+		);
+	}
+	return limit;
+}
+
 /**
  * Default timestamp expression for column defaults.
  * Wrapped in parens for use in CREATE TABLE ... DEFAULT (...).
@@ -69,35 +107,16 @@ export function currentTimestampValue(db: Kysely<any>): RawBuilder<string> {
 
 /**
  * Build WHERE clause for status filtering on a content table.
- * When filtering for 'published' status, also include scheduled content
- * whose scheduled_at time has passed (treating it as effectively published).
- *
- * Visibility is computed, not flipped by cron, so a literal
- * `status = 'published'` comparison undercounts scheduled-and-due entries —
- * every "publicly visible" filter must go through this helper.
+ * Scheduled content becomes public only after the publication sweep commits
+ * the row with a literal `published` status.
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
 export function buildStatusCondition(
-	db: Kysely<any>,
+	_db: Kysely<any>,
 	status: string,
 	tablePrefix?: string,
 ): ReturnType<typeof sql> {
 	const statusField = tablePrefix ? `${tablePrefix}.status` : "status";
-	const scheduledAtField = tablePrefix ? `${tablePrefix}.scheduled_at` : "scheduled_at";
-
-	if (status === "published") {
-		// Include both published content AND scheduled content past its publish time.
-		// scheduled_at is stored as text (ISO 8601). On Postgres, we must cast it
-		// to timestamptz for the comparison with CURRENT_TIMESTAMP to work.
-		const scheduledAtExpr = isPostgres(db)
-			? sql`${sql.ref(scheduledAtField)}::timestamptz`
-			: sql.ref(scheduledAtField);
-		const nowExpr = isPostgres(db)
-			? currentTimestampValue(db)
-			: sql`strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
-		return sql`(${sql.ref(statusField)} = 'published' OR (${sql.ref(statusField)} = 'scheduled' AND ${scheduledAtExpr} <= ${nowExpr}))`;
-	}
-
 	return sql`${sql.ref(statusField)} = ${status}`;
 }
 

package/src/database/migrations/054_media_upload_attempts.ts

@@ -0,0 +1,41 @@
+import type { Kysely } from "kysely";
+
+import { currentTimestamp } from "../dialect-helpers.js";
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await db.schema
+		.createTable("_emdash_media_upload_attempts")
+		.ifNotExists()
+		.addColumn("storage_key", "text", (col) => col.primaryKey())
+		.addColumn("media_id", "text", (col) => col.notNull())
+		.addColumn("status", "text", (col) => col.notNull().defaultTo("active"))
+		.addColumn("created_at", "text", (col) => col.notNull().defaultTo(currentTimestamp(db)))
+		.addColumn("updated_at", "text", (col) => col.notNull().defaultTo(currentTimestamp(db)))
+		.execute();
+
+	await db.schema
+		.createIndex("idx_media_upload_attempts_media_id")
+		.ifNotExists()
+		.on("_emdash_media_upload_attempts")
+		.column("media_id")
+		.execute();
+
+	await db.schema
+		.createIndex("idx_media_upload_attempts_status_created_at")
+		.ifNotExists()
+		.on("_emdash_media_upload_attempts")
+		.columns(["status", "created_at"])
+		.execute();
+
+	await db.schema
+		.createIndex("idx_media_storage_key")
+		.ifNotExists()
+		.on("media")
+		.column("storage_key")
+		.execute();
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema.dropIndex("idx_media_storage_key").ifExists().execute();
+	await db.schema.dropTable("_emdash_media_upload_attempts").ifExists().execute();
+}

package/src/database/migrations/055_content_translation_group_locale_index.ts

@@ -0,0 +1,67 @@
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+
+import { listTablesLike } from "../dialect-helpers.js";
+
+/**
+ * Migration: replace the single-column content `translation_group` index with
+ * one index per translation-group read shape.
+ *
+ * There are two shapes. Translation-group reads filter `deleted_at IS NULL`
+ * with `translation_group = ?` / `IN (...)` and order by locale; menu and
+ * reference resolution looks a group up by `translation_group` (+ `locale`)
+ * alone, with no `deleted_at` term.
+ *
+ * Neither shape can borrow the other's index. Seeking migration 041's
+ * `(deleted_at, locale, ...)` composites on `deleted_at` alone already returns
+ * rows in locale order, so a stats-blind planner prefers them over a
+ * single-column `translation_group` index and reads every non-deleted row in
+ * the table; the batched variant is worse still, because the `IN (...)` list
+ * multiplies the planner's row estimate for a `translation_group`-leading index
+ * and it falls back to a `deleted_at` composite from a handful of groups
+ * onward. Going the other way, an index leading with `deleted_at` cannot seek a
+ * lookup that never constrains that column. D1 never has `sqlite_stat1`, so the
+ * index shape is the only lever and each shape needs a prefix matching it term
+ * for term.
+ *
+ * Forward-only and idempotent (`IF NOT EXISTS`).
+ *
+ * Index names use short `tg_locale` / `del_tg_locale` suffixes rather than
+ * spelling out `translation_group`: Postgres truncates identifiers to 63 bytes,
+ * and the longer forms truncate to the same value for long collection slugs.
+ * Keep these identical to the names in `schema/registry.ts`.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	const tableNames = await listTablesLike(db, "ec_%");
+
+	for (const tableName of tableNames) {
+		// D1 DDL is non-transactional: create the replacements before dropping the
+		// old index so an interrupted migration always leaves a
+		// translation_group-leading index in place.
+		await sql`
+			CREATE INDEX IF NOT EXISTS ${sql.ref(`idx_${tableName}_tg_locale`)}
+			ON ${sql.ref(tableName)} (translation_group, locale)
+		`.execute(db);
+
+		await sql`
+			CREATE INDEX IF NOT EXISTS ${sql.ref(`idx_${tableName}_del_tg_locale`)}
+			ON ${sql.ref(tableName)} (deleted_at, translation_group, locale)
+		`.execute(db);
+
+		await sql`DROP INDEX IF EXISTS ${sql.ref(`idx_${tableName}_translation_group`)}`.execute(db);
+	}
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	const tableNames = await listTablesLike(db, "ec_%");
+
+	for (const tableName of tableNames) {
+		await sql`
+			CREATE INDEX IF NOT EXISTS ${sql.ref(`idx_${tableName}_translation_group`)}
+			ON ${sql.ref(tableName)} (translation_group)
+		`.execute(db);
+
+		await sql`DROP INDEX IF EXISTS ${sql.ref(`idx_${tableName}_del_tg_locale`)}`.execute(db);
+		await sql`DROP INDEX IF EXISTS ${sql.ref(`idx_${tableName}_tg_locale`)}`.execute(db);
+	}
+}