emdash 0.35.0 → 0.37.0

package/src/media/usage/content-refresh.ts

@@ -2,17 +2,24 @@ import { sql, type Kysely } from "kysely";
 
 import { tableExists } from "../../database/dialect-helpers.js";
 import {
+	type MediaUsageExistingSourceProjection,
 	MediaUsageRepository,
+	type MediaUsageNewSourceProjection,
 	type MediaUsageSource,
 } from "../../database/repositories/media-usage.js";
 import type { Database } from "../../database/types.js";
 import { validateIdentifier } from "../../database/validate.js";
 import { isI18nEnabled } from "../../i18n/config.js";
-import { loadContentMediaUsageFields } from "./content-fields.js";
+import {
+	loadContentMediaUsageFields,
+	type ContentMediaUsageFieldDiscovery,
+} from "./content-fields.js";
 import {
 	CONTENT_SOURCE_SCHEMA_VERSION,
 	loadContentMediaUsageSnapshots,
+	loadContentMediaUsageSnapshotsBatch,
 	type ContentMediaUsageSnapshot,
+	type LoadContentMediaUsageSnapshotsResult,
 } from "./content-snapshots.js";
 import {
 	buildContentMediaUsageSourceKey,
@@ -27,8 +34,11 @@ const CONTENT_USAGE_COLLECTION_LOCKS_KEY = Symbol.for("emdash.mediaUsage.collect
 const CONTENT_USAGE_REFRESH_MAX_ATTEMPTS = 2;
 
 export const MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS = Object.freeze({
-	maxOccurrenceMutationUnitsPerClaim: 12,
-	maxProjectionMutationBytesPerClaim: 512 * 1024,
+	maxOccurrenceMutationUnitsPerClaim: 500,
+	maxProjectionMutationBytesPerVariant: 2_000_000,
+	maxProjectionMutationBytesPerClaim: 4_000_000,
+	maxOccurrenceMutationUnitsPerBatch: 50_000,
+	maxProjectionMutationBytesPerBatch: 16_000_000,
 });
 
 export interface ContentMediaUsageAdmissionBudget {
@@ -66,6 +76,9 @@ interface ContentMediaUsageRefreshOptions {
 	collectionId?: string;
 	durableWork?: boolean;
 	admissionBudget?: ContentMediaUsageAdmissionBudget;
+	fieldDiscovery?: ContentMediaUsageFieldDiscovery;
+	observedSources?: ReadonlyMap<string, MediaUsageSource>;
+	snapshotsResult?: LoadContentMediaUsageSnapshotsResult;
 }
 
 export interface ContentMediaUsageRefreshResult {
@@ -83,11 +96,18 @@ const ZERO_RESULT: ContentMediaUsageRefreshResult = {
 	failedSourceCount: 0,
 };
 
-export function createContentMediaUsageAdmissionBudget(): ContentMediaUsageAdmissionBudget {
+export function createContentMediaUsageAdmissionBudget(
+	limits: {
+		maxOccurrenceMutationUnits?: number;
+		maxProjectionMutationBytes?: number;
+	} = {},
+): ContentMediaUsageAdmissionBudget {
 	return {
 		remainingOccurrenceMutationUnits:
+			limits.maxOccurrenceMutationUnits ??
 			MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxOccurrenceMutationUnitsPerClaim,
 		remainingProjectionMutationBytes:
+			limits.maxProjectionMutationBytes ??
 			MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxProjectionMutationBytesPerClaim,
 		hasReservedMutation: false,
 	};
@@ -107,6 +127,7 @@ export async function planContentMediaUsageProjectionAdmission(
 		.filter((source): source is MediaUsageSource => source !== undefined);
 	let deletionOccurrenceUnits = 0;
 	let deletionBytes = 0;
+	let largestDeletionBytes = 0;
 	for (const source of absentSources) {
 		const measurement = await repo.measureSourceGenerationDeletion(
 			source.sourceKey,
@@ -119,7 +140,10 @@ export async function planContentMediaUsageProjectionAdmission(
 				: { outcome: "intrinsic_resource_limit" };
 		}
 		deletionOccurrenceUnits += measurement.occurrenceCount;
-		deletionBytes += storedMediaUsageSourceByteLength(source) + measurement.occurrenceBytes * 2;
+		const sourceDeletionBytes =
+			storedMediaUsageSourceByteLength(source) + measurement.occurrenceBytes * 2;
+		deletionBytes += sourceDeletionBytes;
+		largestDeletionBytes = Math.max(largestDeletionBytes, sourceDeletionBytes);
 	}
 
 	const noOpSourceKeys = new Set<string>();
@@ -128,6 +152,7 @@ export async function planContentMediaUsageProjectionAdmission(
 		noOpSourceKeys,
 		deletionOccurrenceUnits,
 		deletionBytes,
+		largestDeletionBytes,
 	);
 	if (exceedsProjectionAdmissionLimits(cost)) {
 		for (const snapshot of snapshots) {
@@ -144,6 +169,7 @@ export async function planContentMediaUsageProjectionAdmission(
 			noOpSourceKeys,
 			deletionOccurrenceUnits,
 			deletionBytes,
+			largestDeletionBytes,
 		);
 	}
 
@@ -175,6 +201,7 @@ export async function planContentMediaUsageProjectionAdmission(
 interface ProjectionAdmissionCost {
 	occurrenceMutationUnits: number;
 	projectionMutationBytes: number;
+	largestProjectionMutationBytes: number;
 }
 
 function projectionAdmissionCost(
@@ -182,17 +209,23 @@ function projectionAdmissionCost(
 	noOpSourceKeys: ReadonlySet<string>,
 	deletionOccurrenceUnits: number,
 	deletionBytes: number,
+	largestDeletionBytes: number,
 ): ProjectionAdmissionCost {
 	return snapshots.reduce<ProjectionAdmissionCost>(
 		(cost, snapshot) => {
 			if (noOpSourceKeys.has(snapshot.source.sourceKey)) return cost;
 			cost.occurrenceMutationUnits += snapshot.occurrences.length;
 			cost.projectionMutationBytes += snapshot.projectionByteLength;
+			cost.largestProjectionMutationBytes = Math.max(
+				cost.largestProjectionMutationBytes,
+				snapshot.projectionByteLength,
+			);
 			return cost;
 		},
 		{
 			occurrenceMutationUnits: deletionOccurrenceUnits,
 			projectionMutationBytes: deletionBytes,
+			largestProjectionMutationBytes: largestDeletionBytes,
 		},
 	);
 }
@@ -201,6 +234,8 @@ function exceedsProjectionAdmissionLimits(cost: ProjectionAdmissionCost): boolea
 	return (
 		cost.occurrenceMutationUnits >
 			MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxOccurrenceMutationUnitsPerClaim ||
+		cost.largestProjectionMutationBytes >
+			MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxProjectionMutationBytesPerVariant ||
 		cost.projectionMutationBytes >
 			MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxProjectionMutationBytesPerClaim
 	);
@@ -223,22 +258,209 @@ export async function refreshContentMediaUsage(
 	);
 }
 
-export async function refreshContentMediaUsageForWork(
+export interface ContentMediaUsageWorkRefreshInput {
+	collectionId: string;
+	collectionSlug: string;
+	contentId: string;
+}
+
+export interface ContentMediaUsageWorkBatchOptions {
+	shouldContinue?: () => boolean;
+}
+
+export async function refreshContentMediaUsageForWorkBatch(
 	db: Kysely<Database>,
-	collectionId: string,
-	collectionSlug: string,
-	contentId: string,
-): Promise<ContentMediaUsageRefreshResult> {
-	validateIdentifier(collectionSlug, "collection slug");
-	if (!collectionId) throw new Error("Durable media usage work requires a collection identity");
-	return withContentUsageCollectionLock(collectionSlug, () =>
-		withContentUsageLock(collectionSlug, contentId, () =>
-			refreshContentMediaUsageUnlocked(db, collectionSlug, contentId, {
-				collectionId,
-				durableWork: true,
-			}),
-		),
-	);
+	items: readonly ContentMediaUsageWorkRefreshInput[],
+	options: ContentMediaUsageWorkBatchOptions = {},
+): Promise<Map<string, ContentMediaUsageRefreshResult>> {
+	const results = new Map<string, ContentMediaUsageRefreshResult>();
+	const batchBudget = createContentMediaUsageAdmissionBudget({
+		maxOccurrenceMutationUnits:
+			MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxOccurrenceMutationUnitsPerBatch,
+		maxProjectionMutationBytes:
+			MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxProjectionMutationBytesPerBatch,
+	});
+	const collections = new Map<string, ContentMediaUsageWorkRefreshInput[]>();
+	for (const item of items) {
+		const key = `${item.collectionId}\u0000${item.collectionSlug}`;
+		const collectionItems = collections.get(key) ?? [];
+		collectionItems.push(item);
+		collections.set(key, collectionItems);
+	}
+	for (const collectionItems of collections.values()) {
+		if (options.shouldContinue && !options.shouldContinue()) break;
+		const first = collectionItems[0];
+		if (!first) continue;
+		validateIdentifier(first.collectionSlug, "collection slug");
+		if (!first.collectionId)
+			throw new Error("Durable media usage work requires a collection identity");
+		await withContentUsageCollectionLock(first.collectionSlug, async () => {
+			const fieldDiscovery = await loadContentMediaUsageFields(
+				db,
+				first.collectionSlug,
+				first.collectionId,
+			);
+			const sourceKeys = collectionItems.flatMap((item) =>
+				contentSourceKeys(item.collectionSlug, item.contentId, item.collectionId),
+			);
+			const repo = new MediaUsageRepository(db);
+			const observedSources = await repo.findSources(sourceKeys);
+			const snapshots = await loadContentMediaUsageSnapshotsBatch(
+				db,
+				first.collectionSlug,
+				collectionItems.map((item) => item.contentId),
+				fieldDiscovery,
+				{ collectionId: first.collectionId, identityVersion: 1 },
+				{
+					shouldContinue: options.shouldContinue,
+					maxOccurrenceCount:
+						MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxOccurrenceMutationUnitsPerBatch,
+					maxProjectionBytes:
+						MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxProjectionMutationBytesPerBatch,
+				},
+			);
+			const newSourceProjections: MediaUsageNewSourceProjection[] = [];
+			const newSourceKeys = new Map<string, string[]>();
+			const existingSourceProjections: MediaUsageExistingSourceProjection[] = [];
+			const unchangedSourceProjections: MediaUsageExistingSourceProjection[] = [];
+			const existingSourceKeys = new Map<
+				string,
+				{ allCount: number; changed: string[]; unchanged: string[] }
+			>();
+			for (const item of collectionItems) {
+				if (options.shouldContinue && !options.shouldContinue()) break;
+				const snapshotsResult = snapshots.get(item.contentId);
+				const itemSourceKeys = contentSourceKeys(
+					item.collectionSlug,
+					item.contentId,
+					item.collectionId,
+				);
+				if (!snapshotsResult?.success) {
+					continue;
+				}
+				const snapshotsByKey = new Map(
+					snapshotsResult.snapshots.map(
+						(snapshot) => [snapshot.source.sourceKey, snapshot] as const,
+					),
+				);
+				const existing = itemSourceKeys
+					.map((sourceKey) => observedSources.get(sourceKey))
+					.filter((source): source is MediaUsageSource => source !== undefined);
+				const allNew = existing.length === 0;
+				const allExisting =
+					existing.length === snapshotsResult.snapshots.length &&
+					existing.every((source) => snapshotsByKey.has(source.sourceKey));
+				if (!allNew && !allExisting) continue;
+				const admission = await planContentMediaUsageProjectionAdmission(
+					repo,
+					snapshotsResult.snapshots,
+					observedSources,
+					itemSourceKeys,
+					batchBudget,
+				);
+				if (admission.outcome === "claim_budget_deferred") break;
+				if (admission.outcome !== "admitted") {
+					results.set(
+						contentRefreshKey(item.collectionId, item.contentId),
+						admissionFailureResult(admission.outcome),
+					);
+					continue;
+				}
+				const key = contentRefreshKey(item.collectionId, item.contentId);
+				if (allNew) {
+					newSourceProjections.push(
+						...snapshotsResult.snapshots.map((snapshot) => ({
+							source: snapshot.source,
+							occurrences: snapshot.occurrences,
+						})),
+					);
+					newSourceKeys.set(
+						key,
+						snapshotsResult.snapshots.map((snapshot) => snapshot.source.sourceKey),
+					);
+					continue;
+				}
+				const changed: string[] = [];
+				const unchanged: string[] = [];
+				for (const snapshot of snapshotsResult.snapshots) {
+					const expectedSource = observedSources.get(snapshot.source.sourceKey);
+					if (!expectedSource) continue;
+					if (
+						expectedSource.sourceFingerprint === snapshot.source.sourceFingerprint &&
+						expectedSource.sourceCompleteness ===
+							(snapshot.source.sourceCompleteness ?? "complete") &&
+						expectedSource.lastErrorCode === null
+					) {
+						unchanged.push(snapshot.source.sourceKey);
+						unchangedSourceProjections.push({
+							source: snapshot.source,
+							occurrences: snapshot.occurrences,
+							expectedSource,
+						});
+						continue;
+					}
+					changed.push(snapshot.source.sourceKey);
+					existingSourceProjections.push({
+						source: snapshot.source,
+						occurrences: snapshot.occurrences,
+						expectedSource,
+					});
+				}
+				existingSourceKeys.set(key, {
+					allCount: snapshotsResult.snapshots.length,
+					changed,
+					unchanged,
+				});
+			}
+			const insertedSourceKeys = await repo.replaceNewSourcesBatch(newSourceProjections);
+			const replacedSourceKeys = await repo.replaceExistingSourcesBatch(existingSourceProjections);
+			const matchedSourceKeys = await repo.matchingExistingSourcesBatch(unchangedSourceProjections);
+			for (const [key, expectedSourceKeys] of newSourceKeys) {
+				results.set(
+					key,
+					expectedSourceKeys.every((sourceKey) => insertedSourceKeys.has(sourceKey))
+						? {
+								success: true,
+								refreshedSourceCount: expectedSourceKeys.length,
+								deletedSourceCount: 0,
+								failedSourceCount: 0,
+							}
+						: generationConflictResult({ refreshedSourceCount: 0, deletedSourceCount: 0 }),
+				);
+			}
+			for (const [key, expected] of existingSourceKeys) {
+				results.set(
+					key,
+					expected.changed.every((sourceKey) => replacedSourceKeys.has(sourceKey)) &&
+						expected.unchanged.every((sourceKey) => matchedSourceKeys.has(sourceKey))
+						? {
+								success: true,
+								refreshedSourceCount: expected.allCount,
+								deletedSourceCount: 0,
+								failedSourceCount: 0,
+							}
+						: generationConflictResult({ refreshedSourceCount: 0, deletedSourceCount: 0 }),
+				);
+			}
+			for (const item of collectionItems) {
+				if (options.shouldContinue && !options.shouldContinue()) break;
+				const key = contentRefreshKey(item.collectionId, item.contentId);
+				if (!snapshots.has(item.contentId)) continue;
+				if (results.has(key)) continue;
+				const result = await withContentUsageLock(item.collectionSlug, item.contentId, () =>
+					refreshContentMediaUsageUnlocked(db, item.collectionSlug, item.contentId, {
+						collectionId: item.collectionId,
+						durableWork: true,
+						fieldDiscovery,
+						observedSources,
+						snapshotsResult: snapshots.get(item.contentId),
+					}),
+				);
+				results.set(key, result);
+			}
+		});
+	}
+	return results;
 }
 
 async function refreshContentMediaUsageUnlocked(
@@ -294,19 +516,18 @@ async function refreshContentMediaUsageAttempt(
 ): Promise<ContentMediaUsageRefreshResult> {
 	const repo = new MediaUsageRepository(db);
 	const canonicalSourceKeys = contentSourceKeys(collectionSlug, contentId, options.collectionId);
-	const observedSources = await repo.findSources(canonicalSourceKeys);
-	const snapshotsResult = await loadContentMediaUsageSnapshots(
-		db,
-		collectionSlug,
-		contentId,
-		undefined,
-		options.collectionId ? { collectionId: options.collectionId, identityVersion: 1 } : undefined,
-	);
+	const observedSources = options.observedSources ?? (await repo.findSources(canonicalSourceKeys));
+	const snapshotsResult =
+		options.snapshotsResult ??
+		(await loadContentMediaUsageSnapshots(
+			db,
+			collectionSlug,
+			contentId,
+			options.fieldDiscovery,
+			options.collectionId ? { collectionId: options.collectionId, identityVersion: 1 } : undefined,
+		));
 	if (!snapshotsResult.success) {
 		if (snapshotsResult.error === "CONTENT_NOT_FOUND" && options.collectionId) {
-			if (!(await contentCollectionExists(db, collectionSlug, options.collectionId))) {
-				return generationConflictResult({ refreshedSourceCount: 0, deletedSourceCount: 0 });
-			}
 			if (!options.admissionBudget)
 				throw new Error("Durable media usage work requires an admission budget");
 			const admission = await planContentMediaUsageProjectionAdmission(
@@ -336,10 +557,7 @@ async function refreshContentMediaUsageAttempt(
 			: markSnapshotFailure(db, collectionSlug, snapshotsResult);
 	}
 
-	if (!(await contentCollectionExists(db, collectionSlug, options.collectionId))) {
-		if (options.collectionId) {
-			return generationConflictResult({ refreshedSourceCount: 0, deletedSourceCount: 0 });
-		}
+	if (!options.collectionId && !(await contentCollectionExists(db, collectionSlug))) {
 		const deletedSourceCount = await repo.deleteContentSources(collectionSlug, contentId);
 		return { ...ZERO_RESULT, deletedSourceCount };
 	}
@@ -381,10 +599,7 @@ async function refreshContentMediaUsageAttempt(
 		}
 		refreshedSourceCount++;
 	}
-	if (!(await contentCollectionExists(db, collectionSlug, options.collectionId))) {
-		if (options.collectionId) {
-			return generationConflictResult({ refreshedSourceCount, deletedSourceCount: 0 });
-		}
+	if (!options.collectionId && !(await contentCollectionExists(db, collectionSlug))) {
 		const deletedSourceCount = await repo.deleteContentSources(collectionSlug, contentId);
 		return { ...ZERO_RESULT, deletedSourceCount };
 	}
@@ -422,6 +637,10 @@ async function refreshContentMediaUsageAttempt(
 	};
 }
 
+export function contentRefreshKey(collectionId: string, contentId: string): string {
+	return `${collectionId}\u0000${contentId}`;
+}
+
 function contentSourceKeys(
 	collectionSlug: string,
 	contentId: string,

package/src/media/usage/content-snapshots.ts

@@ -1,5 +1,6 @@
 import { sql, type Kysely } from "kysely";
 
+import { jsonTextValues } from "../../database/json-recordset.js";
 import type {
 	MediaUsageOccurrenceInput,
 	MediaUsageSourceInput,
@@ -63,6 +64,12 @@ export interface LoadContentMediaUsageSnapshotsOptions {
 	identityVersion?: number;
 }
 
+export interface LoadContentMediaUsageSnapshotsBatchControl {
+	shouldContinue?: () => boolean;
+	maxOccurrenceCount?: number;
+	maxProjectionBytes?: number;
+}
+
 export async function loadContentMediaUsageSnapshots(
 	db: Kysely<Database>,
 	collectionSlug: string,
@@ -70,20 +77,84 @@ export async function loadContentMediaUsageSnapshots(
 	fieldDiscovery?: ContentMediaUsageFieldDiscovery,
 	options: LoadContentMediaUsageSnapshotsOptions = {},
 ): Promise<LoadContentMediaUsageSnapshotsResult> {
+	const results = await loadContentMediaUsageSnapshotsBatch(
+		db,
+		collectionSlug,
+		[contentId],
+		fieldDiscovery,
+		options,
+	);
+	return results.get(contentId) ?? { success: false, error: "CONTENT_NOT_FOUND" };
+}
+
+export async function loadContentMediaUsageSnapshotsBatch(
+	db: Kysely<Database>,
+	collectionSlug: string,
+	contentIds: readonly string[],
+	fieldDiscovery?: ContentMediaUsageFieldDiscovery,
+	options: LoadContentMediaUsageSnapshotsOptions = {},
+	control: LoadContentMediaUsageSnapshotsBatchControl = {},
+): Promise<Map<string, LoadContentMediaUsageSnapshotsResult>> {
 	validateIdentifier(collectionSlug, "collection slug");
 	if (options.identityVersion !== undefined && !options.collectionId) {
 		throw new Error("Canonical media usage snapshots require a collection identity");
 	}
 	const discovery = fieldDiscovery ?? (await loadContentMediaUsageFields(db, collectionSlug));
-	const row = await loadContentRow(
+	const rows = await loadContentRows(
 		db,
 		collectionSlug,
-		contentId,
+		contentIds,
 		[...discovery.extractionFields.map((field) => field.slug), ...discovery.displayFieldSlugs],
 		options.collectionId,
 	);
+	const revisionIds = Array.from(rows.values(), (row) =>
+		readNullableString(row.draft_revision_id),
+	).filter((revisionId): revisionId is string => revisionId !== null);
+	const revisions = await loadRevisionRows(db, revisionIds);
+	const results = new Map<string, LoadContentMediaUsageSnapshotsResult>();
+	let occurrenceCount = 0;
+	let projectionBytes = 0;
+	for (const contentId of new Set(contentIds)) {
+		if (control.shouldContinue && !control.shouldContinue()) break;
+		const row = rows.get(contentId);
+		const result: LoadContentMediaUsageSnapshotsResult = row
+			? await buildContentMediaUsageSnapshots(row, collectionSlug, discovery, options, revisions)
+			: { success: false, error: "CONTENT_NOT_FOUND" };
+		const snapshots = result.success ? result.snapshots : (result.snapshots ?? []);
+		const itemOccurrenceCount = snapshots.reduce(
+			(total, snapshot) => total + snapshot.occurrences.length,
+			0,
+		);
+		const itemProjectionBytes = snapshots.reduce(
+			(total, snapshot) => total + snapshot.projectionByteLength,
+			0,
+		);
+		if (
+			results.size > 0 &&
+			((control.maxOccurrenceCount !== undefined &&
+				occurrenceCount + itemOccurrenceCount > control.maxOccurrenceCount) ||
+				(control.maxProjectionBytes !== undefined &&
+					projectionBytes + itemProjectionBytes > control.maxProjectionBytes))
+		) {
+			break;
+		}
+		results.set(contentId, result);
+		occurrenceCount += itemOccurrenceCount;
+		projectionBytes += itemProjectionBytes;
+	}
+	return results;
+}
 
-	if (!row) return { success: false, error: "CONTENT_NOT_FOUND" };
+async function buildContentMediaUsageSnapshots(
+	row: Record<string, unknown>,
+	collectionSlug: string,
+	discovery: ContentMediaUsageFieldDiscovery,
+	options: LoadContentMediaUsageSnapshotsOptions,
+	revisions: ReadonlyMap<
+		string,
+		{ success: true; revision: RevisionSnapshotRow } | { success: false }
+	>,
+): Promise<LoadContentMediaUsageSnapshotsResult> {
 	const collectionId = readString(row[CONTENT_COLLECTION_ID_RESULT]);
 	if (!collectionId) {
 		throw new Error("Media usage snapshot query did not return a collection identity");
@@ -135,7 +206,7 @@ export async function loadContentMediaUsageSnapshots(
 			sourceVariant: "draft_overlay",
 			revisionId: draftRevisionId,
 		});
-		const revisionResult = await loadRevisionRow(db, draftRevisionId);
+		const revisionResult = revisions.get(draftRevisionId);
 		if (!revisionResult) {
 			return {
 				success: false,
@@ -212,52 +283,78 @@ interface RevisionSnapshotRow {
 	data: Record<string, unknown>;
 }
 
-async function loadContentRow(
+async function loadContentRows(
 	db: Kysely<Database>,
 	collectionSlug: string,
-	contentId: string,
+	contentIds: readonly string[],
 	fieldSlugs: readonly string[],
 	expectedCollectionId?: string,
-): Promise<Record<string, unknown> | null> {
+): Promise<Map<string, Record<string, unknown>>> {
 	const tableName = getContentTableName(collectionSlug);
 	const columns = uniqueColumns([...CONTENT_SYSTEM_COLUMNS, ...fieldSlugs]);
 	const columnRefs = columns.map((column) => sql.ref(`content.${column}`));
+	const rows = new Map<string, Record<string, unknown>>();
+	const uniqueContentIds = [...new Set(contentIds)];
+	if (uniqueContentIds.length === 0) return rows;
+	const contentIdInput = jsonTextValues(db, uniqueContentIds);
 	const result = await sql<Record<string, unknown>>`
+		WITH requested AS (${contentIdInput})
 		SELECT
 			${sql.join(columnRefs, sql`, `)},
 			collection.id AS __emdash_media_usage_collection_id
 		FROM ${sql.ref(tableName)} AS content
+		INNER JOIN requested ON requested.value = content.id
 		INNER JOIN _emdash_collections AS collection
 			ON collection.slug = ${collectionSlug}
 			${expectedCollectionId ? sql`AND collection.id = ${expectedCollectionId}` : sql``}
-		WHERE content.id = ${contentId}
-		LIMIT 1
 	`.execute(db);
-
-	return result.rows[0] ?? null;
+	for (const row of result.rows) {
+		const contentId = readString(row.id);
+		if (contentId) rows.set(contentId, row);
+	}
+	return rows;
 }
 
-async function loadRevisionRow(
+async function loadRevisionRows(
 	db: Kysely<Database>,
-	revisionId: string,
-): Promise<{ success: true; revision: RevisionSnapshotRow } | { success: false } | null> {
-	const row = await db
-		.selectFrom("revisions")
-		.select(["id", "collection", "entry_id", "data"])
-		.where("id", "=", revisionId)
-		.executeTakeFirst();
-	if (!row) return null;
-	const data = parseRevisionData(row.data);
-	if (!data) return { success: false };
-	return {
-		success: true,
-		revision: {
-			id: row.id,
-			collection: row.collection,
-			entryId: row.entry_id,
-			data,
-		},
-	};
+	revisionIds: readonly string[],
+): Promise<Map<string, { success: true; revision: RevisionSnapshotRow } | { success: false }>> {
+	const revisions = new Map<
+		string,
+		{ success: true; revision: RevisionSnapshotRow } | { success: false }
+	>();
+	const uniqueRevisionIds = [...new Set(revisionIds)];
+	if (uniqueRevisionIds.length === 0) return revisions;
+	const revisionIdInput = jsonTextValues(db, uniqueRevisionIds);
+	const rows = await sql<{
+		id: string;
+		collection: string;
+		entry_id: string;
+		data: unknown;
+	}>`
+		WITH requested AS (${revisionIdInput})
+		SELECT revision.id, revision.collection, revision.entry_id, revision.data
+		FROM revisions AS revision
+		INNER JOIN requested ON requested.value = revision.id
+	`.execute(db);
+	for (const row of rows.rows) {
+		const data = parseRevisionData(row.data);
+		revisions.set(
+			row.id,
+			data
+				? {
+						success: true,
+						revision: {
+							id: row.id,
+							collection: row.collection,
+							entryId: row.entry_id,
+							data,
+						},
+					}
+				: { success: false },
+		);
+	}
+	return revisions;
 }
 
 function buildContentSource(input: {