emdash 0.36.0 → 0.38.0

package/src/database/migrations/077_plugin_storage_revisions.ts

@@ -0,0 +1,89 @@
+import { type Kysely, sql } from "kysely";
+
+import { columnExists, isPostgres } from "../dialect-helpers.js";
+
+const TABLES = [
+	{ name: "options", keys: ["name"] },
+	{ name: "_plugin_storage", keys: ["plugin_id", "collection", "id"] },
+] as const;
+
+const DUPLICATE_COLUMN_REGEX =
+	/(?:duplicate column|column .* already exists|already exists.*column)/i;
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	for (const table of TABLES) {
+		if (await columnExists(db, table.name, "revision")) continue;
+		try {
+			await db.schema
+				.alterTable(table.name)
+				.addColumn("revision", "text", (column) => column.notNull().defaultTo("0"))
+				.execute();
+		} catch (error) {
+			if (isDuplicateColumnError(error) && (await columnExists(db, table.name, "revision"))) {
+				continue;
+			}
+			throw error;
+		}
+	}
+
+	if (isPostgres(db)) {
+		await sql`
+			CREATE OR REPLACE FUNCTION emdash_plugin_storage_assign_revision()
+			RETURNS trigger
+			LANGUAGE plpgsql
+			AS $$
+			BEGIN
+				IF TG_OP = 'INSERT' THEN
+					IF NEW.revision = '0' THEN
+						NEW.revision := gen_random_uuid()::text;
+					END IF;
+				ELSIF NEW.revision = '0' OR NEW.revision = OLD.revision THEN
+					NEW.revision := gen_random_uuid()::text;
+				END IF;
+				RETURN NEW;
+			END;
+			$$
+		`.execute(db);
+		for (const table of TABLES) {
+			await sql`
+				CREATE OR REPLACE TRIGGER ${sql.ref(`emdash_${table.name}_revision`)}
+				BEFORE INSERT OR UPDATE ON ${sql.ref(table.name)}
+				FOR EACH ROW EXECUTE FUNCTION emdash_plugin_storage_assign_revision()
+			`.execute(db);
+		}
+	} else {
+		for (const table of TABLES) {
+			const rowKey = sql.join(
+				table.keys.map((key) => sql`${sql.ref(key)} = ${sql.ref(`NEW.${key}`)}`),
+				sql` AND `,
+			);
+			await sql`
+				CREATE TRIGGER IF NOT EXISTS ${sql.ref(`emdash_${table.name}_revision_insert`)}
+				AFTER INSERT ON ${sql.ref(table.name)}
+				WHEN NEW.revision = '0'
+				BEGIN
+					UPDATE ${sql.ref(table.name)} SET revision = lower(hex(randomblob(16)))
+					WHERE ${rowKey} AND revision = NEW.revision;
+				END
+			`.execute(db);
+			await sql`
+				CREATE TRIGGER IF NOT EXISTS ${sql.ref(`emdash_${table.name}_revision_update`)}
+				AFTER UPDATE ON ${sql.ref(table.name)}
+				WHEN NEW.revision = '0' OR NEW.revision = OLD.revision
+				BEGIN
+					UPDATE ${sql.ref(table.name)} SET revision = lower(hex(randomblob(16)))
+					WHERE ${rowKey} AND revision = NEW.revision;
+				END
+			`.execute(db);
+		}
+	}
+}
+
+function isDuplicateColumnError(error: unknown): boolean {
+	if (!(error instanceof Error)) return false;
+	return DUPLICATE_COLUMN_REGEX.test(error.message) || isDuplicateColumnError(error.cause);
+}
+
+export async function down(_db: Kysely<unknown>): Promise<void> {
+	// Revisions must survive a host rollback while other writers still use them.
+}

package/src/database/migrations/runner.ts

@@ -76,6 +76,10 @@ import * as m070 from "./070_collection_routable.js";
 import * as m071 from "./071_restore_content_bylines_table.js";
 import * as m072 from "./072_media_folders.js";
 import * as m073 from "./073_media_focal_point.js";
+import * as m074 from "./074_content_deleted_scheduled_index.js";
+import * as m075 from "./075_entry_edit_locks.js";
+import * as m076 from "./076_collection_nav_group.js";
+import * as m077 from "./077_plugin_storage_revisions.js";
 
 const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"001_initial": m001,
@@ -150,6 +154,10 @@ const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"071_restore_content_bylines_table": m071,
 	"072_media_folders": m072,
 	"073_media_focal_point": m073,
+	"074_content_deleted_scheduled_index": m074,
+	"075_entry_edit_locks": m075,
+	"076_collection_nav_group": m076,
+	"077_plugin_storage_revisions": m077,
 });
 
 /** Ordered names from the statically registered migration set. */
@@ -211,7 +219,7 @@ export interface MigrationOptions {
 	raceWaitMs?: number;
 }
 
-function createMigrator(db: Kysely<Database>, options?: MigrationOptions): Migrator {
+export function createMigrator(db: Kysely<Database>, options?: MigrationOptions): Migrator {
 	return new Migrator({
 		db,
 		provider: new StaticMigrationProvider(),

package/src/database/repositories/byline.ts

@@ -30,9 +30,9 @@ type BylineRow = Selectable<BylineTable>;
 
 /**
  * A byline row optionally augmented with the avatar's media columns, folded in
- * by the `LEFT JOIN media` in the content-credit hydration queries. The plain
- * `selectAll()` finders produce rows without these keys, so they're optional
- * and `rowToByline` defaults them to null.
+ * by the `LEFT JOIN media` in the credit-hydration and single-row finder
+ * queries. `findMany` selects without the join, so the keys are optional and
+ * `rowToByline` defaults them to null.
  */
 type BylineRowWithAvatar = BylineRow & {
 	avatar_storage_key?: string | null;
@@ -298,7 +298,7 @@ export class BylineRepository {
 	 * same way `BylineRepository` doesn't resolve locale fallback for
 	 * the base byline lookup.
 	 */
-	private async withCustomFields(rows: BylineRow[]): Promise<BylineSummary[]> {
+	private async withCustomFields(rows: BylineRowWithAvatar[]): Promise<BylineSummary[]> {
 		const summaries = rows.map(rowToByline);
 		// Always populate `customFields = {}` (PR plan AC #6) — even when
 		// no fields are registered, every BylineSummary carries the empty
@@ -311,7 +311,9 @@ export class BylineRepository {
 		return summaries;
 	}
 
-	private async withCustomFieldsOne(row: BylineRow | undefined): Promise<BylineSummary | null> {
+	private async withCustomFieldsOne(
+		row: BylineRowWithAvatar | undefined,
+	): Promise<BylineSummary | null> {
 		if (!row) return null;
 		const [result] = await this.withCustomFields([row]);
 		return result ?? null;
@@ -501,12 +503,26 @@ export class BylineRepository {
 	// Reads
 	// ============================================
 
+	/**
+	 * Every byline column plus the avatar's media columns, folded in by the
+	 * same `LEFT JOIN media` the credit-hydration queries use. Only the
+	 * single-row finders select this; `findMany` stays a single-table scan.
+	 */
+	private selectBylineWithAvatar() {
+		return this.db
+			.selectFrom("_emdash_bylines as b")
+			.leftJoin("media as m", "m.id", "b.avatar_media_id")
+			.selectAll("b")
+			.select([
+				"m.storage_key as avatar_storage_key",
+				"m.alt as avatar_alt",
+				"m.blurhash as avatar_blurhash",
+				"m.dominant_color as avatar_dominant_color",
+			]);
+	}
+
 	async findById(id: string): Promise<BylineSummary | null> {
-		const row = await this.db
-			.selectFrom("_emdash_bylines")
-			.selectAll()
-			.where("id", "=", id)
-			.executeTakeFirst();
+		const row = await this.selectBylineWithAvatar().where("b.id", "=", id).executeTakeFirst();
 		return this.withCustomFieldsOne(row);
 	}
 
@@ -516,9 +532,9 @@ export class BylineRepository {
 	 * calls). Mirrors `TaxonomyRepository.findBySlug`.
 	 */
 	async findBySlug(slug: string, options?: { locale?: string }): Promise<BylineSummary | null> {
-		let query = this.db.selectFrom("_emdash_bylines").selectAll().where("slug", "=", slug);
-		if (options?.locale !== undefined) query = query.where("locale", "=", options.locale);
-		const row = await query.orderBy("locale", "asc").executeTakeFirst();
+		let query = this.selectBylineWithAvatar().where("b.slug", "=", slug);
+		if (options?.locale !== undefined) query = query.where("b.locale", "=", options.locale);
+		const row = await query.orderBy("b.locale", "asc").executeTakeFirst();
 		return this.withCustomFieldsOne(row);
 	}
 
@@ -529,9 +545,9 @@ export class BylineRepository {
 	 * the lowest-locale-code match.
 	 */
 	async findByUserId(userId: string, options?: { locale?: string }): Promise<BylineSummary | null> {
-		let query = this.db.selectFrom("_emdash_bylines").selectAll().where("user_id", "=", userId);
-		if (options?.locale !== undefined) query = query.where("locale", "=", options.locale);
-		const row = await query.orderBy("locale", "asc").executeTakeFirst();
+		let query = this.selectBylineWithAvatar().where("b.user_id", "=", userId);
+		if (options?.locale !== undefined) query = query.where("b.locale", "=", options.locale);
+		const row = await query.orderBy("b.locale", "asc").executeTakeFirst();
 		return this.withCustomFieldsOne(row);
 	}
 

package/src/database/repositories/content.ts

@@ -42,6 +42,16 @@ const MAX_IN_FILTER_VALUES = SQL_BATCH_SIZE;
 const MAX_FILTER_STRING_LENGTH = 2048;
 
 type NormalizedFilterScalar = string | number;
+export type ContentRevisionPrecondition = Pick<ContentItem, "version" | "updatedAt">;
+
+function assertRevisionPrecondition(
+	item: ContentItem,
+	expected: ContentRevisionPrecondition | undefined,
+): void {
+	if (expected && (item.version !== expected.version || item.updatedAt !== expected.updatedAt)) {
+		throw new ContentMutationConflictError();
+	}
+}
 
 type ResolvedFieldFilter =
 	| { column: string; kind: "null" }
@@ -837,6 +847,15 @@ export class ContentRepository {
 		return mappedResult;
 	}
 
+	private normalizeScheduledAt(value: string | null): string | null {
+		if (value === null) return null;
+		const scheduledDate = new Date(value);
+		if (isNaN(scheduledDate.getTime())) {
+			throw new EmDashValidationError("Invalid scheduled date");
+		}
+		return scheduledDate.toISOString();
+	}
+
 	/**
 	 * Update content
 	 */
@@ -861,7 +880,7 @@ export class ContentRepository {
 		}
 
 		if (input.scheduledAt !== undefined) {
-			updates.scheduled_at = input.scheduledAt;
+			updates.scheduled_at = this.normalizeScheduledAt(input.scheduledAt);
 		}
 
 		if (input.authorId !== undefined) {
@@ -954,7 +973,7 @@ export class ContentRepository {
 				collection: type,
 				entryId: id,
 				data: mergedData,
-				...(input.authorId ? { authorId: input.authorId } : {}),
+				...(input.revisionAuthorId ? { authorId: input.revisionAuthorId } : {}),
 			});
 
 			let staged: boolean;
@@ -1020,7 +1039,7 @@ export class ContentRepository {
 			liveMetadataChanged = true;
 		}
 		if (input.scheduledAt !== undefined) {
-			assignments.push(sql`scheduled_at = ${input.scheduledAt}`);
+			assignments.push(sql`scheduled_at = ${this.normalizeScheduledAt(input.scheduledAt)}`);
 			liveMetadataChanged = true;
 		}
 		if (input.authorId !== undefined) {
@@ -1055,6 +1074,162 @@ export class ContentRepository {
 		return changed;
 	}
 
+	/**
+	 * Copy non-translatable field values to every other entry in the
+	 * translation group, trashed entries included.
+	 *
+	 * Only the fields present in `data` are copied. With `previous`, `data` is
+	 * the entry's complete new state and only the fields whose value differs
+	 * from `previous` are copied, an absent field as null. An entry that already
+	 * holds every copied value is left untouched, so its `updated_at` does not
+	 * move.
+	 *
+	 * On collections with revisions a changed entry also gets a new live
+	 * revision, because republishing and unpublishing read that revision rather
+	 * than the columns. A pending draft takes a value only where it still holds
+	 * the entry's previous value, so an unpublished edit to the field survives.
+	 */
+	async syncNonTranslatableFields(
+		type: string,
+		sourceId: string,
+		translationGroup: string,
+		data: Record<string, unknown>,
+		options: { previous?: Record<string, unknown> } = {},
+	): Promise<void> {
+		const tableName = getTableName(type);
+		const collectionRows = await this.db
+			.selectFrom("_emdash_collections as collection")
+			.leftJoin("_emdash_fields as field", (join) =>
+				join.onRef("field.collection_id", "=", "collection.id").on("field.translatable", "=", 0),
+			)
+			.select(["collection.supports", "field.slug as fieldSlug"])
+			.where("collection.slug", "=", type)
+			.execute();
+
+		const { previous } = options;
+		const values: Record<string, unknown> = {};
+		for (const { fieldSlug } of collectionRows) {
+			if (!fieldSlug) continue;
+			if (previous) {
+				if (!sameStoredValue(previous[fieldSlug], data[fieldSlug])) {
+					values[fieldSlug] = data[fieldSlug] ?? null;
+				}
+			} else if (fieldSlug in data) {
+				values[fieldSlug] = data[fieldSlug];
+			}
+		}
+		if (Object.keys(values).length === 0) return;
+
+		const supportsRaw = collectionRows[0]?.supports;
+		const supports: unknown = supportsRaw ? JSON.parse(supportsRaw) : [];
+		const usesRevisions = Array.isArray(supports) && supports.includes("revisions");
+
+		const siblings = await sql<Record<string, unknown>>`
+			SELECT * FROM ${sql.ref(tableName)}
+			WHERE translation_group = ${translationGroup}
+			AND id != ${sourceId}
+		`.execute(this.db);
+
+		let changed = false;
+		for (const row of siblings.rows) {
+			if (await this.syncSiblingValues(type, this.mapRow(type, row), values, usesRevisions)) {
+				changed = true;
+			}
+		}
+		if (changed) invalidateCollectionCache(type);
+	}
+
+	private async syncSiblingValues(
+		type: string,
+		initial: ContentItem,
+		values: Record<string, unknown>,
+		usesRevisions: boolean,
+	): Promise<boolean> {
+		const tableName = getTableName(type);
+		const revisionRepo = new RevisionRepository(this.db);
+		let sibling: ContentItem | null = initial;
+
+		for (let attempt = 0; sibling && attempt < MAX_DRAFT_STAGE_ATTEMPTS; attempt++) {
+			const current: ContentItem = sibling;
+			const changed: Record<string, unknown> = {};
+			for (const [field, value] of Object.entries(values)) {
+				if (!sameStoredValue(current.data[field], value)) changed[field] = value;
+			}
+			if (Object.keys(changed).length === 0) return false;
+
+			const assignments: ReturnType<typeof sql>[] = [];
+			for (const [field, value] of Object.entries(changed)) {
+				validateIdentifier(field, "content field name");
+				assignments.push(sql`${sql.ref(field)} = ${serializeValue(value)}`);
+			}
+
+			const createdRevisionIds: string[] = [];
+			const cleanUp = async () => {
+				for (const revisionId of createdRevisionIds) {
+					await this.deleteUnstagedRevision(revisionRepo, type, current.id, revisionId);
+				}
+			};
+
+			let synced: boolean;
+			try {
+				const live =
+					usesRevisions && current.liveRevisionId
+						? await revisionRepo.findById(current.liveRevisionId)
+						: null;
+				if (live) {
+					const revision = await revisionRepo.create({
+						collection: type,
+						entryId: current.id,
+						data: { ...live.data, ...changed },
+					});
+					createdRevisionIds.push(revision.id);
+					assignments.push(sql`live_revision_id = ${revision.id}`);
+				}
+
+				const draft =
+					usesRevisions && current.draftRevisionId
+						? await revisionRepo.findById(current.draftRevisionId)
+						: null;
+				const carried: Record<string, unknown> = {};
+				for (const [field, value] of Object.entries(changed)) {
+					if (draft && sameStoredValue(draft.data[field], current.data[field])) {
+						carried[field] = value;
+					}
+				}
+				if (draft && Object.keys(carried).length > 0) {
+					const revision = await revisionRepo.create({
+						collection: type,
+						entryId: current.id,
+						data: { ...draft.data, ...carried },
+					});
+					createdRevisionIds.push(revision.id);
+					assignments.push(sql`draft_revision_id = ${revision.id}`);
+				}
+
+				assignments.push(sql`updated_at = ${new Date().toISOString()}`, sql`version = version + 1`);
+				const result = await sql`
+					UPDATE ${sql.ref(tableName)}
+					SET ${sql.join(assignments, sql`, `)}
+					WHERE id = ${current.id}
+					AND version = ${current.version}
+					AND ${nullableColumnMatch("live_revision_id", current.liveRevisionId)}
+					AND ${nullableColumnMatch("draft_revision_id", current.draftRevisionId)}
+				`.execute(this.db);
+				synced = (result.numAffectedRows ?? 0n) > 0n;
+			} catch (error) {
+				await cleanUp();
+				throw error;
+			}
+
+			if (synced) return true;
+			await cleanUp();
+			sibling = await this.findByIdIncludingTrashed(type, current.id);
+		}
+
+		if (!sibling) return false;
+		throw new ContentMutationConflictError();
+	}
+
 	/**
 	 * Delete content (soft delete - moves to trash)
 	 */
@@ -1129,7 +1304,7 @@ export class ContentRepository {
 	 */
 	async findTrashed(
 		type: string,
-		options: Omit<FindManyOptions, "where"> = {},
+		options: Omit<FindManyOptions, "where"> & { where?: { locale?: string } } = {},
 	): Promise<FindManyResult<ContentItem & { deletedAt: string }>> {
 		const tableName = getTableName(type);
 		const limit = Math.min(options.limit || 50, 100);
@@ -1146,6 +1321,10 @@ export class ContentRepository {
 			.selectAll()
 			.where("deleted_at" as never, "is not", null);
 
+		if (options.where?.locale) {
+			query = query.where("locale" as any, "=", options.where.locale);
+		}
+
 		// Handle cursor pagination — decodeCursor throws on invalid input.
 		if (options.cursor) {
 			const { orderValue, id: cursorId } = decodeCursor(options.cursor);
@@ -1202,14 +1381,19 @@ export class ContentRepository {
 	/**
 	 * Count trashed content items
 	 */
-	async countTrashed(type: string): Promise<number> {
+	async countTrashed(type: string, options: { locale?: string } = {}): Promise<number> {
 		const tableName = getTableName(type);
 
-		const result = await this.db
+		let query = this.db
 			.selectFrom(tableName as keyof Database)
 			.select((eb) => eb.fn.count("id").as("count"))
-			.where("deleted_at" as never, "is not", null)
-			.executeTakeFirst();
+			.where("deleted_at" as never, "is not", null);
+
+		if (options.locale) {
+			query = query.where("locale" as any, "=", options.locale);
+		}
+
+		const result = await query.executeTakeFirst();
 
 		return Number(result?.count || 0);
 	}
@@ -1527,10 +1711,11 @@ export class ContentRepository {
 		// transition to 'scheduled' so they aren't visible before the time.
 		const newStatus = existing.status === "published" ? "published" : "scheduled";
 
+		// The due query compares ISO strings, so every stored schedule uses the same UTC form.
 		await sql`
 			UPDATE ${sql.ref(tableName)}
 			SET status = ${newStatus},
-				scheduled_at = ${scheduledAt},
+				scheduled_at = ${scheduledDate.toISOString()},
 				updated_at = ${now}
 			WHERE id = ${id}
 			AND deleted_at IS NULL
@@ -1636,6 +1821,19 @@ export class ContentRepository {
 		return result.rows.map((row) => this.mapRow(type, row));
 	}
 
+	/** Whether any row of `translationGroup` exists, trashed rows included. */
+	async hasTranslationsIncludingTrashed(type: string, translationGroup: string): Promise<boolean> {
+		const tableName = getTableName(type);
+
+		const result = await sql<Record<string, unknown>>`
+			SELECT id FROM ${sql.ref(tableName)}
+			WHERE translation_group = ${translationGroup}
+			LIMIT 1
+		`.execute(this.db);
+
+		return result.rows.length > 0;
+	}
+
 	/**
 	 * Batch variant of {@link findTranslations}: every (non-deleted) locale
 	 * variant for any of `translationGroups`, in one `WHERE translation_group IN
@@ -1777,6 +1975,7 @@ export class ContentRepository {
 		expectedScheduledAt?: string,
 		promoteRevision = true,
 		requireSlug = true,
+		expectedRevision?: ContentRevisionPrecondition,
 	): Promise<ContentItem> {
 		const tableName = getTableName(type);
 		const now = new Date().toISOString();
@@ -1785,6 +1984,7 @@ export class ContentRepository {
 		if (!existing) {
 			throw new EmDashValidationError("Content item not found");
 		}
+		assertRevisionPrecondition(existing, expectedRevision);
 		if (
 			requireDue &&
 			expectedScheduledAt !== undefined &&
@@ -1829,6 +2029,7 @@ export class ContentRepository {
 						WHERE id = ${id}
 						AND deleted_at IS NULL
 						AND version = ${existing.version}
+						AND updated_at = ${existing.updatedAt}
 						AND status = ${existing.status}
 						AND ${nullableColumnMatch("live_revision_id", existing.liveRevisionId)}
 						AND ${nullableColumnMatch("draft_revision_id", existing.draftRevisionId)}
@@ -1954,6 +2155,7 @@ export class ContentRepository {
 					WHERE id = ${id}
 					AND deleted_at IS NULL
 					AND version = ${existing.version}
+					AND updated_at = ${existing.updatedAt}
 					AND status = ${existing.status}
 					AND ${nullableColumnMatch("live_revision_id", existing.liveRevisionId)}
 					AND ${nullableColumnMatch("draft_revision_id", existing.draftRevisionId)}
@@ -2028,10 +2230,14 @@ export class ContentRepository {
 	/**
 	 * Unpublish content
 	 *
-	 * Removes live pointer but preserves draft. If no draft exists,
-	 * creates one from the live version so the content isn't lost.
+	 * Removes live pointer but preserves the draft and publication date. If no
+	 * draft exists, creates one from the live version so the content isn't lost.
 	 */
-	async unpublish(type: string, id: string): Promise<ContentItem> {
+	async unpublish(
+		type: string,
+		id: string,
+		expectedRevision?: ContentRevisionPrecondition,
+	): Promise<ContentItem> {
 		const tableName = getTableName(type);
 		const now = new Date().toISOString();
 
@@ -2039,44 +2245,61 @@ export class ContentRepository {
 		if (!existing) {
 			throw new EmDashValidationError("Content item not found");
 		}
+		assertRevisionPrecondition(existing, expectedRevision);
+		if (existing.status === "draft" && !existing.liveRevisionId) return existing;
 
-		// If no draft exists, create one from the live version
-		if (!existing.draftRevisionId && existing.liveRevisionId) {
-			const revisionRepo = new RevisionRepository(this.db);
-			const liveRevision = await revisionRepo.findById(existing.liveRevisionId);
-			if (liveRevision) {
-				const draft = await revisionRepo.create({
-					collection: type,
-					entryId: id,
-					data: liveRevision.data,
-				});
-
-				await sql`
-					UPDATE ${sql.ref(tableName)}
-					SET draft_revision_id = ${draft.id}
-					WHERE id = ${id}
-				`.execute(this.db);
+		const revisionRepo = new RevisionRepository(this.db);
+		let provisionalRevisionId: string | null = null;
+		try {
+			let draftRevisionId = existing.draftRevisionId;
+			if (!draftRevisionId && existing.liveRevisionId) {
+				const liveRevision = await revisionRepo.findById(existing.liveRevisionId);
+				if (liveRevision) {
+					const draft = await revisionRepo.create({
+						collection: type,
+						entryId: id,
+						data: liveRevision.data,
+					});
+					draftRevisionId = draft.id;
+					provisionalRevisionId = draft.id;
+				}
 			}
-		}
 
-		await sql`
-			UPDATE ${sql.ref(tableName)}
-			SET live_revision_id = NULL,
-				status = 'draft',
-				published_at = NULL,
-				updated_at = ${now}
-			WHERE id = ${id}
-			AND deleted_at IS NULL
-		`.execute(this.db);
+			const result = await sql`
+				UPDATE ${sql.ref(tableName)}
+				SET live_revision_id = NULL,
+					draft_revision_id = ${draftRevisionId},
+					status = 'draft',
+					updated_at = ${now},
+					version = version + 1
+				WHERE id = ${id}
+				AND deleted_at IS NULL
+				AND version = ${existing.version}
+				AND updated_at = ${existing.updatedAt}
+				AND status = ${existing.status}
+				AND ${nullableColumnMatch("live_revision_id", existing.liveRevisionId)}
+				AND ${nullableColumnMatch("draft_revision_id", existing.draftRevisionId)}
+				AND ${nullableColumnMatch("scheduled_at", existing.scheduledAt)}
+			`.execute(this.db);
+			if ((result.numAffectedRows ?? 0n) === 0n) throw new ContentMutationConflictError();
 
-		invalidateCollectionCache(type);
-
-		const updated = await this.findById(type, id);
-		if (!updated) {
-			throw new Error("Content not found");
+			invalidateCollectionCache(type);
+			const updated = await this.findById(type, id);
+			if (!updated) throw new Error("Content not found");
+			return updated;
+		} catch (error) {
+			if (provisionalRevisionId) {
+				try {
+					await revisionRepo.deleteIfUnreferenced(type, id, provisionalRevisionId);
+				} catch (cleanupError) {
+					console.error(
+						`[content] Failed to clean up provisional revision ${provisionalRevisionId}:`,
+						cleanupError,
+					);
+				}
+			}
+			throw error;
 		}
-
-		return updated;
 	}
 
 	/**
@@ -2143,13 +2366,18 @@ export class ContentRepository {
 	 * Clears draft_revision_id. The content table columns already hold the
 	 * published version, so no data sync is needed.
 	 */
-	async discardDraft(type: string, id: string): Promise<ContentItem> {
+	async discardDraft(
+		type: string,
+		id: string,
+		expectedRevision?: ContentRevisionPrecondition,
+	): Promise<ContentItem> {
 		const tableName = getTableName(type);
 
 		const existing = await this.findById(type, id);
 		if (!existing) {
 			throw new EmDashValidationError("Content item not found");
 		}
+		assertRevisionPrecondition(existing, expectedRevision);
 
 		if (!existing.draftRevisionId) {
 			// No draft to discard
@@ -2159,12 +2387,20 @@ export class ContentRepository {
 		// Discarding a draft restores the state from before the draft was
 		// staged — nothing about the live entry changed in between, so
 		// updated_at stays at its pre-draft value (#2143).
-		await sql`
+		const result = await sql`
 			UPDATE ${sql.ref(tableName)}
-			SET draft_revision_id = NULL
+			SET draft_revision_id = NULL,
+				version = version + 1
 			WHERE id = ${id}
 			AND deleted_at IS NULL
+			AND version = ${existing.version}
+			AND updated_at = ${existing.updatedAt}
+			AND status = ${existing.status}
+			AND ${nullableColumnMatch("live_revision_id", existing.liveRevisionId)}
+			AND ${nullableColumnMatch("draft_revision_id", existing.draftRevisionId)}
+			AND ${nullableColumnMatch("scheduled_at", existing.scheduledAt)}
 		`.execute(this.db);
+		if ((result.numAffectedRows ?? 0n) === 0n) throw new ContentMutationConflictError();
 
 		const updated = await this.findById(type, id);
 		if (!updated) {