emdash 0.35.0 → 0.37.0

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

@@ -10,6 +10,14 @@ import {
 	assertProseMirrorMarksSupported,
 } from "./mark-safety.js";
 import { readOrderedListMetadata, type OrderedListMetadata } from "./numbered-list.js";
+import {
+	PORTABLE_TEXT_BLOCK_NODE,
+	PORTABLE_TEXT_SPAN_MARK,
+	portableTextBlockFromAttrs,
+	portableTextKeyFromAttrs,
+	portableTextMarkDefsFromMarks,
+	portableTextSpanKeyFromMarks,
+} from "./portable-text-identity.js";
 import type {
 	ProseMirrorDocument,
 	ProseMirrorNode,
@@ -41,21 +49,33 @@ export function prosemirrorToPortableText(doc: ProseMirrorDocument): PortableTex
 	assertProseMirrorMarksSupported(doc);
 
 	const blocks: PortableTextBlock[] = [];
+	const usedBlockKeys = new Set<string>();
 
 	for (const [i, node] of doc.content.entries()) {
+		if (i === doc.content.length - 1 && isUnkeyedEmptyParagraph(node)) continue;
 		const converted = convertNode(node, `root:${i}`);
-		if (converted) {
-			if (Array.isArray(converted)) {
-				blocks.push(...converted);
-			} else {
-				blocks.push(converted);
+		for (const block of converted ? (Array.isArray(converted) ? converted : [converted]) : []) {
+			let key = block._key;
+			if (usedBlockKeys.has(key)) {
+				do key = generateKey();
+				while (usedBlockKeys.has(key));
 			}
+			usedBlockKeys.add(key);
+			blocks.push(key === block._key ? block : { ...block, _key: key });
 		}
 	}
 
 	return blocks;
 }
 
+function isUnkeyedEmptyParagraph(node: ProseMirrorNode): boolean {
+	return (
+		node.type === "paragraph" &&
+		(node.content?.length ?? 0) === 0 &&
+		portableTextKeyFromAttrs(node.attrs) === undefined
+	);
+}
+
 /**
  * Convert a single ProseMirror node to Portable Text block(s)
  */
@@ -64,6 +84,9 @@ function convertNode(
 	path: string,
 ): PortableTextBlock | PortableTextBlock[] | null {
 	switch (node.type) {
+		case PORTABLE_TEXT_BLOCK_NODE:
+			return portableTextBlockFromAttrs(node.attrs) ?? null;
+
 		case "paragraph":
 			return convertParagraph(node);
 
@@ -94,7 +117,7 @@ function convertNode(
 		case "horizontalRule":
 			return {
 				_type: "break",
-				_key: generateKey(),
+				_key: portableTextKeyFromAttrs(node.attrs) ?? generateKey(),
 				style: "lineBreak",
 			};
 
@@ -125,10 +148,10 @@ function convertParagraph(node: ProseMirrorNode): PortableTextTextBlock | null {
 
 	return {
 		_type: "block",
-		_key: generateKey(),
+		_key: portableTextKeyFromAttrs(node.attrs) ?? generateKey(),
 		style: "normal",
 		children,
-		markDefs: markDefs.length > 0 ? markDefs : undefined,
+		...(markDefs.length > 0 ? { markDefs } : {}),
 		...(textAlign ? { textAlign } : {}),
 	};
 }
@@ -170,7 +193,7 @@ function convertHeading(node: ProseMirrorNode): PortableTextTextBlock | null {
 
 	return {
 		_type: "block",
-		_key: generateKey(),
+		_key: portableTextKeyFromAttrs(node.attrs) ?? generateKey(),
 		style,
 		children,
 		markDefs: markDefs.length > 0 ? markDefs : undefined,
@@ -218,7 +241,7 @@ function convertListItem(
 			if (children.length > 0) {
 				blocks.push({
 					_type: "block",
-					_key: generateKey(),
+					_key: portableTextKeyFromAttrs(child.attrs) ?? generateKey(),
 					style: "normal",
 					listItem,
 					level,
@@ -274,7 +297,10 @@ function convertBlockquote(
 			if (children.length > 0) {
 				blocks.push({
 					_type: "block",
-					_key: generateKey(),
+					_key:
+						portableTextKeyFromAttrs(child.attrs) ??
+						portableTextKeyFromAttrs(node.attrs) ??
+						generateKey(),
 					style: "blockquote",
 					children,
 					markDefs: markDefs.length > 0 ? markDefs : undefined,
@@ -295,7 +321,7 @@ function convertCodeBlock(node: ProseMirrorNode): PortableTextCodeBlock {
 
 	return {
 		_type: "code",
-		_key: generateKey(),
+		_key: portableTextKeyFromAttrs(node.attrs) ?? generateKey(),
 		code,
 		language: language || undefined,
 	};
@@ -308,7 +334,7 @@ function convertHtmlBlock(node: ProseMirrorNode): PortableTextHtmlBlock {
 	const rawHtml = node.attrs?.html;
 	return {
 		_type: "htmlBlock",
-		_key: generateKey(),
+		_key: portableTextKeyFromAttrs(node.attrs) ?? generateKey(),
 		html: typeof rawHtml === "string" ? rawHtml : "",
 	};
 }
@@ -327,10 +353,11 @@ function convertImage(node: ProseMirrorNode): PortableTextImageBlock {
 	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 alignment = attrs?.alignment;
 
 	return {
 		_type: "image",
-		_key: generateKey(),
+		_key: portableTextKeyFromAttrs(node.attrs) ?? generateKey(),
 		asset: {
 			// Use mediaId as _ref if available (for proper provider lookups)
 			_ref: mediaId || src || "",
@@ -345,6 +372,14 @@ function convertImage(node: ProseMirrorNode): PortableTextImageBlock {
 		height: height || undefined,
 		displayWidth: displayWidth || undefined,
 		displayHeight: displayHeight || undefined,
+		alignment:
+			alignment === "left" ||
+			alignment === "center" ||
+			alignment === "right" ||
+			alignment === "wide" ||
+			alignment === "full"
+				? alignment
+				: undefined,
 	};
 }
 
@@ -355,7 +390,7 @@ function convertGallery(node: ProseMirrorNode): PortableTextGalleryBlock {
 	const columns = node.attrs?.columns;
 	return {
 		_type: "gallery",
-		_key: generateKey(),
+		_key: portableTextKeyFromAttrs(node.attrs) ?? generateKey(),
 		images: sanitizeGalleryImages(node.attrs?.images, generateKey),
 		...(typeof columns === "number" ? { columns } : {}),
 	};
@@ -371,23 +406,49 @@ function convertInlineContent(nodes: ProseMirrorNode[]): {
 	const children: PortableTextSpan[] = [];
 	const markDefs: PortableTextMarkDef[] = [];
 	const markDefMap = new Map<string, string>(); // href -> key
+	const usedSpanKeys = new Set<string>();
+	const claimSpanKey = (preferred?: string) => {
+		if (preferred && !usedSpanKeys.has(preferred)) {
+			usedSpanKeys.add(preferred);
+			return preferred;
+		}
+		let key: string;
+		do key = generateKey();
+		while (usedSpanKeys.has(key));
+		usedSpanKeys.add(key);
+		return key;
+	};
 
 	for (const node of nodes) {
 		if (node.type === "text" && node.text) {
 			const marks: string[] = [];
+			const originalMarkDefs = portableTextMarkDefsFromMarks(node.marks);
 
 			for (const mark of node.marks || []) {
-				const markType = convertMark(mark, markDefs, markDefMap);
+				const markType = convertMark(mark, markDefs, markDefMap, originalMarkDefs);
 				if (markType) {
 					marks.push(markType);
 				}
 			}
 
+			const preferredKey =
+				portableTextSpanKeyFromMarks(node.marks) ?? portableTextKeyFromAttrs(node.attrs);
+			const normalizedMarks = marks.length > 0 ? marks : undefined;
+			const previous = children.at(-1);
+			if (
+				preferredKey &&
+				previous?._key === preferredKey &&
+				JSON.stringify(previous.marks) === JSON.stringify(normalizedMarks)
+			) {
+				previous.text += node.text;
+				continue;
+			}
+
 			children.push({
 				_type: "span",
-				_key: generateKey(),
+				_key: claimSpanKey(preferredKey),
 				text: node.text,
-				marks: marks.length > 0 ? marks : undefined,
+				marks: normalizedMarks,
 			});
 		} else if (node.type === "hardBreak") {
 			// Hard breaks become newlines in the text
@@ -397,7 +458,9 @@ function convertInlineContent(nodes: ProseMirrorNode[]): {
 			} else {
 				children.push({
 					_type: "span",
-					_key: generateKey(),
+					_key: claimSpanKey(
+						portableTextSpanKeyFromMarks(node.marks) ?? portableTextKeyFromAttrs(node.attrs),
+					),
 					text: "\n",
 				});
 			}
@@ -408,7 +471,7 @@ function convertInlineContent(nodes: ProseMirrorNode[]): {
 	if (children.length === 0) {
 		children.push({
 			_type: "span",
-			_key: generateKey(),
+			_key: claimSpanKey(),
 			text: "",
 		});
 	}
@@ -423,6 +486,7 @@ function convertMark(
 	mark: ProseMirrorMark,
 	markDefs: PortableTextMarkDef[],
 	markDefMap: Map<string, string>,
+	originalMarkDefs: PortableTextMarkDef[],
 ): string | null {
 	switch (mark.type) {
 		case "bold":
@@ -449,23 +513,30 @@ function convertMark(
 		case "code":
 			return "code";
 
+		case PORTABLE_TEXT_SPAN_MARK:
+			return null;
+
 		case "link": {
 			const href = (typeof mark.attrs?.href === "string" ? mark.attrs.href : "") || "";
+			const originalMarkDef = originalMarkDefs.find((markDef) => markDef._type === "link");
+			const mapKey = originalMarkDef ? `key:${originalMarkDef._key}` : `href:${href}`;
 
 			// Check if we already have a mark def for this link
-			if (markDefMap.has(href)) {
-				return markDefMap.get(href)!;
+			if (markDefMap.has(mapKey)) {
+				return markDefMap.get(mapKey)!;
 			}
 
 			// Create new mark def
-			const key = generateKey();
+			const key = originalMarkDef?._key || generateKey();
+			const blank = mark.attrs?.target === "_blank";
 			markDefs.push({
+				...originalMarkDef,
 				_type: "link",
 				_key: key,
 				href,
-				blank: mark.attrs?.target === "_blank",
+				...(blank || (originalMarkDef && Object.hasOwn(originalMarkDef, "blank")) ? { blank } : {}),
 			});
-			markDefMap.set(href, key);
+			markDefMap.set(mapKey, key);
 
 			return key;
 		}

package/src/content/converters/types.ts

@@ -70,6 +70,7 @@ export interface PortableTextImageBlock {
 	displayWidth?: number;
 	/** Display height for this instance (overrides original) */
 	displayHeight?: number;
+	alignment?: "left" | "center" | "right" | "wide" | "full";
 }
 
 /**
@@ -91,6 +92,8 @@ export interface PortableTextGalleryImage {
 	caption?: string;
 	width?: number;
 	height?: number;
+	focalX?: number;
+	focalY?: number;
 	/** LQIP blurhash placeholder (images only) */
 	blurhash?: string;
 	/** LQIP dominant-color placeholder, as a CSS color (images only) */

package/src/database/connection.ts

@@ -1,6 +1,6 @@
-import BetterSqlite3 from "better-sqlite3";
 import { Kysely, SqliteDialect } from "kysely";
 
+import { openNodeSqliteDatabase } from "../db/node-sqlite-compat.js";
 import { EmDashDatabaseError } from "./errors.js";
 import { kyselyLogOption } from "./instrumentation.js";
 import type { Database } from "./types.js";
@@ -12,23 +12,6 @@ export interface DatabaseConfig {
 	authToken?: string;
 }
 
-/**
- * Returns a helpful, actionable message when better-sqlite3's native binary
- * was compiled against a different Node.js version than the one running. This
- * happens after upgrading Node without rebuilding native deps.
- *
- * Returns null if the error is not a NODE_MODULE_VERSION mismatch.
- */
-export function formatNativeModuleVersionError(error: unknown): string | null {
-	const message = error instanceof Error ? error.message : String(error);
-	if (!message.includes("NODE_MODULE_VERSION")) return null;
-	return (
-		"better-sqlite3's native binary was compiled against a different Node.js version. " +
-		"Rebuild it with `pnpm rebuild better-sqlite3` (or `npm rebuild better-sqlite3`), " +
-		"or reinstall dependencies with your current Node.js version."
-	);
-}
-
 /**
  * Creates a Kysely database instance
  * Supports:
@@ -42,15 +25,7 @@ export function createDatabase(config: DatabaseConfig): Kysely<Database> {
 		if (config.url.startsWith("file:") || config.url === ":memory:") {
 			const dbPath = config.url === ":memory:" ? ":memory:" : config.url.replace("file:", "");
 
-			const sqlite = new BetterSqlite3(dbPath);
-
-			// Enable WAL mode for crash safety — writes go to a write-ahead log
-			// before being applied, preventing FTS5 shadow table corruption on
-			// process kill during content writes. No-op for :memory: databases.
-			sqlite.pragma("journal_mode = WAL");
-
-			// Enable foreign key constraints
-			sqlite.pragma("foreign_keys = ON");
+			const sqlite = openNodeSqliteDatabase(dbPath, { journalMode: "wal" });
 
 			const dialect = new SqliteDialect({
 				database: sqlite,
@@ -73,10 +48,6 @@ export function createDatabase(config: DatabaseConfig): Kysely<Database> {
 		if (error instanceof EmDashDatabaseError) {
 			throw error;
 		}
-		const nativeVersionHint = formatNativeModuleVersionError(error);
-		if (nativeVersionHint) {
-			throw new EmDashDatabaseError(nativeVersionHint, error);
-		}
 		throw new EmDashDatabaseError("Failed to create database", error);
 	}
 }

package/src/database/index.ts

@@ -1,5 +1,5 @@
 // `createDatabase` is intentionally not re-exported here: it lives in
-// `connection.ts`, which statically imports `better-sqlite3`. See #947.
+// `connection.ts`, which statically imports the Node-only `node:sqlite` module.
 export { EmDashDatabaseError } from "./errors.js";
 export type { DatabaseConfig } from "./connection.js";
 export {

package/src/database/json-recordset.ts

@@ -0,0 +1,16 @@
+import { sql, type Kysely, type RawBuilder } from "kysely";
+
+import { isPostgres } from "./dialect-helpers.js";
+import type { Database } from "./types.js";
+
+export function jsonTextValues(
+	db: Kysely<Database>,
+	values: readonly string[],
+): RawBuilder<{ value: string }> {
+	const payload = JSON.stringify([...new Set(values)]);
+	return isPostgres(db)
+		? sql<{
+				value: string;
+			}>`SELECT value::text AS value FROM jsonb_array_elements_text(${payload}::jsonb) AS value`
+		: sql<{ value: string }>`SELECT value AS value FROM json_each(${payload})`;
+}

package/src/database/migrations/017_authorization_codes.ts

@@ -1,7 +1,6 @@
 import type { Kysely } from "kysely";
-import { sql } from "kysely";
 
-import { currentTimestamp } from "../dialect-helpers.js";
+import { columnExists, currentTimestamp } from "../dialect-helpers.js";
 
 /**
  * Authorization codes for OAuth 2.1 Authorization Code + PKCE flow.
@@ -10,10 +9,18 @@ import { currentTimestamp } from "../dialect-helpers.js";
  * via the standard OAuth authorization code grant.
  *
  * Also adds client_id tracking to oauth_tokens for per-client revocation.
+ *
+ * Every statement is guarded so the migration can restart after any one of
+ * them has committed. D1 commits each DDL statement on its own and the
+ * migrator records the migration only once `up` returns, so an interrupted
+ * run leaves the table created and the migration pending; an unguarded
+ * `CREATE TABLE` then fails on every retry and the database never finishes
+ * migrating.
  */
 export async function up(db: Kysely<unknown>): Promise<void> {
 	await db.schema
 		.createTable("_emdash_authorization_codes")
+		.ifNotExists()
 		.addColumn("code_hash", "text", (col) => col.primaryKey()) // SHA-256 hash of authorization code
 		.addColumn("client_id", "text", (col) => col.notNull()) // CIMD URL or opaque string
 		.addColumn("redirect_uri", "text", (col) => col.notNull()) // Must match exactly on exchange
@@ -31,15 +38,18 @@ export async function up(db: Kysely<unknown>): Promise<void> {
 
 	await db.schema
 		.createIndex("idx_auth_codes_expires")
+		.ifNotExists()
 		.on("_emdash_authorization_codes")
 		.column("expires_at")
 		.execute();
 
 	// Track which client obtained a token (for per-client revocation)
-	await sql`ALTER TABLE _emdash_oauth_tokens ADD COLUMN client_id TEXT`.execute(db);
+	if (!(await columnExists(db, "_emdash_oauth_tokens", "client_id"))) {
+		await db.schema.alterTable("_emdash_oauth_tokens").addColumn("client_id", "text").execute();
+	}
 }
 
 export async function down(db: Kysely<unknown>): Promise<void> {
-	await db.schema.dropTable("_emdash_authorization_codes").execute();
+	await db.schema.dropTable("_emdash_authorization_codes").ifExists().execute();
 	// SQLite doesn't support DROP COLUMN, but this is only for dev rollback
 }

package/src/database/migrations/019_i18n.ts

@@ -223,7 +223,7 @@ export async function up(db: Kysely<unknown>): Promise<void> {
 		const tmp = `${t}_i18n_tmp`;
 
 		// Note: no transaction wrapper — D1 doesn't support transactions,
-		// and SQLite/better-sqlite3 is single-writer so crash-safety is
+		// and file-backed SQLite is single-writer so crash-safety is
 		// handled by the journal mode. The tmp table approach is already
 		// crash-recoverable (orphaned tmp tables are harmless).
 		{

package/src/database/migrations/071_restore_content_bylines_table.ts

@@ -0,0 +1,43 @@
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+
+import { isSqlite, tableExists } from "../dialect-helpers.js";
+
+/**
+ * Restore `_emdash_content_bylines` where migration 040's SQLite rebuild
+ * stopped between dropping the old table and renaming the staged copy.
+ *
+ * 040 guards its rebuild on `PRAGMA foreign_key_list`, which returns no rows
+ * for a missing table, so a retry after that partial run skips the rename and
+ * leaves `_emdash_content_bylines_new` behind with the credits inside. The
+ * indexes went with the dropped table.
+ *
+ * The Postgres path of 040 alters the table in place, so this is a no-op there.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	if (!isSqlite(db)) return;
+
+	if (!(await tableExists(db, "_emdash_content_bylines"))) {
+		if (!(await tableExists(db, "_emdash_content_bylines_new"))) return;
+		await sql`ALTER TABLE _emdash_content_bylines_new RENAME TO _emdash_content_bylines`.execute(
+			db,
+		);
+	}
+
+	await db.schema
+		.createIndex("idx_content_bylines_content")
+		.ifNotExists()
+		.on("_emdash_content_bylines")
+		.columns(["collection_slug", "content_id", "sort_order"])
+		.execute();
+	await db.schema
+		.createIndex("idx_content_bylines_byline")
+		.ifNotExists()
+		.on("_emdash_content_bylines")
+		.column("byline_id")
+		.execute();
+}
+
+export async function down(_db: Kysely<unknown>): Promise<void> {
+	// no-op
+}

package/src/database/migrations/072_media_folders.ts

@@ -0,0 +1,72 @@
+import type { Kysely } from "kysely";
+
+import { columnExists } from "../dialect-helpers.js";
+
+const DUPLICATE_COLUMN_RE = /(?:duplicate column|column .* already exists|already exists.*column)/i;
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await db.schema
+		.createTable("media_folders")
+		.ifNotExists()
+		.addColumn("id", "text", (col) => col.primaryKey())
+		.addColumn("name", "text", (col) => col.notNull())
+		.addColumn("name_key", "text", (col) => col.notNull().unique())
+		.execute();
+
+	await addFolderColumnIfMissing(db, () =>
+		db.schema
+			.alterTable("media")
+			.addColumn("folder_id", "text", (col) =>
+				col.references("media_folders.id").onDelete("set null"),
+			)
+			.execute(),
+	);
+
+	await db.schema
+		.createIndex("idx_media_folder_id")
+		.ifNotExists()
+		.on("media")
+		.column("folder_id")
+		.execute();
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema.dropIndex("idx_media_folder_id").ifExists().execute();
+	if (await columnExists(db, "media", "folder_id")) {
+		await db.schema.alterTable("media").dropColumn("folder_id").execute();
+	}
+	await db.schema.dropTable("media_folders").ifExists().execute();
+}
+
+async function addFolderColumnIfMissing(
+	db: Kysely<unknown>,
+	addColumn: () => Promise<void>,
+): Promise<void> {
+	if (await columnExists(db, "media", "folder_id")) return;
+
+	try {
+		await addColumn();
+	} catch (error) {
+		if (DUPLICATE_COLUMN_RE.test(deepErrorMessage(error))) {
+			if (await columnExists(db, "media", "folder_id")) return;
+		}
+		throw error;
+	}
+}
+
+function deepErrorMessage(error: unknown): string {
+	if (error instanceof Error) {
+		const own = error.message ?? "";
+		if (error.cause) {
+			const causeMessage = deepErrorMessage(error.cause);
+			return own ? `${own}: ${causeMessage}` : causeMessage;
+		}
+		return own;
+	}
+	if (typeof error === "string") return error;
+	try {
+		return JSON.stringify(error);
+	} catch {
+		return String(error);
+	}
+}

package/src/database/migrations/073_media_focal_point.ts

@@ -0,0 +1,57 @@
+import type { Kysely } from "kysely";
+
+import { columnExists } from "../dialect-helpers.js";
+
+const DUPLICATE_COLUMN_RE = /(?:duplicate column|column .* already exists|already exists.*column)/i;
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await addFocalColumnIfMissing(db, "focal_x", () =>
+		db.schema.alterTable("media").addColumn("focal_x", "real").execute(),
+	);
+	await addFocalColumnIfMissing(db, "focal_y", () =>
+		db.schema.alterTable("media").addColumn("focal_y", "real").execute(),
+	);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	if (await columnExists(db, "media", "focal_y")) {
+		await db.schema.alterTable("media").dropColumn("focal_y").execute();
+	}
+	if (await columnExists(db, "media", "focal_x")) {
+		await db.schema.alterTable("media").dropColumn("focal_x").execute();
+	}
+}
+
+export async function addFocalColumnIfMissing(
+	db: Kysely<unknown>,
+	column: "focal_x" | "focal_y",
+	addColumn: () => Promise<void>,
+): Promise<void> {
+	if (await columnExists(db, "media", column)) return;
+
+	try {
+		await addColumn();
+	} catch (error) {
+		if (DUPLICATE_COLUMN_RE.test(deepErrorMessage(error))) {
+			if (await columnExists(db, "media", column)) return;
+		}
+		throw error;
+	}
+}
+
+function deepErrorMessage(error: unknown): string {
+	if (error instanceof Error) {
+		const own = error.message ?? "";
+		if (error.cause) {
+			const causeMessage = deepErrorMessage(error.cause);
+			return own ? `${own}: ${causeMessage}` : causeMessage;
+		}
+		return own;
+	}
+	if (typeof error === "string") return error;
+	try {
+		return JSON.stringify(error);
+	} catch {
+		return String(error);
+	}
+}

package/src/database/migrations/074_content_deleted_scheduled_index.ts

@@ -0,0 +1,55 @@
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+
+import { listTablesLike } from "../dialect-helpers.js";
+
+/**
+ * Migration: replace the single-column partial `scheduled_at` index on content
+ * tables with a `(deleted_at, scheduled_at)` composite.
+ *
+ * The scheduled-publishing sweep filters `scheduled_at` by range and
+ * `deleted_at IS NULL`, ordered by `scheduled_at`. A `scheduled_at`-only index
+ * cannot satisfy the soft-delete term, so a stats-blind planner seeks a
+ * `deleted_at`-leading composite instead and reads every live row. Leading with
+ * `deleted_at` lets one index serve the equality, the range, and the ORDER BY.
+ * D1 never has `sqlite_stat1`, so the index shape is the only lever.
+ *
+ * The partial predicate from migration 030 is kept so the index stays
+ * proportional to scheduled content rather than to the table.
+ *
+ * Forward-only and idempotent (`IF NOT EXISTS`).
+ *
+ * The short `del_sched` suffix keeps the name inside Postgres's 63-byte
+ * identifier limit for long collection slugs. Keep it identical to the name 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 replacement before dropping the
+		// old index so an interrupted migration always leaves a scheduled_at index
+		// in place.
+		await sql`
+			CREATE INDEX IF NOT EXISTS ${sql.ref(`idx_${tableName}_del_sched`)}
+			ON ${sql.ref(tableName)} (deleted_at, scheduled_at)
+			WHERE scheduled_at IS NOT NULL
+		`.execute(db);
+
+		await sql`DROP INDEX IF EXISTS ${sql.ref(`idx_${tableName}_scheduled`)}`.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}_scheduled`)}
+			ON ${sql.ref(tableName)} (scheduled_at)
+			WHERE scheduled_at IS NOT NULL
+		`.execute(db);
+
+		await sql`DROP INDEX IF EXISTS ${sql.ref(`idx_${tableName}_del_sched`)}`.execute(db);
+	}
+}