emdash 1.3.0 → 1.4.0

package/src/components/inline-image.tsx

@@ -395,6 +395,7 @@ export function InlineImageToolbar({
 	const [shown, setShown] = React.useState(false);
 	const [draft, setDraft] = React.useState("");
 	const menuRef = React.useRef<HTMLDivElement>(null);
+	const surfaceRef = React.useRef<HTMLDivElement>(null);
 	const replaceRef = React.useRef<HTMLButtonElement>(null);
 	const hiddenAtRef = React.useRef(Number.NEGATIVE_INFINITY);
 	const image = useEditorState({
@@ -449,7 +450,7 @@ export function InlineImageToolbar({
 			onShow: () => {
 				setShown(true);
 				if (performance.now() - hiddenAtRef.current > RESHOW_WITHOUT_ENTRANCE_MS) {
-					playToolbarEntrance(menuRef.current?.firstElementChild);
+					playToolbarEntrance(surfaceRef.current);
 				}
 			},
 			onHide: () => {
@@ -517,7 +518,7 @@ export function InlineImageToolbar({
 			menuRef.current?.contains(activeElement) ||
 			activeElement?.closest(`[${TOOLBAR_POPUP_ATTR}]`)
 		) {
-			menuRef.current?.focus({ preventScroll: true });
+			surfaceRef.current?.focus({ preventScroll: true });
 		}
 		setReplacing(false);
 		setDraft(image.alt);
@@ -562,54 +563,59 @@ export function InlineImageToolbar({
 				updateDelay={0}
 				options={options}
 				shouldShow={shouldShow}
-				role="toolbar"
-				aria-label="Image controls"
-				className="emdash-inline-ui-bar emdash-image-bubble-menu"
-				onMouseDown={() => {
-					// TipTap skips the editor's next blur after a press on its toolbar. With
-					// focus in the caption or the toolbar, no such blur comes to use that up,
-					// and the one that hides the toolbar later would be skipped instead.
-					if (!editor.view.hasFocus()) {
-						editor.view.dispatch(
-							editor.state.tr.setMeta("blur", { event: { relatedTarget: menuRef.current } }),
-						);
-					}
-				}}
-				onKeyDown={onKeyDown}
 			>
-				<ToolbarShownContext.Provider value={shown}>
-					<ToolbarTooltipGroup>
-						{mode === "alt" ? (
-							<AltTextField
-								value={draft}
-								onChange={setDraft}
-								onSave={saveAlt}
-								onCancel={backToEditor}
-							/>
-						) : (
-							<>
-								<ToolbarTextButton
-									label="Replace"
-									icon={<ImageSquare aria-hidden="true" />}
-									expanded={replacing}
-									buttonRef={replaceRef}
-									onClick={() => (replacing ? closeReplace() : setReplacing(true))}
-								/>
-								<ToolbarTextButton
-									label="Alt text"
-									icon={<TextAa aria-hidden="true" />}
-									pressed={described}
-									tooltip={described ? image.alt.trim() : "No description yet"}
-									onClick={editAlt}
+				<div
+					ref={surfaceRef}
+					tabIndex={-1}
+					role="toolbar"
+					aria-label="Image controls"
+					className="emdash-inline-ui-bar emdash-image-bubble-menu"
+					onMouseDown={() => {
+						// TipTap skips the editor's next blur after a press on its toolbar. With
+						// focus in the caption or the toolbar, no such blur comes to use that up,
+						// and the one that hides the toolbar later would be skipped instead.
+						if (!editor.view.hasFocus()) {
+							editor.view.dispatch(
+								editor.state.tr.setMeta("blur", { event: { relatedTarget: surfaceRef.current } }),
+							);
+						}
+					}}
+					onKeyDown={onKeyDown}
+				>
+					<ToolbarShownContext.Provider value={shown}>
+						<ToolbarTooltipGroup>
+							{mode === "alt" ? (
+								<AltTextField
+									value={draft}
+									onChange={setDraft}
+									onSave={saveAlt}
+									onCancel={backToEditor}
 								/>
-								<ToolbarSeparator />
-								<ToolbarButton label="Delete image" onClick={remove}>
-									<Trash />
-								</ToolbarButton>
-							</>
-						)}
-					</ToolbarTooltipGroup>
-				</ToolbarShownContext.Provider>
+							) : (
+								<>
+									<ToolbarTextButton
+										label="Replace"
+										icon={<ImageSquare aria-hidden="true" />}
+										expanded={replacing}
+										buttonRef={replaceRef}
+										onClick={() => (replacing ? closeReplace() : setReplacing(true))}
+									/>
+									<ToolbarTextButton
+										label="Alt text"
+										icon={<TextAa aria-hidden="true" />}
+										pressed={described}
+										tooltip={described ? image.alt.trim() : "No description yet"}
+										onClick={editAlt}
+									/>
+									<ToolbarSeparator />
+									<ToolbarButton label="Delete image" onClick={remove}>
+										<Trash />
+									</ToolbarButton>
+								</>
+							)}
+						</ToolbarTooltipGroup>
+					</ToolbarShownContext.Provider>
+				</div>
 			</BubbleMenu>
 			{replacing && image.position !== null && (
 				<InlineMediaPicker

package/src/database/dialect-helpers.ts

@@ -67,6 +67,15 @@ export interface AtomicBatchAdapter {
 	executeAtomicBatch(queries: readonly CompiledQuery[]): Promise<readonly QueryResult<unknown>[]>;
 }
 
+function isAtomicBatchAdapter(adapter: object): adapter is AtomicBatchAdapter {
+	return "executeAtomicBatch" in adapter && typeof adapter.executeAtomicBatch === "function";
+}
+
+/** Whether `executeAtomicBatchIfSupported` runs a batch on this database. */
+export function supportsAtomicBatch<DB>(db: Kysely<DB>): boolean {
+	return isAtomicBatchAdapter(db.getExecutor().adapter);
+}
+
 /**
  * Execute a fixed statement list atomically when the active adapter supports
  * it. Returns `null` for adapters that should use an ordinary transaction.
@@ -76,9 +85,7 @@ export async function executeAtomicBatchIfSupported<DB>(
 	queries: readonly (Compilable | RawBuilder<unknown>)[],
 ): Promise<readonly QueryResult<unknown>[] | null> {
 	const adapter: object = db.getExecutor().adapter;
-	if (!("executeAtomicBatch" in adapter) || typeof adapter.executeAtomicBatch !== "function") {
-		return null;
-	}
+	if (!isAtomicBatchAdapter(adapter)) return null;
 
 	return adapter.executeAtomicBatch(
 		queries.map((query) => ("isRawBuilder" in query ? query.compile(db) : query.compile())),

package/src/database/migrations/content-sized.ts

@@ -0,0 +1,82 @@
+import { sql, type Kysely, type RawBuilder } from "kysely";
+
+import { isMissingTableError } from "../../utils/db-errors.js";
+import type { Database } from "../types.js";
+import { validateIdentifier } from "../validate.js";
+
+/**
+ * A migration whose work grows with the site's content. A caller that cannot
+ * finish a long run, such as auto mode inside a Worker request, compares the
+ * row count with its limit before it takes the migration lock.
+ */
+export interface ContentSizedMigration {
+	/**
+	 * Counts the rows the migration writes, with rows it only reads weighted by
+	 * their share of a statement. Stops once `cap` is reached.
+	 */
+	countRows(db: Kysely<Database>, cap: number): Promise<number>;
+}
+
+async function countCapped(
+	db: Kysely<Database>,
+	rows: RawBuilder<unknown>,
+	cap: number,
+): Promise<number> {
+	try {
+		const result = await sql<{ count: number | string | bigint }>`
+			SELECT COUNT(*) AS count FROM (${rows} LIMIT ${cap}) AS capped
+		`.execute(db);
+		return Number(result.rows[0]?.count ?? 0);
+	} catch (error) {
+		if (isMissingTableError(error)) return 0;
+		throw error;
+	}
+}
+
+const DATETIME_COLLECTIONS = sql`
+	SELECT collection.slug FROM _emdash_collections AS collection
+	INNER JOIN _emdash_fields AS field ON field.collection_id = collection.id
+	WHERE field.type IN ('datetime', 'repeater')
+`;
+
+/**
+ * 079 can update every content entry, and every revision of a collection with
+ * datetime or repeater fields, one statement each. It only reads the other
+ * revisions, 50 per statement in each of its three passes, so about 16 of them
+ * cost what one written row does.
+ */
+const READ_ONLY_REVISIONS_PER_ROW = 16;
+
+async function countDatetimeNormalizationRows(db: Kysely<Database>, cap: number): Promise<number> {
+	let slugs: string[];
+	try {
+		const collections = await db.selectFrom("_emdash_collections").select("slug").execute();
+		slugs = collections.map((collection) => collection.slug);
+	} catch (error) {
+		if (isMissingTableError(error)) return 0;
+		throw error;
+	}
+	let rows = await countCapped(
+		db,
+		sql`SELECT 1 FROM revisions WHERE collection IN (${DATETIME_COLLECTIONS})`,
+		cap,
+	);
+	for (const slug of slugs) {
+		if (rows >= cap) return rows;
+		validateIdentifier(slug, "collection slug");
+		// oxlint-disable-next-line no-await-in-loop -- each count is capped by what the previous ones left
+		rows += await countCapped(db, sql`SELECT 1 FROM ${sql.ref(`ec_${slug}`)}`, cap - rows);
+	}
+	if (rows >= cap) return rows;
+	const readOnly = await countCapped(
+		db,
+		sql`SELECT 1 FROM revisions WHERE collection NOT IN (${DATETIME_COLLECTIONS})`,
+		(cap - rows) * READ_ONLY_REVISIONS_PER_ROW,
+	);
+	return rows + Math.ceil(readOnly / READ_ONLY_REVISIONS_PER_ROW);
+}
+
+/** Keyed by migration name, since a published migration's module must not change. */
+export const CONTENT_SIZED_MIGRATIONS: ReadonlyMap<string, ContentSizedMigration> = new Map([
+	["079_datetime_normalization", { countRows: countDatetimeNormalizationRows }],
+]);

package/src/database/migrations/policy.ts

@@ -1,7 +1,12 @@
 import type { Kysely } from "kysely";
 
 import type { Database } from "../types.js";
-import { getExactMigrationStatus, runMigrations } from "./runner.js";
+import {
+	getExactMigrationStatus,
+	MigrationLockHeldError,
+	MigrationRowLimitError,
+	runMigrations,
+} from "./runner.js";
 
 export type RuntimeMigrationMode = "auto" | "check" | "manual";
 
@@ -53,13 +58,34 @@ export class PendingMigrationsError extends Error {
 	}
 }
 
+/**
+ * Whether a runtime init error leaves the database waiting for migrations that
+ * this request cannot apply. A backed-off init carries the original error as
+ * its cause.
+ */
+export function isMigrationRequiredError(error: unknown): boolean {
+	const cause = error instanceof Error ? error.cause : undefined;
+	return [error, cause].some(
+		(candidate) =>
+			candidate instanceof PendingMigrationsError ||
+			candidate instanceof MigrationLockHeldError ||
+			candidate instanceof MigrationRowLimitError,
+	);
+}
+
+export interface RuntimeMigrationPolicyOptions {
+	/** In auto mode, see `MigrationOptions.contentRowLimit`. */
+	contentRowLimit?: number;
+}
+
 export async function enforceRuntimeMigrationPolicy(
 	db: Kysely<Database>,
 	mode: RuntimeMigrationMode,
+	options: RuntimeMigrationPolicyOptions = {},
 ): Promise<void> {
 	if (mode === "manual") return;
 	if (mode === "auto") {
-		await runMigrations(db);
+		await runMigrations(db, { contentRowLimit: options.contentRowLimit });
 		return;
 	}
 

package/src/database/migrations/runner.ts

@@ -99,6 +99,7 @@ import * as m088 from "./088_cron_oneshot_utc.js";
 import * as m089 from "./089_auto_seed_completion.js";
 import * as m090 from "./090_redirect_enable_loop_guard.js";
 import * as m091 from "./091_redirect_artifacts.js";
+import { CONTENT_SIZED_MIGRATIONS } from "./content-sized.js";
 
 const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"001_initial": m001,
@@ -265,6 +266,27 @@ export class MigrationFailedError extends Error {
 	}
 }
 
+/**
+ * Thrown before the migration lock is taken when the pending content-sized
+ * migrations process more rows than the caller's `contentRowLimit`. Nothing
+ * has been applied; `emdash migrate` applies them outside a request.
+ */
+export class MigrationRowLimitError extends Error {
+	readonly migrations: string[];
+	readonly rowLimit: number;
+
+	constructor(migrations: readonly string[], rowLimit: number) {
+		super(
+			`Pending migration ${migrations.join(", ")} processes more than ${rowLimit} content rows, ` +
+				"too many to apply while serving a request. Apply it with `emdash migrate`: " +
+				"https://docs.emdashcms.com/deployment/core-migrations/#apply-large-content-migrations-from-the-cli",
+		);
+		this.name = "MigrationRowLimitError";
+		this.migrations = [...migrations];
+		this.rowLimit = rowLimit;
+	}
+}
+
 /** Custom migration table name */
 const MIGRATION_TABLE = "_emdash_migrations";
 
@@ -276,6 +298,11 @@ export interface MigrationOptions {
 	 * give-up path doesn't take 10 seconds per case.
 	 */
 	raceWaitMs?: number;
+	/**
+	 * Refuse with MigrationRowLimitError, before taking the migration lock, when
+	 * the pending content-sized migrations process more rows than this.
+	 */
+	contentRowLimit?: number;
 }
 
 export function createMigrator(db: Kysely<Database>, options?: MigrationOptions): Migrator {
@@ -486,6 +513,23 @@ export async function getExactMigrationStatus(
 	return { knownApplied, pending, unknownApplied };
 }
 
+async function assertWithinContentRowLimit(
+	db: Kysely<Database>,
+	rowLimit: number,
+	options: MigrationOptions | undefined,
+): Promise<void> {
+	const { pending } = await getExactMigrationStatus(db, options);
+	const sized = pending.filter((name) => CONTENT_SIZED_MIGRATIONS.has(name));
+	let rows = 0;
+	for (const name of sized) {
+		const migration = CONTENT_SIZED_MIGRATIONS.get(name);
+		if (!migration) continue;
+		// oxlint-disable-next-line no-await-in-loop -- each count is capped by what the previous ones left
+		rows += await migration.countRows(db, rowLimit + 1 - rows);
+		if (rows > rowLimit) throw new MigrationRowLimitError(sized, rowLimit);
+	}
+}
+
 /**
  * Run all pending migrations.
  *
@@ -524,6 +568,10 @@ export async function runMigrations(
 		}
 	}
 
+	if (options?.contentRowLimit !== undefined) {
+		await assertWithinContentRowLimit(db, options.contentRowLimit, options);
+	}
+
 	const migrator = createMigrator(db, options);
 
 	const { error, results } = await migrator.migrateToLatest();

package/src/database/repositories/byline.ts

@@ -2,6 +2,8 @@ import { sql, type Kysely, type Selectable } from "kysely";
 import { ulid } from "ulidx";
 
 import { getBylineFieldDefs } from "../../bylines/field-defs-cache.js";
+import { getLocaleRank } from "../../i18n/config.js";
+import { localeMatches, localeOrder } from "../../i18n/query.js";
 import {
 	invalidateBylineObjectCache,
 	invalidateCollectionCache,
@@ -28,6 +30,33 @@ import {
 
 type BylineRow = Selectable<BylineTable>;
 
+type LocalizedBylineRow = {
+	id: string;
+	locale: string;
+	translation_group: string | null;
+	content_id?: string;
+};
+
+function preferLocalizedRows<T extends LocalizedBylineRow>(rows: T[], locale?: string): T[] {
+	if (locale === undefined) return rows;
+	const selected = new Map<string, T>();
+	for (const row of rows) {
+		const key = `${row.content_id ?? ""}:${row.translation_group ?? row.id}`;
+		const existing = selected.get(key);
+		if (
+			!existing ||
+			getLocaleRank(row.locale, locale) < getLocaleRank(existing.locale, locale) ||
+			(getLocaleRank(row.locale, locale) === getLocaleRank(existing.locale, locale) &&
+				row.id < existing.id)
+		) {
+			selected.set(key, row);
+		}
+	}
+	return rows.filter(
+		(row) => selected.get(`${row.content_id ?? ""}:${row.translation_group ?? row.id}`) === row,
+	);
+}
+
 /**
  * A byline row optionally augmented with the avatar's media columns, folded in
  * by the `LEFT JOIN media` in the credit-hydration and single-row finder
@@ -374,21 +403,23 @@ export class BylineRepository {
 		// query covers everything).
 		const translatableByByline = new Map<string, Map<string, string | null>>();
 		const bylineIds = [...new Set(summaries.map((s) => s.id))];
-		for (const chunk of chunks(bylineIds, SQL_BATCH_SIZE)) {
-			const trRows = await this.db
-				.selectFrom("_emdash_byline_field_values")
-				.select(["byline_id", "field_id", "value"])
-				.where("byline_id", "in", chunk)
-				.execute();
-			for (const trRow of trRows) {
-				let fieldMap = translatableByByline.get(trRow.byline_id);
-				if (!fieldMap) {
-					fieldMap = new Map();
-					translatableByByline.set(trRow.byline_id, fieldMap);
+		const loadTranslatable = async () => {
+			for (const chunk of chunks(bylineIds, SQL_BATCH_SIZE)) {
+				const trRows = await this.db
+					.selectFrom("_emdash_byline_field_values")
+					.select(["byline_id", "field_id", "value"])
+					.where("byline_id", "in", chunk)
+					.execute();
+				for (const trRow of trRows) {
+					let fieldMap = translatableByByline.get(trRow.byline_id);
+					if (!fieldMap) {
+						fieldMap = new Map();
+						translatableByByline.set(trRow.byline_id, fieldMap);
+					}
+					fieldMap.set(trRow.field_id, trRow.value);
 				}
-				fieldMap.set(trRow.field_id, trRow.value);
 			}
-		}
+		};
 
 		// Group-shared values, batched over the union of translation_groups,
 		// with per-group request-cache priming so subsequent calls within
@@ -404,7 +435,13 @@ export class BylineRepository {
 					.filter((g): g is string => typeof g === "string" && g.length > 0),
 			),
 		];
-		const groupByGroup = await this.loadGroupValuesByIds(groups);
+		// The two reads are independent, so issue them together. On D1 with
+		// `coalesce` enabled they share one round trip; elsewhere they still
+		// run one after the other.
+		const [, groupByGroup] = await Promise.all([
+			loadTranslatable(),
+			this.loadGroupValuesByIds(groups),
+		]);
 
 		// Each loop gates on `field.translatable` so a row in the wrong
 		// owner table (e.g. left over from a translatable flip) can't
@@ -536,8 +573,15 @@ export class BylineRepository {
 	 */
 	async findBySlug(slug: string, options?: { locale?: string }): Promise<BylineSummary | null> {
 		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();
+		if (options?.locale !== undefined)
+			query = query.where(localeMatches("b.locale", options.locale));
+		const row = await query
+			.orderBy(
+				options?.locale !== undefined ? localeOrder("b.locale", options.locale) : "b.locale",
+				"asc",
+			)
+			.orderBy("b.id", "asc")
+			.executeTakeFirst();
 		return this.withCustomFieldsOne(row);
 	}
 
@@ -549,8 +593,15 @@ export class BylineRepository {
 	 */
 	async findByUserId(userId: string, options?: { locale?: string }): Promise<BylineSummary | null> {
 		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();
+		if (options?.locale !== undefined)
+			query = query.where(localeMatches("b.locale", options.locale));
+		const row = await query
+			.orderBy(
+				options?.locale !== undefined ? localeOrder("b.locale", options.locale) : "b.locale",
+				"asc",
+			)
+			.orderBy("b.id", "asc")
+			.executeTakeFirst();
 		return this.withCustomFieldsOne(row);
 	}
 
@@ -591,7 +642,7 @@ export class BylineRepository {
 		}
 
 		if (options?.locale !== undefined) {
-			query = query.where("locale", "=", options.locale);
+			query = query.where(localeMatches("locale", options.locale));
 		}
 
 		if (options?.cursor) {
@@ -980,9 +1031,10 @@ export class BylineRepository {
 			.where("cb.collection_slug", "=", collectionSlug)
 			.where("cb.content_id", "=", contentId)
 			.orderBy("cb.sort_order", "asc");
-		if (options?.locale !== undefined) query = query.where("b.locale", "=", options.locale);
+		if (options?.locale !== undefined)
+			query = query.where(localeMatches("b.locale", options.locale));
 
-		const rows = await query.execute();
+		const rows = preferLocalizedRows(await query.execute(), options?.locale);
 		// Reconstruct byline rows to feed `withCustomFields`. The JOIN selects
 		// the `BylineRow` columns under the `b.` alias plus the avatar media
 		// columns from the `media` LEFT JOIN; carry both through so
@@ -1120,9 +1172,10 @@ export class BylineRepository {
 				.where("cb.collection_slug", "=", collectionSlug)
 				.where("cb.content_id", "in", chunk)
 				.orderBy("cb.sort_order", "asc");
-			if (options?.locale !== undefined) query = query.where("b.locale", "=", options.locale);
+			if (options?.locale !== undefined)
+				query = query.where(localeMatches("b.locale", options.locale));
 
-			const rows = await query.execute();
+			const rows = preferLocalizedRows(await query.execute(), options?.locale);
 			// Carry the avatar media columns from the LEFT JOIN through the
 			// reshape so `rowToByline` can populate avatarStorageKey/avatarAlt.
 			const bylineRows: BylineRowWithAvatar[] = rows.map((row) => ({
@@ -1224,7 +1277,8 @@ export class BylineRepository {
 					"b.translation_group as translation_group",
 				])
 				.where("b.user_id", "in", chunk);
-			if (options?.locale !== undefined) query = query.where("b.locale", "=", options.locale);
+			if (options?.locale !== undefined)
+				query = query.where(localeMatches("b.locale", options.locale));
 
 			const rows = await query.execute();
 			let bylines: BylineSummary[];
@@ -1239,7 +1293,18 @@ export class BylineRepository {
 				const row = rows[i];
 				const summary = bylines[i];
 				if (!row || !summary || !row.user_id) continue;
-				result.set(row.user_id, summary);
+				const existing = result.get(row.user_id);
+				if (
+					!existing ||
+					options?.locale === undefined ||
+					getLocaleRank(row.locale, options.locale) <
+						getLocaleRank(existing.locale, options.locale) ||
+					(getLocaleRank(row.locale, options.locale) ===
+						getLocaleRank(existing.locale, options.locale) &&
+						row.id < existing.id)
+				) {
+					result.set(row.user_id, summary);
+				}
 			}
 		}
 		return result;
@@ -1341,17 +1406,16 @@ export class BylineRepository {
 		// actually lands in the junction. Deduping by wire row id BEFORE
 		// resolving would let two locale siblings of the same byline slip
 		// through and trigger a UNIQUE(collection, content, byline_id)
-		// failure at insert time. A single SELECT keeps this O(1) DB
-		// calls regardless of how many credits are being set.
+		// failure at insert time.
 		const idToGroup = new Map<string, string>();
-		if (inputBylines.length > 0) {
-			const wireIds = [...new Set(inputBylines.map((item) => item.bylineId))];
+		const wireIds = [...new Set(inputBylines.map((item) => item.bylineId))];
+		for (const batch of chunks(wireIds, SQL_BATCH_SIZE)) {
 			const rows = await this.db
 				.selectFrom("_emdash_bylines")
 				.select(["id", "translation_group"])
-				.where("id", "in", wireIds)
+				.where("id", "in", batch)
 				.execute();
-			if (rows.length !== wireIds.length) {
+			if (rows.length !== batch.length) {
 				throw new Error("One or more byline IDs do not exist");
 			}
 			for (const row of rows) {

package/src/database/repositories/comment.ts

@@ -2,6 +2,8 @@ import { sql, type ExpressionBuilder, type Kysely } from "kysely";
 import { ulid } from "ulidx";
 
 import { invalidateCommentObjectCache } from "../../object-cache/index.js";
+import { chunks, SQL_BATCH_SIZE } from "../../utils/chunks.js";
+import { withTransaction } from "../transaction.js";
 import type { Database } from "../types.js";
 import { encodeCursor, decodeCursor, type FindManyResult } from "./types.js";
 
@@ -354,14 +356,22 @@ export class CommentRepository {
 
 		const now = new Date().toISOString();
 
-		const result = await this.db
-			.updateTable("_emdash_comments")
-			.set({ status, updated_at: now })
-			.where("id", "in", ids)
-			.executeTakeFirst();
-
+		const updatedCount = await withTransaction(this.db, async (db) => {
+			let updated = 0;
+			for (const batch of chunks([...new Set(ids)], SQL_BATCH_SIZE)) {
+				const result = await db
+					.updateTable("_emdash_comments")
+					.set({ status, updated_at: now })
+					.where("id", "in", batch)
+					.executeTakeFirst();
+
+				if (!db.isTransaction) invalidateCommentObjectCache();
+				updated += Number(result.numUpdatedRows ?? 0);
+			}
+			return updated;
+		});
 		invalidateCommentObjectCache();
-		return Number(result.numUpdatedRows ?? 0);
+		return updatedCount;
 	}
 
 	/**