emdash 0.37.0 → 0.38.0

package/src/components/Table.astro

@@ -1,83 +1,156 @@
 ---
-/**
- * Portable Text Table block component
- *
- * Renders tables from content imports. Cell content is rendered through the
- * standard Portable Text pipeline so all marks (bold, italic, links, etc.) are
- * handled by the registered mark components -- including `sanitizeHref` for links.
- */
+import {
+	TABLE_CELL_MIN_WIDTH,
+	createPortableTextTableCellMarkResolver,
+	getPortableTextTableColumnWidths,
+	normalizePortableTextTable,
+	type PortableTextTableBlock,
+	type PortableTextTableCell,
+} from "@emdash-cms/admin/portable-text-table";
 import { PortableText } from "astro-portabletext";
 import { emdashMarkComponents } from "./marks.js";
 
 export interface Props {
-	node: {
-		_type: "table";
-		_key: string;
-		rows: Array<{
-			_type: "tableRow";
-			_key: string;
-			cells: Array<{
-				_type: "tableCell";
-				_key: string;
-				content: Array<{
-					_type: "span";
-					_key: string;
-					text: string;
-					marks?: string[];
-				}>;
-				markDefs?: Array<{
-					_type: string;
-					_key: string;
-					[key: string]: unknown;
-				}>;
-				isHeader?: boolean;
-			}>;
-		}>;
-		hasHeaderRow?: boolean;
-	};
+	node: unknown;
 }
 
-const markComponents = { mark: emdashMarkComponents };
+interface PlacedCell {
+	cell: PortableTextTableCell;
+	column: number;
+}
 
+const markComponents = { mark: emdashMarkComponents };
 const { node } = Astro.props;
-const rows = node?.rows ?? [];
+let generatedKey = 0;
+const normalized = normalizePortableTextTable(node, {
+	path: "render:table",
+	createKey: () => `render-table-${generatedKey++}`,
+});
+const table = normalized.ok ? normalized.table : normalized.renderFallback;
+const resolveCellMarkDefs = table ? createPortableTextTableCellMarkResolver(table) : undefined;
+const rawRows = table ? undefined : getRawRows(normalized.raw);
+const placedRows = table ? placeCells(table) : [];
+const visualWidth = normalized.ok
+	? normalized.width
+	: table
+		? getVisualWidth(placedRows)
+		: getRawWidth(rawRows ?? []);
+const columnWidths = table ? getPortableTextTableColumnWidths(table) : undefined;
+const minimumWidth = columnWidths
+	? columnWidths.reduce((total, columnWidth) => total + columnWidth, 0)
+	: visualWidth * TABLE_CELL_MIN_WIDTH;
+const hasHeaderRow =
+	table?.hasHeaderRow === true &&
+	table.rows[0]?.cells.length > 0 &&
+	table.rows[0].cells.every((cell) => cell.isHeader === true && (cell.rowspan ?? 1) === 1);
+const headerRow = hasHeaderRow ? placedRows[0] : undefined;
+const bodyRows = hasHeaderRow ? placedRows.slice(1) : placedRows;
+
+function placeCells(value: PortableTextTableBlock): PlacedCell[][] {
+	const occupied = Array.from({ length: value.rows.length }, () => new Set<number>());
+	return value.rows.map((row, rowIndex) => {
+		let column = 0;
+		return row.cells.map((cell) => {
+			while (occupied[rowIndex]?.has(column)) column++;
+			const start = column;
+			const colspan = cell.colspan ?? 1;
+			const rowspan = cell.rowspan ?? 1;
+			for (let rowOffset = 0; rowOffset < rowspan; rowOffset++) {
+				for (let columnOffset = 0; columnOffset < colspan; columnOffset++) {
+					occupied[rowIndex + rowOffset]?.add(start + columnOffset);
+				}
+			}
+			column += colspan;
+			return { cell, column: start };
+		});
+	});
+}
 
-if (!rows.length) {
-	return null;
+function getVisualWidth(rows: PlacedCell[][]): number {
+	let result = 1;
+	for (const row of rows) {
+		for (const { cell, column } of row) {
+			result = Math.max(result, column + (cell.colspan ?? 1));
+		}
+	}
+	return result;
+}
+
+function getRawRows(value: unknown): unknown[] {
+	return isRecord(value) && Array.isArray(value.rows) ? value.rows : [];
 }
 
-/**
- * Wrap a table cell's inline content as a Portable Text block so it can be
- * rendered through the standard pipeline (marks, markDefs, etc.).
- */
-function cellToBlock(cell: Props["node"]["rows"][number]["cells"][number]) {
+function getRawCells(value: unknown): unknown[] {
+	return isRecord(value) && Array.isArray(value.cells) ? value.cells : [];
+}
+
+function getRawWidth(rows: unknown[]): number {
+	let rawWidth = 1;
+	for (const row of rows) rawWidth = Math.max(rawWidth, getRawCells(row).length);
+	return rawWidth;
+}
+
+function recoverRawCellText(value: unknown, depth = 0): string {
+	if (depth > 32) return "";
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) {
+		return value.map((entry) => recoverRawCellText(entry, depth + 1)).join("");
+	}
+	if (!isRecord(value)) return "";
+	if (typeof value.text === "string") return value.text;
+	if (typeof value.content === "string") return value.content;
+	const nested = Array.isArray(value.content)
+		? value.content
+		: Array.isArray(value.children)
+			? value.children
+			: [];
+	return recoverRawCellText(nested, depth + 1);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function cellToBlock(cell: PortableTextTableCell) {
 	return [
 		{
 			_type: "block" as const,
 			_key: cell._key,
+			style: "normal",
 			children: cell.content,
-			markDefs: cell.markDefs ?? [],
+			markDefs: resolveCellMarkDefs?.(cell) ?? [],
 		},
 	];
 }
 
-const hasHeader = node?.hasHeaderRow;
-const headerRow = hasHeader ? rows[0] : null;
-const bodyRows = hasHeader ? rows.slice(1) : rows;
+function cellAttributes(cell: PortableTextTableCell, scope?: "col" | "row") {
+	return {
+		scope,
+		colspan: (cell.colspan ?? 1) > 1 ? cell.colspan : undefined,
+		rowspan: (cell.rowspan ?? 1) > 1 ? cell.rowspan : undefined,
+		style: cell.textAlign ? `text-align: ${cell.textAlign};` : undefined,
+	};
+}
 ---
 
 <div class="emdash-table-wrapper">
-	<table class="emdash-table">
+	<table class="emdash-table" style={`min-width: ${minimumWidth}px;`}>
+		{table ? (
+			<>
+		{
+			columnWidths && (
+				<colgroup>
+					{columnWidths.map((columnWidth) => <col style={`width: ${columnWidth}px;`} />)}
+				</colgroup>
+			)
+		}
 		{
 			headerRow && (
 				<thead>
 					<tr>
-						{headerRow.cells.map((cell) => (
-							<th>
-								<PortableText
-									value={cellToBlock(cell)}
-									components={markComponents}
-								/>
+						{headerRow.map(({ cell }) => (
+							<th {...cellAttributes(cell, "col")}>
+								<PortableText value={cellToBlock(cell)} components={markComponents} />
 							</th>
 						))}
 					</tr>
@@ -88,14 +161,13 @@ const bodyRows = hasHeader ? rows.slice(1) : rows;
 			{
 				bodyRows.map((row) => (
 					<tr>
-						{row.cells.map((cell) => {
+						{row.map(({ cell, column }) => {
 							const CellTag = cell.isHeader ? "th" : "td";
+							const scope =
+								cell.isHeader && column === 0 && (cell.rowspan ?? 1) === 1 ? "row" : undefined;
 							return (
-								<CellTag>
-									<PortableText
-										value={cellToBlock(cell)}
-										components={markComponents}
-									/>
+								<CellTag {...cellAttributes(cell, scope)}>
+									<PortableText value={cellToBlock(cell)} components={markComponents} />
 								</CellTag>
 							);
 						})}
@@ -103,26 +175,39 @@ const bodyRows = hasHeader ? rows.slice(1) : rows;
 				))
 			}
 		</tbody>
+			</>
+		) : (
+			<tbody>
+				{rawRows?.map((row) => (
+					<tr>
+						{getRawCells(row).map((cell) => <td>{recoverRawCellText(cell)}</td>)}
+					</tr>
+				))}
+			</tbody>
+		)}
 	</table>
 </div>
 
 <style>
 	.emdash-table-wrapper {
-		margin: 1.5rem 0;
+		max-inline-size: 100%;
+		margin-block: 1.5rem;
 		overflow-x: auto;
+		overscroll-behavior-inline: contain;
 	}
 	.emdash-table {
-		width: 100%;
+		inline-size: 100%;
 		border-collapse: collapse;
 		font-size: 0.9rem;
 	}
 	.emdash-table th,
 	.emdash-table td {
+		position: relative;
 		border: 1px solid var(--color-border, #ddd);
 		padding: 0.75rem;
-		text-align: left;
+		text-align: start;
+		vertical-align: top;
 	}
-	/* Remove default block margins inside cells */
 	.emdash-table th :global(p),
 	.emdash-table td :global(p) {
 		margin: 0;

package/src/config/errors.ts

@@ -0,0 +1,13 @@
+export type EmDashConfigurationErrorCode = "BINDING_NOT_FOUND" | "CONFIGURATION_ERROR";
+
+/** A configuration failure whose message is safe to return from the API. */
+export class EmDashConfigurationError extends Error {
+	constructor(
+		message: string,
+		public readonly code: EmDashConfigurationErrorCode,
+		public override cause?: unknown,
+	) {
+		super(message);
+		this.name = "EmDashConfigurationError";
+	}
+}

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

@@ -4,6 +4,11 @@
  * Converts Portable Text to TipTap's ProseMirror JSON format for editing.
  */
 
+import {
+	UnsafePortableTextTableError,
+	portableTextTableToProseMirror,
+} from "@emdash-cms/admin/portable-text-table";
+
 import { sanitizeGalleryImages } from "./gallery.js";
 import {
 	UnsupportedPortableTextMarksError,
@@ -34,6 +39,10 @@ import type {
 	PortableTextCodeBlock,
 } from "./types.js";
 
+function generateKey(): string {
+	return Math.random().toString(36).substring(2, 11);
+}
+
 export interface PortableTextToProsemirrorOptions {
 	/**
 	 * Preserve custom blocks and Portable Text keys through a ProseMirror round trip.
@@ -134,7 +143,7 @@ export function portableTextToProsemirror(
 				}),
 			});
 		} else {
-			const converted = convertBlock(block, preserveIdentity);
+			const converted = convertBlock(block, `root:${i}`, preserveIdentity);
 			if (converted) {
 				content.push(converted);
 			}
@@ -222,7 +231,11 @@ function isCodeBlock(block: PortableTextBlock): block is PortableTextCodeBlock {
 /**
  * Convert a single Portable Text block to ProseMirror node
  */
-function convertBlock(block: PortableTextBlock, preserveIdentity: boolean): ProseMirrorNode | null {
+function convertBlock(
+	block: PortableTextBlock,
+	path: string,
+	preserveIdentity: boolean,
+): ProseMirrorNode | null {
 	if (isTextBlock(block)) {
 		return convertTextBlock(block, preserveIdentity);
 	}
@@ -286,6 +299,17 @@ function convertBlock(block: PortableTextBlock, preserveIdentity: boolean): Pros
 			attrs: { [PORTABLE_TEXT_BLOCK_ATTR]: block },
 		};
 	}
+	if (block._type === "table") {
+		const result = portableTextTableToProseMirror(block, {
+			path,
+			createKey: generateKey,
+			spansToInline: (content, markDefs) => convertSpans(content, markDefs, preserveIdentity),
+		});
+		if (!result.ok) {
+			throw new UnsafePortableTextTableError(result.reason, result.raw, result.renderFallback);
+		}
+		return result.node;
+	}
 	return {
 		type: "paragraph",
 		content: [

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

@@ -4,6 +4,11 @@
  * 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,
@@ -114,6 +119,21 @@ 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",
@@ -399,13 +419,16 @@ 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)) {
@@ -452,7 +475,7 @@ function convertInlineContent(nodes: ProseMirrorNode[]): {
 			});
 		} 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 {
@@ -518,8 +541,11 @@ function convertMark(
 
 		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}` : `href:${href}`;
+			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(mapKey)) {
@@ -528,13 +554,16 @@ function convertMark(
 
 			// Create new mark def
 			const key = originalMarkDef?._key || generateKey();
-			const blank = mark.attrs?.target === "_blank";
 			markDefs.push({
 				...originalMarkDef,
 				_type: "link",
 				_key: key,
 				href,
-				...(blank || (originalMarkDef && Object.hasOwn(originalMarkDef, "blank")) ? { blank } : {}),
+				...(originalMarkDef
+					? blank || Object.hasOwn(originalMarkDef, "blank")
+						? { blank }
+						: {}
+					: { blank }),
 			});
 			markDefMap.set(mapKey, 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)
  */
@@ -148,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/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();
+	}
+}