emdash 0.36.0 → 0.38.0

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

@@ -4,12 +4,25 @@
  * Converts TipTap's ProseMirror JSON format to Portable Text for storage.
  */
 
+import {
+	UnsafePortableTextTableError,
+	proseMirrorTableToPortableText,
+} from "@emdash-cms/admin/portable-text-table";
+
 import { sanitizeGalleryImages } from "./gallery.js";
 import {
 	UnsupportedPortableTextMarksError,
 	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 +54,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 +89,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);
 
@@ -91,10 +119,25 @@ function convertNode(
 		case "gallery":
 			return convertGallery(node);
 
+		case "table": {
+			const result = proseMirrorTableToPortableText(node, {
+				path,
+				createKey: generateKey,
+				inlineToSpans: (content) => {
+					const { children, markDefs } = convertInlineContent(content, true);
+					return { content: children, markDefs };
+				},
+			});
+			if (!result.ok) {
+				throw new UnsafePortableTextTableError(result.reason, result.raw, result.renderFallback);
+			}
+			return result.table;
+		}
+
 		case "horizontalRule":
 			return {
 				_type: "break",
-				_key: generateKey(),
+				_key: portableTextKeyFromAttrs(node.attrs) ?? generateKey(),
 				style: "lineBreak",
 			};
 
@@ -125,10 +168,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 +213,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 +261,7 @@ function convertListItem(
 			if (children.length > 0) {
 				blocks.push({
 					_type: "block",
-					_key: generateKey(),
+					_key: portableTextKeyFromAttrs(child.attrs) ?? generateKey(),
 					style: "normal",
 					listItem,
 					level,
@@ -274,7 +317,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 +341,7 @@ function convertCodeBlock(node: ProseMirrorNode): PortableTextCodeBlock {
 
 	return {
 		_type: "code",
-		_key: generateKey(),
+		_key: portableTextKeyFromAttrs(node.attrs) ?? generateKey(),
 		code,
 		language: language || undefined,
 	};
@@ -308,7 +354,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 +373,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 +392,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 +410,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 } : {}),
 	};
@@ -364,40 +419,71 @@ function convertGallery(node: ProseMirrorNode): PortableTextGalleryBlock {
 /**
  * Convert inline content (text nodes with marks) to Portable Text spans
  */
-function convertInlineContent(nodes: ProseMirrorNode[]): {
+function convertInlineContent(
+	nodes: ProseMirrorNode[],
+	preserveHardBreakBoundary = false,
+): {
 	children: PortableTextSpan[];
 	markDefs: PortableTextMarkDef[];
 } {
 	const children: PortableTextSpan[] = [];
 	const markDefs: PortableTextMarkDef[] = [];
-	const markDefMap = new Map<string, string>(); // href -> key
+	const markDefMap = new Map<string, string>();
+	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
-			if (children.length > 0) {
+			if (children.length > 0 && !preserveHardBreakBoundary) {
 				const lastChild = children.at(-1)!;
 				lastChild.text += "\n";
 			} else {
 				children.push({
 					_type: "span",
-					_key: generateKey(),
+					_key: claimSpanKey(
+						portableTextSpanKeyFromMarks(node.marks) ?? portableTextKeyFromAttrs(node.attrs),
+					),
 					text: "\n",
 				});
 			}
@@ -408,7 +494,7 @@ function convertInlineContent(nodes: ProseMirrorNode[]): {
 	if (children.length === 0) {
 		children.push({
 			_type: "span",
-			_key: generateKey(),
+			_key: claimSpanKey(),
 			text: "",
 		});
 	}
@@ -423,6 +509,7 @@ function convertMark(
 	mark: ProseMirrorMark,
 	markDefs: PortableTextMarkDef[],
 	markDefMap: Map<string, string>,
+	originalMarkDefs: PortableTextMarkDef[],
 ): string | null {
 	switch (mark.type) {
 		case "bold":
@@ -449,23 +536,36 @@ 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 blank = mark.attrs?.target === "_blank";
+			const originalMarkDef = originalMarkDefs.find((markDef) => markDef._type === "link");
+			const mapKey = originalMarkDef
+				? `key:${originalMarkDef._key}`
+				: `value:${JSON.stringify([href, blank])}`;
 
 			// 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();
 			markDefs.push({
+				...originalMarkDef,
 				_type: "link",
 				_key: key,
 				href,
-				blank: mark.attrs?.target === "_blank",
+				...(originalMarkDef
+					? blank || Object.hasOwn(originalMarkDef, "blank")
+						? { blank }
+						: {}
+					: { blank }),
 			});
-			markDefMap.set(href, key);
+			markDefMap.set(mapKey, key);
 
 			return key;
 		}

package/src/content/converters/types.ts

@@ -4,6 +4,15 @@
  * Defines the structure of Portable Text blocks used in EmDash.
  */
 
+import type { PortableTextTableBlock } from "@emdash-cms/admin/portable-text-table";
+
+export type {
+	PortableTextTableAlignment,
+	PortableTextTableBlock,
+	PortableTextTableCell,
+	PortableTextTableRow,
+} from "@emdash-cms/admin/portable-text-table";
+
 /**
  * Base span (inline text)
  */
@@ -70,6 +79,7 @@ export interface PortableTextImageBlock {
 	displayWidth?: number;
 	/** Display height for this instance (overrides original) */
 	displayHeight?: number;
+	alignment?: "left" | "center" | "right" | "wide" | "full";
 }
 
 /**
@@ -147,6 +157,7 @@ export type PortableTextBlock =
 	| PortableTextGalleryBlock
 	| PortableTextCodeBlock
 	| PortableTextHtmlBlock
+	| PortableTextTableBlock
 	| PortableTextUnknownBlock;
 
 /**

package/src/database/dialect-helpers.ts

@@ -14,6 +14,7 @@ import type { ColumnDataType, Kysely, RawBuilder } from "kysely";
 import { PostgresAdapter, sql } from "kysely";
 
 import type { DatabaseDialectType } from "../db/adapters.js";
+import type { Database } from "./types.js";
 import { validateIdentifier, validateJsonFieldName } from "./validate.js";
 
 export type { DatabaseDialectType };
@@ -207,6 +208,7 @@ export async function listTablesLike(db: Kysely<any>, pattern: string): Promise<
 		const result = await sql<{ table_name: string }>`
 			SELECT table_name FROM information_schema.tables
 			WHERE table_schema = current_schema() AND table_name LIKE ${pattern}
+			ORDER BY table_name
 		`.execute(db);
 		return result.rows.map((r) => r.table_name);
 	}
@@ -214,10 +216,48 @@ export async function listTablesLike(db: Kysely<any>, pattern: string): Promise<
 	const result = await sql<{ name: string }>`
 		SELECT name FROM sqlite_master
 		WHERE type = 'table' AND name LIKE ${pattern}
+		ORDER BY name
 	`.execute(db);
 	return result.rows.map((r) => r.name);
 }
 
+export interface TableColumnInfo {
+	name: string;
+	type: string;
+}
+
+/**
+ * List a table's columns in declaration order.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
+export async function listTableColumns(
+	db: Kysely<any>,
+	tableName: string,
+): Promise<TableColumnInfo[]> {
+	if (isPostgres(db)) {
+		const result = await sql<{
+			column_name: string;
+			data_type: string;
+		}>`
+			SELECT column_name, data_type
+			FROM information_schema.columns
+			WHERE table_schema = current_schema() AND table_name = ${tableName}
+			ORDER BY ordinal_position
+		`.execute(db);
+		return result.rows.map((column) => ({
+			name: column.column_name,
+			type: column.data_type,
+		}));
+	}
+
+	const result = await sql<{ name: string; type: string }>`
+		SELECT name, type
+		FROM pragma_table_info(${tableName})
+		ORDER BY cid
+	`.execute(db);
+	return result.rows;
+}
+
 /**
  * Column type for binary data.
  *
@@ -299,6 +339,91 @@ export function pluginDataExtractExpr(
 	return `CASE WHEN json_type(data, '$.${field}') IN ('integer', 'real') THEN ${extract} END`;
 }
 
+/**
+ * Build the new value of the `_plugin_storage.data` (text-JSON) column for a
+ * guarded `updateIf`, composing wholesale `set` fields and integer `delta`
+ * fields into a SINGLE dialect-correct expression.
+ *
+ * Both branches go through `json_set` / `jsonb_set` so the write never rewrites
+ * the whole column from JS (which would require a read-then-write and break the
+ * single-statement atomicity that makes no-oversell hold):
+ *
+ * - **set** field → the value is stored via `json(?)` (SQLite) / `?::jsonb`
+ *   (Postgres) with `JSON.stringify(value)`, uniformly handling scalars,
+ *   objects, arrays, and `null` (stored as JSON `null`, never SQL `NULL` — a
+ *   SQL `NULL` in `jsonb_set` would null the entire `data` column and hit the
+ *   `NOT NULL` constraint).
+ * - **delta** field → `COALESCE(<numeric extract>, 0) + n`, where the extract
+ *   is the type-guarded numeric form from {@link pluginDataExtractExpr} so a
+ *   missing or null stored value coalesces to `0` on both dialects. The update
+ *   guard rejects invalid counters and unsafe results. Integer arithmetic stays
+ *   integer (Postgres `to_jsonb(numeric)` and SQLite integer `+` both round-trip
+ *   without a spurious `.0`).
+ *
+ * Field names are validated (`validateJsonFieldName` / `pluginDataExtractExpr`)
+ * before interpolation, so the JSON path is a safe identifier and values are
+ * bound parameters — no injection surface.
+ *
+ * SQLite:   json_set(json_set(data, '$.f1', json(?)), '$.f2', COALESCE(json_extract(...), 0) + ?)
+ * Postgres: (jsonb_set(jsonb_set(data::jsonb, '{f1}', ?::jsonb), '{f2}', to_jsonb(COALESCE(..., 0) + ?)))::text
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
+export function pluginDataWriteExpr(
+	db: Kysely<any>,
+	setEntries: Array<[string, unknown]>,
+	deltaEntries: Array<[string, number]>,
+): RawBuilder<string> {
+	const pg = isPostgres(db);
+	let expr: RawBuilder<unknown> = pg ? sql`data::jsonb` : sql`data`;
+
+	for (const [field, value] of setEntries) {
+		validateJsonFieldName(field, "plugin storage set field name");
+		const json = JSON.stringify(value ?? null);
+		if (pg) {
+			expr = sql`jsonb_set(${expr}, ${sql.lit(`{${field}}`)}, ${json}::jsonb)`;
+		} else {
+			expr = sql`json_set(${expr}, ${sql.lit(`$.${field}`)}, json(${json}))`;
+		}
+	}
+
+	for (const [field, n] of deltaEntries) {
+		const numericExtract = pluginDataExtractExpr(db, field, { numeric: true });
+		if (pg) {
+			expr = sql`jsonb_set(${expr}, ${sql.lit(`{${field}}`)}, to_jsonb(COALESCE(${sql.raw(numericExtract)}, 0) + ${n}))`;
+		} else {
+			expr = sql`json_set(${expr}, ${sql.lit(`$.${field}`)}, cast(COALESCE(${sql.raw(numericExtract)}, 0) as integer) + cast(${n} as integer))`;
+		}
+	}
+
+	if (pg) {
+		return sql<string>`(${expr})::text`;
+	}
+	return sql<string>`${expr}`;
+}
+
+export function pluginDataUpdateGuard(
+	db: Kysely<Database>,
+	deltaEntries: Array<[string, number]>,
+): RawBuilder<boolean> {
+	const pg = isPostgres(db);
+	const conditions: RawBuilder<boolean>[] = [
+		pg ? sql`jsonb_typeof(data::jsonb) = 'object'` : sql`json_type(data) = 'object'`,
+	];
+	for (const [field, amount] of deltaEntries) {
+		const numeric = sql.raw(pluginDataExtractExpr(db, field, { numeric: true }));
+		const type = pg
+			? sql`jsonb_typeof(data::jsonb -> ${sql.lit(field)})`
+			: sql`json_type(data, ${sql.lit(`$.${field}`)})`;
+		const base = sql`coalesce(${numeric}, 0)`;
+		const integral = pg ? sql`${base} = trunc(${base})` : sql`${base} = cast(${base} as integer)`;
+		const lower = Math.max(Number.MIN_SAFE_INTEGER, Number.MIN_SAFE_INTEGER - amount);
+		const upper = Math.min(Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER - amount);
+		conditions.push(sql`((${type} is null or ${type} = 'null' or ${numeric} is not null)
+			and ${integral} and ${base} >= ${lower} and ${base} <= ${upper})`);
+	}
+	return sql`(${sql.join(conditions, sql` and `)})`;
+}
+
 /**
  * SQL expression for ordering plugin-storage rows by a `data` field.
  *

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/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);
+	}
+}

package/src/database/migrations/075_entry_edit_locks.ts

@@ -0,0 +1,44 @@
+import type { Kysely } from "kysely";
+
+import { columnExists } from "../dialect-helpers.js";
+
+/**
+ * Timestamps here carry no column default: `datetime('now')` renders a
+ * space-separated shape that would not sort against the ISO-8601 values the
+ * lease predicate compares as strings.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await db.schema
+		.createTable("_emdash_entry_locks")
+		.ifNotExists()
+		.addColumn("collection", "text", (col) => col.notNull())
+		.addColumn("entry_id", "text", (col) => col.notNull())
+		.addColumn("user_id", "text", (col) => col.notNull().references("users.id").onDelete("cascade"))
+		.addColumn("token", "text", (col) => col.notNull())
+		.addColumn("acquired_at", "text", (col) => col.notNull())
+		.addColumn("expires_at", "text", (col) => col.notNull())
+		.addPrimaryKeyConstraint("pk_emdash_entry_locks", ["collection", "entry_id"])
+		.execute();
+
+	await db.schema
+		.createIndex("idx_emdash_entry_locks_user_id")
+		.ifNotExists()
+		.on("_emdash_entry_locks")
+		.column("user_id")
+		.execute();
+
+	if (!(await columnExists(db, "_emdash_collections", "edit_locking"))) {
+		await db.schema
+			.alterTable("_emdash_collections")
+			.addColumn("edit_locking", "integer", (col) => col.notNull().defaultTo(1))
+			.execute();
+	}
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	if (await columnExists(db, "_emdash_collections", "edit_locking")) {
+		await db.schema.alterTable("_emdash_collections").dropColumn("edit_locking").execute();
+	}
+	await db.schema.dropIndex("idx_emdash_entry_locks_user_id").ifExists().execute();
+	await db.schema.dropTable("_emdash_entry_locks").ifExists().execute();
+}

package/src/database/migrations/076_collection_nav_group.ts

@@ -0,0 +1,22 @@
+import type { Kysely } from "kysely";
+
+import { columnExists } from "../dialect-helpers.js";
+
+/**
+ * Migration: group collections into admin sidebar folders.
+ *
+ * Adds `nav_group` to `_emdash_collections`. Collections sharing a group
+ * render under one collapsible folder in the admin sidebar; NULL keeps the
+ * collection inline.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	if (!(await columnExists(db, "_emdash_collections", "nav_group"))) {
+		await db.schema.alterTable("_emdash_collections").addColumn("nav_group", "text").execute();
+	}
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	if (await columnExists(db, "_emdash_collections", "nav_group")) {
+		await db.schema.alterTable("_emdash_collections").dropColumn("nav_group").execute();
+	}
+}