emdash 0.35.0 → 0.37.0

package/dist/{content-refresh-B_8SJzuU.mjs → content-refresh-Bwp-8yGy.mjs}

@@ -1,11 +1,13 @@
 import { t as validateIdentifier } from "./validate-BpwoDOgt.mjs";
 import { p as tableExists, s as isPostgres } from "./dialect-helpers-BSbfaO3F.mjs";
 import { i as isI18nEnabled } from "./config-C3EBstHi.mjs";
-import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-fiZ8G9RJ.mjs";
+import { getRequestContext } from "./request-context.mjs";
+import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-C4szrD8o.mjs";
 import { i as InvalidCursorError, o as decodeCursor, s as encodeCursor } from "./types-CQPWhPxE.mjs";
-import { t as withTransaction } from "./transaction-NQj4VJ7Z.mjs";
-import { t as INTERNAL_MEDIA_PREFIX } from "./normalize-Bc-s_r-a.mjs";
-import { n as normalizeMime } from "./mime-DfIVjNkr.mjs";
+import { t as withTransaction } from "./transaction-0KOpOyMu.mjs";
+import { t as INTERNAL_MEDIA_PREFIX } from "./normalize-C2xNjTSG.mjs";
+import { n as normalizeMime } from "./mime-CUIG6x84.mjs";
+import { n as MediaUsageActivationVersionMismatchError, t as MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION } from "./activation-K0kGBWuJ.mjs";
 import { sql } from "kysely";
 import { ulid } from "ulidx";
 
@@ -100,17 +102,82 @@ function isRecord$3(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+//#endregion
+//#region src/media/usage/types.ts
+const CONTENT_SOURCE_SCHEMA_VERSION = 1;
+
+//#endregion
+//#region src/database/json-recordset.ts
+function jsonTextValues(db, values) {
+	const payload = JSON.stringify([...new Set(values)]);
+	return isPostgres(db) ? sql`SELECT value::text AS value FROM jsonb_array_elements_text(${payload}::jsonb) AS value` : sql`SELECT value AS value FROM json_each(${payload})`;
+}
+
 //#endregion
 //#region src/database/repositories/media-usage.ts
 const OCCURRENCE_BIND_COLUMNS = 13;
+const D1_MAX_BOUND_PARAMETERS = 100;
 const MEDIA_USAGE_GENERATION_WRITE_LEASE_MS = 3600 * 1e3;
-const OCCURRENCE_INSERT_BATCH_SIZE = Math.max(1, Math.floor(SQL_BATCH_SIZE / OCCURRENCE_BIND_COLUMNS));
+const OCCURRENCE_INSERT_BATCH_SIZE = Math.max(1, Math.floor(D1_MAX_BOUND_PARAMETERS / OCCURRENCE_BIND_COLUMNS));
 function cleanupDeleteBatchSize(cleanupLease) {
 	return cleanupLease ? SQL_BATCH_SIZE - 3 : SQL_BATCH_SIZE;
 }
 function canIssueCleanupStatement(canIssueStatement) {
 	return canIssueStatement?.() ?? true;
 }
+function nullableRefMatch(left, right) {
+	const leftRef = sql.ref(left);
+	const rightRef = sql.ref(right);
+	return sql`(
+		(${leftRef} IS NULL AND ${rightRef} IS NULL)
+		OR ${leftRef} = ${rightRef}
+	)`;
+}
+const MAX_JSON_BIND_BYTES = 19e5;
+const MEDIA_USAGE_EVENT_QUERY_CEILING = 900;
+const MEDIA_USAGE_QUERY_RESERVE = 150;
+function chunkJsonRows(rows) {
+	const batches = [];
+	let batch = [];
+	let batchBytes = 2;
+	for (const row of rows) {
+		const rowBytes = new TextEncoder().encode(JSON.stringify(row)).byteLength + (batch.length > 0 ? 1 : 0);
+		if (batch.length > 0 && batchBytes + rowBytes > MAX_JSON_BIND_BYTES) {
+			batches.push(batch);
+			batch = [];
+			batchBytes = 2;
+		}
+		batch.push(row);
+		batchBytes += rowBytes;
+	}
+	if (batch.length > 0) batches.push(batch);
+	return batches;
+}
+function mediaUsageQueryBudgetAllows(queries) {
+	const metrics = getRequestContext()?.metrics;
+	return !metrics || metrics.dbCount + queries + MEDIA_USAGE_QUERY_RESERVE <= MEDIA_USAGE_EVENT_QUERY_CEILING;
+}
+function mergeInto(target, source) {
+	for (const value of source) target.add(value);
+}
+function batchOccurrenceRows(prepared, now) {
+	return prepared.flatMap((item) => item.projection.occurrences.map((occurrence) => ({
+		id: ulid(),
+		source_key: item.row.source_key,
+		generation: item.generation,
+		field_slug: occurrence.fieldSlug,
+		field_path: occurrence.fieldPath,
+		occurrence_index: occurrence.occurrenceIndex ?? 0,
+		reference_type: occurrence.referenceType,
+		media_id: occurrence.mediaId,
+		provider: occurrence.provider,
+		provider_asset_id: occurrence.providerAssetId,
+		media_kind: occurrence.mediaKind ?? null,
+		mime_type: occurrence.mimeType ?? null,
+		created_at: now,
+		lease_token: item.leaseToken
+	})));
+}
 function cleanupDurationSeconds(value) {
 	if (!Number.isSafeInteger(value) || value < 0) throw new Error("Media usage cleanup duration must be a non-negative whole number of seconds");
 	return value;
@@ -199,9 +266,14 @@ var MediaUsageRepository = class {
 		const uniqueSourceKeys = [...new Set(sourceKeys)];
 		const sources = /* @__PURE__ */ new Map();
 		if (uniqueSourceKeys.length === 0) return sources;
-		for (const sourceKeyBatch of chunks(uniqueSourceKeys, SQL_BATCH_SIZE)) {
-			const rows = await this.db.selectFrom("_emdash_media_usage_sources").selectAll().where("source_key", "in", sourceKeyBatch).execute();
-			for (const row of rows) {
+		for (const sourceKeyBatch of chunkJsonRows(uniqueSourceKeys)) {
+			const result = await sql`
+				WITH requested AS (${jsonTextValues(this.db, sourceKeyBatch)})
+				SELECT source.*
+				FROM _emdash_media_usage_sources AS source
+				INNER JOIN requested ON requested.value = source.source_key
+			`.execute(this.db);
+			for (const row of result.rows) {
 				const source = rowToSource(row);
 				sources.set(source.sourceKey, source);
 			}
@@ -250,6 +322,388 @@ var MediaUsageRepository = class {
 			source: replaced ? null : await this.findSource(source.sourceKey)
 		};
 	}
+	async replaceNewSourcesBatch(projections) {
+		const unique = [...new Map(projections.map((projection) => [projection.source.sourceKey, projection])).values()];
+		if (unique.length === 0) return /* @__PURE__ */ new Set();
+		const collectionSlug = unique[0]?.source.collectionSlug;
+		const collectionId = unique[0]?.source.collectionId;
+		if (!collectionSlug || !collectionId) throw new Error("Canonical media usage batch requires collection identity");
+		validateIdentifier(collectionSlug, "collection slug");
+		if (unique.some((projection) => projection.source.collectionSlug !== collectionSlug || projection.source.collectionId !== collectionId)) throw new Error("Canonical media usage batch must contain one collection");
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const expiresAt = new Date(Date.now() + MEDIA_USAGE_GENERATION_WRITE_LEASE_MS).toISOString();
+		const prepared = unique.map((projection) => {
+			const generation = ulid();
+			return {
+				projection,
+				generation,
+				leaseToken: ulid(),
+				row: this.buildSourceRow(projection.source, generation, now)
+			};
+		});
+		const sourceRows = prepared.map((item) => ({
+			...item.row,
+			lease_token: item.leaseToken
+		}));
+		const occurrenceRows = batchOccurrenceRows(prepared, now);
+		if (!mediaUsageQueryBudgetAllows(2 + chunkJsonRows(occurrenceRows).length + chunkJsonRows(sourceRows).length)) {
+			if (unique.length === 1) return /* @__PURE__ */ new Set();
+			const midpoint = Math.ceil(unique.length / 2);
+			const inserted = /* @__PURE__ */ new Set();
+			mergeInto(inserted, await this.replaceNewSourcesBatch(unique.slice(0, midpoint)));
+			mergeInto(inserted, await this.replaceNewSourcesBatch(unique.slice(midpoint)));
+			return inserted;
+		}
+		const leasesPayload = JSON.stringify(prepared.map((item) => ({
+			source_key: item.row.source_key,
+			collection_id: item.row.collection_id,
+			collection_slug: item.row.collection_slug,
+			generation: item.generation,
+			lease_token: item.leaseToken,
+			expires_at: expiresAt,
+			created_at: now
+		})));
+		const leases = this.generationWriteBatchInput(leasesPayload);
+		await sql`
+			WITH input AS (${leases})
+			INSERT INTO _emdash_media_usage_generation_writes (
+				source_key, generation, lease_token, expires_at, created_at
+			)
+			SELECT source_key, generation, lease_token, expires_at, created_at
+			FROM input
+			WHERE EXISTS (
+				SELECT 1
+				FROM _emdash_collections AS collection
+				INNER JOIN _emdash_media_usage_index_status AS status
+					ON status.collection_id = collection.id
+					AND status.scope_key = collection.slug
+				WHERE collection.id = input.collection_id
+					AND collection.slug = input.collection_slug
+					AND status.adapter_id = 'content-media'
+					AND status.scope_type = 'collection'
+					AND status.capture_state = 'active'
+					AND NOT EXISTS (
+						SELECT 1 FROM _emdash_media_usage_collection_deletions AS deletion
+						WHERE deletion.collection_id = input.collection_id
+					)
+			)
+		`.execute(this.db);
+		try {
+			await this.insertBatchOccurrences(occurrenceRows);
+			const tableName = `ec_${collectionSlug}`;
+			validateIdentifier(tableName, "content table");
+			const inserted = /* @__PURE__ */ new Set();
+			for (const sourceRowBatch of chunkJsonRows(sourceRows)) {
+				const result = await sql`
+					WITH input AS (${this.sourceBatchInput(JSON.stringify(sourceRowBatch))})
+					INSERT INTO _emdash_media_usage_sources (
+						source_key, source_type, collection_id, collection_slug, content_id,
+						source_variant, locale, translation_group, content_slug, content_title,
+						content_status, content_scheduled_at, content_deleted_at, revision_id,
+						current_generation, schema_version, source_updated_at, source_version,
+						source_fingerprint, identity_version, source_completeness,
+						last_attempted_at, last_error_code, indexed_at, updated_at
+					)
+					SELECT
+						input.source_key, input.source_type, input.collection_id, input.collection_slug,
+						input.content_id, input.source_variant, input.locale, input.translation_group,
+						input.content_slug, input.content_title, input.content_status,
+						input.content_scheduled_at, input.content_deleted_at, input.revision_id,
+						input.current_generation, input.schema_version, input.source_updated_at,
+						input.source_version, input.source_fingerprint, input.identity_version,
+						input.source_completeness, input.last_attempted_at, input.last_error_code,
+						input.indexed_at, input.updated_at
+					FROM input
+					WHERE EXISTS (
+						SELECT 1
+						FROM _emdash_media_usage_generation_writes AS writer
+						WHERE writer.source_key = input.source_key
+							AND writer.generation = input.current_generation
+							AND writer.lease_token = input.lease_token
+							AND ${this.generationWriteLeaseExpiryIsInFuture("writer.expires_at")}
+					)
+					AND EXISTS (
+						SELECT 1
+						FROM _emdash_collections AS collection
+						INNER JOIN _emdash_media_usage_index_status AS status
+							ON status.collection_id = collection.id
+							AND status.scope_key = collection.slug
+						WHERE collection.id = input.collection_id
+							AND collection.slug = input.collection_slug
+							AND status.adapter_id = 'content-media'
+							AND status.scope_type = 'collection'
+							AND status.capture_state = 'active'
+							AND NOT EXISTS (
+								SELECT 1
+								FROM _emdash_media_usage_collection_deletions AS deletion
+								WHERE deletion.collection_id = input.collection_id
+							)
+					)
+					AND EXISTS (
+						SELECT 1
+						FROM ${sql.ref(tableName)} AS content
+						WHERE content.id = input.content_id
+							AND content.version = input.source_version
+							AND content.updated_at = input.source_updated_at
+							AND (
+								(input.source_variant = 'columns' AND ${nullableRefMatch("content.live_revision_id", "input.revision_id")})
+								OR
+								(input.source_variant = 'draft_overlay' AND ${nullableRefMatch("content.draft_revision_id", "input.revision_id")})
+							)
+					)
+					ON CONFLICT (source_key) DO NOTHING
+					RETURNING source_key
+				`.execute(this.db);
+				for (const row of result.rows) inserted.add(row.source_key);
+			}
+			return inserted;
+		} finally {
+			await sql`
+				WITH input AS (${leases})
+				DELETE FROM _emdash_media_usage_generation_writes AS writer
+				WHERE EXISTS (
+					SELECT 1
+					FROM input
+					WHERE input.source_key = writer.source_key
+						AND input.generation = writer.generation
+						AND input.lease_token = writer.lease_token
+				)
+			`.execute(this.db);
+		}
+	}
+	async replaceExistingSourcesBatch(projections) {
+		const unique = [...new Map(projections.map((projection) => [projection.source.sourceKey, projection])).values()];
+		if (unique.length === 0) return /* @__PURE__ */ new Set();
+		const collectionSlug = unique[0]?.source.collectionSlug;
+		const collectionId = unique[0]?.source.collectionId;
+		if (!collectionSlug || !collectionId) throw new Error("Canonical media usage batch requires collection identity");
+		validateIdentifier(collectionSlug, "collection slug");
+		if (unique.some((projection) => projection.source.collectionSlug !== collectionSlug || projection.source.collectionId !== collectionId)) throw new Error("Canonical media usage batch must contain one collection");
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const expiresAt = new Date(Date.now() + MEDIA_USAGE_GENERATION_WRITE_LEASE_MS).toISOString();
+		const prepared = unique.map((projection) => {
+			const generation = ulid();
+			return {
+				projection,
+				generation,
+				leaseToken: ulid(),
+				row: this.buildSourceRow(projection.source, generation, now)
+			};
+		});
+		const sourceRows = prepared.map((item) => ({
+			...item.row,
+			lease_token: item.leaseToken,
+			expected_generation: item.projection.expectedSource.currentGeneration,
+			expected_collection_id: item.projection.expectedSource.collectionId,
+			expected_updated_at: item.projection.expectedSource.updatedAt,
+			expected_source_fingerprint: item.projection.expectedSource.sourceFingerprint,
+			expected_source_updated_at: item.projection.expectedSource.sourceUpdatedAt,
+			expected_source_version: item.projection.expectedSource.sourceVersion,
+			expected_identity_version: item.projection.expectedSource.identityVersion,
+			expected_revision_id: item.projection.expectedSource.revisionId,
+			expected_source_completeness: item.projection.expectedSource.sourceCompleteness,
+			expected_last_attempted_at: item.projection.expectedSource.lastAttemptedAt,
+			expected_last_error_code: item.projection.expectedSource.lastErrorCode
+		}));
+		const occurrenceRows = batchOccurrenceRows(prepared, now);
+		if (!mediaUsageQueryBudgetAllows(2 + chunkJsonRows(occurrenceRows).length + chunkJsonRows(sourceRows).length)) {
+			if (unique.length === 1) return /* @__PURE__ */ new Set();
+			const midpoint = Math.ceil(unique.length / 2);
+			const replaced = /* @__PURE__ */ new Set();
+			mergeInto(replaced, await this.replaceExistingSourcesBatch(unique.slice(0, midpoint)));
+			mergeInto(replaced, await this.replaceExistingSourcesBatch(unique.slice(midpoint)));
+			return replaced;
+		}
+		const leasesPayload = JSON.stringify(prepared.map((item) => ({
+			source_key: item.row.source_key,
+			collection_id: item.row.collection_id,
+			collection_slug: item.row.collection_slug,
+			generation: item.generation,
+			lease_token: item.leaseToken,
+			expires_at: expiresAt,
+			created_at: now
+		})));
+		const leases = this.generationWriteBatchInput(leasesPayload);
+		await sql`
+			WITH input AS (${leases})
+			INSERT INTO _emdash_media_usage_generation_writes (
+				source_key, generation, lease_token, expires_at, created_at
+			)
+			SELECT source_key, generation, lease_token, expires_at, created_at
+			FROM input
+			WHERE EXISTS (
+				SELECT 1
+				FROM _emdash_collections AS collection
+				INNER JOIN _emdash_media_usage_index_status AS status
+					ON status.collection_id = collection.id
+					AND status.scope_key = collection.slug
+				WHERE collection.id = input.collection_id
+					AND collection.slug = input.collection_slug
+					AND status.adapter_id = 'content-media'
+					AND status.scope_type = 'collection'
+					AND status.capture_state = 'active'
+					AND NOT EXISTS (
+						SELECT 1 FROM _emdash_media_usage_collection_deletions AS deletion
+						WHERE deletion.collection_id = input.collection_id
+					)
+			)
+		`.execute(this.db);
+		try {
+			await this.insertBatchOccurrences(occurrenceRows);
+			const tableName = `ec_${collectionSlug}`;
+			validateIdentifier(tableName, "content table");
+			const replaced = /* @__PURE__ */ new Set();
+			for (const sourceRowBatch of chunkJsonRows(sourceRows)) {
+				const result = await sql`
+					WITH input AS (${this.sourceBatchInput(JSON.stringify(sourceRowBatch))})
+					UPDATE _emdash_media_usage_sources AS source
+					SET source_type = input.source_type,
+						collection_id = input.collection_id,
+						collection_slug = input.collection_slug,
+						content_id = input.content_id,
+						source_variant = input.source_variant,
+						locale = input.locale,
+						translation_group = input.translation_group,
+						content_slug = input.content_slug,
+						content_title = input.content_title,
+						content_status = input.content_status,
+						content_scheduled_at = input.content_scheduled_at,
+						content_deleted_at = input.content_deleted_at,
+						revision_id = input.revision_id,
+						current_generation = input.current_generation,
+						schema_version = input.schema_version,
+						source_updated_at = input.source_updated_at,
+						source_version = input.source_version,
+						source_fingerprint = input.source_fingerprint,
+						identity_version = input.identity_version,
+						source_completeness = input.source_completeness,
+						last_attempted_at = input.last_attempted_at,
+						last_error_code = input.last_error_code,
+						indexed_at = input.indexed_at,
+						updated_at = input.updated_at
+					FROM input
+					WHERE source.source_key = input.source_key
+						AND source.current_generation = input.expected_generation
+						AND ${this.batchRefsMatch("source.collection_id", "input.expected_collection_id")}
+						AND source.updated_at = input.expected_updated_at
+						AND ${this.batchRefsMatch("source.source_fingerprint", "input.expected_source_fingerprint")}
+						AND ${this.batchRefsMatch("source.source_updated_at", "input.expected_source_updated_at")}
+						AND ${this.batchRefsMatch("source.source_version", "input.expected_source_version")}
+						AND ${this.batchRefsMatch("source.identity_version", "input.expected_identity_version")}
+						AND ${this.batchRefsMatch("source.revision_id", "input.expected_revision_id")}
+						AND source.source_completeness = input.expected_source_completeness
+						AND ${this.batchRefsMatch("source.last_attempted_at", "input.expected_last_attempted_at")}
+						AND ${this.batchRefsMatch("source.last_error_code", "input.expected_last_error_code")}
+						AND EXISTS (
+							SELECT 1
+							FROM _emdash_media_usage_generation_writes AS writer
+							WHERE writer.source_key = input.source_key
+								AND writer.generation = input.current_generation
+								AND writer.lease_token = input.lease_token
+								AND ${this.generationWriteLeaseExpiryIsInFuture("writer.expires_at")}
+						)
+						AND EXISTS (
+							SELECT 1
+							FROM _emdash_collections AS collection
+							INNER JOIN _emdash_media_usage_index_status AS status
+								ON status.collection_id = collection.id
+								AND status.scope_key = collection.slug
+							WHERE collection.id = input.collection_id
+								AND collection.slug = input.collection_slug
+								AND status.adapter_id = 'content-media'
+								AND status.scope_type = 'collection'
+								AND status.capture_state = 'active'
+								AND NOT EXISTS (
+									SELECT 1
+									FROM _emdash_media_usage_collection_deletions AS deletion
+									WHERE deletion.collection_id = input.collection_id
+								)
+						)
+						AND EXISTS (
+							SELECT 1
+							FROM ${sql.ref(tableName)} AS content
+							WHERE content.id = input.content_id
+								AND content.version = input.source_version
+								AND content.updated_at = input.source_updated_at
+								AND (
+									(input.source_variant = 'columns' AND ${nullableRefMatch("content.live_revision_id", "input.revision_id")})
+									OR
+									(input.source_variant = 'draft_overlay' AND ${nullableRefMatch("content.draft_revision_id", "input.revision_id")})
+								)
+						)
+					RETURNING ${isPostgres(this.db) ? sql`source.source_key` : sql`source_key`} AS source_key
+				`.execute(this.db);
+				for (const row of result.rows) replaced.add(row.source_key);
+			}
+			return replaced;
+		} finally {
+			await sql`
+				WITH input AS (${leases})
+				DELETE FROM _emdash_media_usage_generation_writes AS writer
+				WHERE EXISTS (
+					SELECT 1
+					FROM input
+					WHERE input.source_key = writer.source_key
+						AND input.generation = writer.generation
+						AND input.lease_token = writer.lease_token
+				)
+			`.execute(this.db);
+		}
+	}
+	async matchingExistingSourcesBatch(projections) {
+		if (projections.length === 0) return /* @__PURE__ */ new Set();
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const rows = projections.map((projection) => ({
+			...this.buildSourceRow(projection.source, projection.expectedSource.currentGeneration, now),
+			expected_generation: projection.expectedSource.currentGeneration,
+			expected_collection_id: projection.expectedSource.collectionId,
+			expected_updated_at: projection.expectedSource.updatedAt,
+			expected_source_fingerprint: projection.expectedSource.sourceFingerprint,
+			expected_source_updated_at: projection.expectedSource.sourceUpdatedAt,
+			expected_source_version: projection.expectedSource.sourceVersion,
+			expected_identity_version: projection.expectedSource.identityVersion,
+			expected_revision_id: projection.expectedSource.revisionId,
+			expected_source_completeness: projection.expectedSource.sourceCompleteness,
+			expected_last_attempted_at: projection.expectedSource.lastAttemptedAt,
+			expected_last_error_code: projection.expectedSource.lastErrorCode
+		}));
+		if (!mediaUsageQueryBudgetAllows(chunkJsonRows(rows).length)) {
+			if (projections.length === 1) return /* @__PURE__ */ new Set();
+			const midpoint = Math.ceil(projections.length / 2);
+			const matched = /* @__PURE__ */ new Set();
+			mergeInto(matched, await this.matchingExistingSourcesBatch(projections.slice(0, midpoint)));
+			mergeInto(matched, await this.matchingExistingSourcesBatch(projections.slice(midpoint)));
+			return matched;
+		}
+		const matched = /* @__PURE__ */ new Set();
+		for (const batch of chunkJsonRows(rows)) {
+			const result = await sql`
+				WITH input AS (${this.sourceBatchInput(JSON.stringify(batch))})
+				SELECT source.source_key
+				FROM _emdash_media_usage_sources AS source
+				INNER JOIN input ON input.source_key = source.source_key
+				WHERE source.current_generation = input.expected_generation
+					AND ${this.batchRefsMatch("source.collection_id", "input.expected_collection_id")}
+					AND source.updated_at = input.expected_updated_at
+					AND ${this.batchRefsMatch("source.source_fingerprint", "input.expected_source_fingerprint")}
+					AND ${this.batchRefsMatch("source.source_updated_at", "input.expected_source_updated_at")}
+					AND ${this.batchRefsMatch("source.source_version", "input.expected_source_version")}
+					AND ${this.batchRefsMatch("source.identity_version", "input.expected_identity_version")}
+					AND ${this.batchRefsMatch("source.revision_id", "input.expected_revision_id")}
+					AND source.source_completeness = input.expected_source_completeness
+					AND ${this.batchRefsMatch("source.last_attempted_at", "input.expected_last_attempted_at")}
+					AND ${this.batchRefsMatch("source.last_error_code", "input.expected_last_error_code")}
+					AND EXISTS (
+						SELECT 1
+						FROM _emdash_collections AS collection
+						WHERE collection.id = source.collection_id
+							AND collection.slug = source.collection_slug
+					)
+			`.execute(this.db);
+			for (const row of result.rows) matched.add(row.source_key);
+		}
+		return matched;
+	}
 	async markSourceAttempted(source) {
 		if (source.collectionId !== void 0 && source.collectionId !== null) {
 			const expectedSource = await this.findSource(source.sourceKey);
@@ -317,6 +771,103 @@ var MediaUsageRepository = class {
 			reconciliationRequired: row.reconciliation_required !== null && Number(row.reconciliation_required) !== 0
 		}));
 	}
+	async findCollectionProgress() {
+		const row = (await sql`
+			WITH collection_progress AS (
+				SELECT
+					CASE WHEN status.status = 'complete'
+						AND status.schema_version = ${CONTENT_SOURCE_SCHEMA_VERSION}
+						AND status.reconciliation_required = 0
+						AND status.capture_state = 'active'
+						AND NOT EXISTS (
+							SELECT 1 FROM _emdash_media_usage_work AS work
+							WHERE work.collection_id = collection.id
+								AND work.collection_slug = collection.slug
+						)
+					THEN 1 ELSE 0 END AS is_ready,
+					CASE WHEN status.collection_id IS NULL
+						OR COALESCE(status.capture_state, '') <> 'active'
+						OR status.status NOT IN ('complete', 'never', 'running', 'partial', 'failed', 'stale')
+						OR status.status = 'failed'
+						OR (
+							status.reconciliation_required = 0
+							AND (
+								status.status <> 'complete'
+								OR COALESCE(status.schema_version, -1) <> ${CONTENT_SOURCE_SCHEMA_VERSION}
+							)
+							AND NOT EXISTS (
+								SELECT 1 FROM _emdash_media_usage_work AS work
+								WHERE work.collection_id = collection.id
+									AND work.collection_slug = collection.slug
+							)
+						)
+						OR EXISTS (
+							SELECT 1 FROM _emdash_media_usage_work AS work
+							WHERE work.collection_id = collection.id
+								AND work.collection_slug = collection.slug
+								AND work.state = 'failed'
+						)
+						OR EXISTS (
+							SELECT 1 FROM _emdash_media_usage_reconciliations AS reconciliation
+							WHERE reconciliation.collection_id = collection.id
+								AND reconciliation.collection_slug = collection.slug
+								AND reconciliation.state = 'failed'
+								AND status.reconciliation_required = 1
+								AND (
+									reconciliation.target_epoch IS NULL
+									OR reconciliation.target_epoch >= status.change_epoch
+								)
+						)
+					THEN 1 ELSE 0 END AS needs_attention
+				FROM _emdash_collections AS collection
+				LEFT JOIN _emdash_media_usage_index_status AS status
+					ON status.adapter_id = 'content-media'
+					AND status.scope_type = 'collection'
+					AND status.collection_id = collection.id
+					AND status.scope_key = collection.slug
+				WHERE NOT EXISTS (
+					SELECT 1 FROM _emdash_media_usage_collection_deletions AS deletion
+					WHERE deletion.collection_id = collection.id
+						AND deletion.collection_slug = collection.slug
+				)
+			)
+			SELECT
+				(
+					SELECT activation.runtime_generation
+					FROM _emdash_media_usage_activation AS activation
+					WHERE activation.task_key = 'incremental_capture'
+				) AS activation_generation,
+				EXISTS (
+					SELECT 1 FROM _emdash_media_usage_activation AS activation
+					WHERE activation.task_key = 'incremental_capture'
+						AND activation.state = 'active'
+				) AS activation_active,
+				COUNT(*) AS total_collections,
+				COALESCE(SUM(is_ready), 0) AS ready_collections,
+				EXISTS (
+					SELECT 1 FROM _emdash_media_usage_collection_deletions AS deletion
+					WHERE deletion.state IN ('pending', 'retry', 'leased')
+				) AS cleanup_pending,
+				CASE WHEN COALESCE(MAX(needs_attention), 0) = 1 OR EXISTS (
+					SELECT 1 FROM _emdash_media_usage_collection_deletions AS deletion
+					WHERE deletion.state = 'failed'
+				) THEN 1 ELSE 0 END AS needs_attention
+			FROM collection_progress
+		`.execute(this.db)).rows[0];
+		if (!row) throw new Error("Media usage progress query returned no result");
+		if (!row.activation_active) return null;
+		if (Number(row.activation_generation) !== MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION) throw new MediaUsageActivationVersionMismatchError("Media usage activation runtime generation is incompatible");
+		const readyCollections = Number(row.ready_collections);
+		const totalCollections = Number(row.total_collections);
+		const cleanupPending = Number(row.cleanup_pending);
+		const needsAttention = Number(row.needs_attention);
+		if (!Number.isSafeInteger(readyCollections) || !Number.isSafeInteger(totalCollections) || readyCollections < 0 || totalCollections < readyCollections || cleanupPending !== 0 && cleanupPending !== 1 || needsAttention !== 0 && needsAttention !== 1) throw new Error("Media usage progress query returned invalid counts");
+		return {
+			status: needsAttention ? "needs_attention" : readyCollections === totalCollections && cleanupPending === 0 ? "ready" : "indexing",
+			readyCollections,
+			totalCollections
+		};
+	}
 	async findCurrentEntryUsagePageByMediaId(mediaId, options = {}) {
 		const requestedLimit = Math.floor(options.limit ?? 50);
 		const limit = Number.isFinite(requestedLimit) ? Math.min(Math.max(1, requestedLimit), 100) : 50;
@@ -469,7 +1020,14 @@ var MediaUsageRepository = class {
 			consecutiveFailures: row.consecutive_failures
 		};
 	}
+	/**
+	* Scans for reclaimable occurrences, or resolves to `null` when the sweep was
+	* never issued because the lease is gone or the tick is out of budget. An
+	* empty array means the scan ran and found nothing, which lets the caller
+	* retire the sweep window; `null` must leave the cursor where it was.
+	*/
 	async findMediaUsageCleanupCandidates(input) {
+		if (!await this.admitCleanupScan(input.cleanupLease, input.canIssueStatement)) return null;
 		let query = this.db.selectFrom("_emdash_media_usage as u").leftJoin("_emdash_media_usage_sources as s", "s.source_key", "u.source_key").leftJoin("_emdash_media_usage_generation_writes as writer", (join) => join.onRef("writer.source_key", "=", "u.source_key").onRef("writer.generation", "=", "u.generation")).select([
 			"u.id as id",
 			"u.source_key as source_key",
@@ -479,8 +1037,10 @@ var MediaUsageRepository = class {
 			"s.indexed_at as indexed_at",
 			"writer.expires_at as write_lease_expires_at"
 		]).where("u.created_at", "<", input.cutoff).orderBy("u.created_at", "asc").orderBy("u.id", "asc").limit(Math.max(0, Math.floor(input.limit)));
-		if (input.cleanupLease) query = query.where(this.activeCleanupLeaseExpression(input.cleanupLease));
-		if (input.cursor) query = query.where((eb) => eb.or([eb("u.created_at", ">", input.cursor.createdAt), eb.and([eb("u.created_at", "=", input.cursor.createdAt), eb("u.id", ">", input.cursor.id)])]));
+		if (input.cursor) {
+			const cursor = input.cursor;
+			query = query.where((eb) => eb(eb.refTuple("u.created_at", "u.id"), ">", eb.tuple(cursor.createdAt, cursor.id)));
+		}
 		return (await query.execute()).map((row) => ({
 			id: row.id,
 			sourceKey: row.source_key,
@@ -532,38 +1092,31 @@ var MediaUsageRepository = class {
 		const batchLimit = Math.floor(limit);
 		if (batchLimit <= 0) return 0;
 		if (options.candidateIds) return this.deleteOrphanCandidateIds(options.candidateIds.slice(0, batchLimit), cutoff, options.cleanupLease, options.canIssueStatement);
-		if (!canIssueCleanupStatement(options.canIssueStatement)) return 0;
-		let query = this.db.selectFrom("_emdash_media_usage as u").leftJoin("_emdash_media_usage_sources as s", (join) => join.onRef("s.source_key", "=", "u.source_key")).leftJoin("_emdash_media_usage_generation_writes as writer", (join) => join.onRef("writer.source_key", "=", "u.source_key").onRef("writer.generation", "=", "u.generation")).select("u.id").where("s.source_key", "is", null).where("u.created_at", "<", cutoff).where(this.noActiveGenerationWriteExpression("u")).orderBy("u.created_at", "asc").orderBy("u.id", "asc").limit(batchLimit);
-		if (options.cleanupLease) query = query.where(this.activeCleanupLeaseExpression(options.cleanupLease));
-		const rows = await query.execute();
+		if (!await this.admitCleanupScan(options.cleanupLease, options.canIssueStatement)) return 0;
+		const rows = await this.db.selectFrom("_emdash_media_usage as u").leftJoin("_emdash_media_usage_sources as s", (join) => join.onRef("s.source_key", "=", "u.source_key")).leftJoin("_emdash_media_usage_generation_writes as writer", (join) => join.onRef("writer.source_key", "=", "u.source_key").onRef("writer.generation", "=", "u.generation")).select("u.id").where("s.source_key", "is", null).where("u.created_at", "<", cutoff).where(this.noActiveGenerationWriteExpression("u")).orderBy("u.created_at", "asc").orderBy("u.id", "asc").limit(batchLimit).execute();
 		return this.deleteOrphanCandidateIds(rows.map((row) => row.id), cutoff, options.cleanupLease, options.canIssueStatement);
 	}
 	async deleteStaleGenerationsOlderThan(cutoff, limit, options = {}) {
 		const batchLimit = Math.floor(limit);
 		if (batchLimit <= 0) return 0;
 		if (options.candidateIds) return this.deleteStaleCandidateIds(options.candidateIds.slice(0, batchLimit), cutoff, options.cleanupLease, options.canIssueStatement);
-		if (!canIssueCleanupStatement(options.canIssueStatement)) return 0;
-		let query = this.db.selectFrom("_emdash_media_usage as u").innerJoin("_emdash_media_usage_sources as s", (join) => join.onRef("s.source_key", "=", "u.source_key")).leftJoin("_emdash_media_usage_generation_writes as writer", (join) => join.onRef("writer.source_key", "=", "u.source_key").onRef("writer.generation", "=", "u.generation")).select("u.id").where("u.created_at", "<", cutoff).whereRef("u.generation", "!=", "s.current_generation").whereRef("u.created_at", "<", "s.indexed_at").where(this.noActiveGenerationWriteExpression("u")).orderBy("u.created_at", "asc").orderBy("u.id", "asc").limit(batchLimit);
-		if (options.cleanupLease) query = query.where(this.activeCleanupLeaseExpression(options.cleanupLease));
-		const rows = await query.execute();
+		if (!await this.admitCleanupScan(options.cleanupLease, options.canIssueStatement)) return 0;
+		const rows = await this.db.selectFrom("_emdash_media_usage as u").innerJoin("_emdash_media_usage_sources as s", (join) => join.onRef("s.source_key", "=", "u.source_key")).leftJoin("_emdash_media_usage_generation_writes as writer", (join) => join.onRef("writer.source_key", "=", "u.source_key").onRef("writer.generation", "=", "u.generation")).select("u.id").where("u.created_at", "<", cutoff).whereRef("u.generation", "!=", "s.current_generation").whereRef("u.created_at", "<", "s.indexed_at").where(this.noActiveGenerationWriteExpression("u")).orderBy("u.created_at", "asc").orderBy("u.id", "asc").limit(batchLimit).execute();
 		return this.deleteStaleCandidateIds(rows.map((row) => row.id), cutoff, options.cleanupLease, options.canIssueStatement);
 	}
 	async deleteAbandonedGenerationsOlderThan(cutoff, limit, options = {}) {
 		const batchLimit = Math.floor(limit);
 		if (batchLimit <= 0) return 0;
 		if (options.candidateIds) return this.deleteAbandonedCandidateIds(options.candidateIds.slice(0, batchLimit), cutoff, options.cleanupLease, options.canIssueStatement);
-		if (!canIssueCleanupStatement(options.canIssueStatement)) return 0;
-		let query = this.db.selectFrom("_emdash_media_usage as u").innerJoin("_emdash_media_usage_sources as s", (join) => join.onRef("s.source_key", "=", "u.source_key")).leftJoin("_emdash_media_usage_generation_writes as writer", (join) => join.onRef("writer.source_key", "=", "u.source_key").onRef("writer.generation", "=", "u.generation")).select("u.id").where("u.created_at", "<", cutoff).whereRef("u.generation", "!=", "s.current_generation").whereRef("u.created_at", ">=", "s.indexed_at").where(this.noActiveGenerationWriteExpression("u")).orderBy("u.created_at", "asc").orderBy("u.id", "asc").limit(batchLimit);
-		if (options.cleanupLease) query = query.where(this.activeCleanupLeaseExpression(options.cleanupLease));
-		const rows = await query.execute();
+		if (!await this.admitCleanupScan(options.cleanupLease, options.canIssueStatement)) return 0;
+		const rows = await this.db.selectFrom("_emdash_media_usage as u").innerJoin("_emdash_media_usage_sources as s", (join) => join.onRef("s.source_key", "=", "u.source_key")).leftJoin("_emdash_media_usage_generation_writes as writer", (join) => join.onRef("writer.source_key", "=", "u.source_key").onRef("writer.generation", "=", "u.generation")).select("u.id").where("u.created_at", "<", cutoff).whereRef("u.generation", "!=", "s.current_generation").whereRef("u.created_at", ">=", "s.indexed_at").where(this.noActiveGenerationWriteExpression("u")).orderBy("u.created_at", "asc").orderBy("u.id", "asc").limit(batchLimit).execute();
 		return this.deleteAbandonedCandidateIds(rows.map((row) => row.id), cutoff, options.cleanupLease, options.canIssueStatement);
 	}
 	async deleteExpiredGenerationWriteLeases(limit, cleanupLease, canIssueStatement) {
 		const batchLimit = Math.floor(limit);
-		if (batchLimit <= 0 || !canIssueCleanupStatement(canIssueStatement)) return 0;
-		let query = this.db.selectFrom("_emdash_media_usage_generation_writes").select("lease_token").where(this.generationWriteLeaseHasExpired("expires_at")).orderBy("expires_at", "asc").orderBy("lease_token", "asc").limit(batchLimit);
-		if (cleanupLease) query = query.where(this.activeCleanupLeaseExpression(cleanupLease));
-		const rows = await query.execute();
+		if (batchLimit <= 0) return 0;
+		if (!await this.admitCleanupScan(cleanupLease, canIssueStatement)) return 0;
+		const rows = await this.db.selectFrom("_emdash_media_usage_generation_writes").select("lease_token").where(this.generationWriteLeaseHasExpired("expires_at")).orderBy("expires_at", "asc").orderBy("lease_token", "asc").limit(batchLimit).execute();
 		if (rows.length === 0 || !canIssueCleanupStatement(canIssueStatement)) return 0;
 		let deleteQuery = this.db.deleteFrom("_emdash_media_usage_generation_writes").where("lease_token", "in", rows.map((row) => row.lease_token)).where(this.generationWriteLeaseHasExpired("expires_at"));
 		if (cleanupLease) deleteQuery = deleteQuery.where(this.activeCleanupLeaseExpression(cleanupLease));
@@ -746,6 +1299,7 @@ var MediaUsageRepository = class {
 			status: sql`CASE WHEN ${canComplete} THEN 'complete' ELSE status END`,
 			completed_at: sql`CASE WHEN ${canComplete} THEN ${now} ELSE completed_at END`,
 			last_error_code: sql`CASE WHEN ${canComplete} THEN NULL ELSE last_error_code END`,
+			cursor: sql`CASE WHEN ${canComplete} THEN NULL ELSE cursor END`,
 			last_incremental_success_at: now,
 			updated_at: now
 		}).where("adapter_id", "=", "content-media").where("scope_type", "=", "collection").where("scope_key", "=", input.collectionSlug).where("collection_id", "=", input.collectionId).where("change_epoch", "=", observed.change_epoch).where("capture_state", "=", "active").where(sql`EXISTS (
@@ -756,6 +1310,65 @@ var MediaUsageRepository = class {
 				)`).executeTakeFirst();
 		return Number(result.numUpdatedRows ?? 0) > 0;
 	}
+	async prepareIncrementalFinalization(input) {
+		const observed = await this.db.selectFrom("_emdash_media_usage_index_status").select(["change_epoch", "reconciliation_required"]).where("adapter_id", "=", "content-media").where("scope_type", "=", "collection").where("scope_key", "=", input.collectionSlug).where("collection_id", "=", input.collectionId).where("capture_state", "=", "active").executeTakeFirst();
+		if (!observed) return { outcome: "lost" };
+		if (observed.reconciliation_required !== 0) return { outcome: "not_required" };
+		const marker = `incremental-finalize:${String(observed.change_epoch)}:${ulid()}`;
+		const result = await this.db.updateTable("_emdash_media_usage_index_status").set({
+			cursor: marker,
+			updated_at: this.sortableUtcTimestamp()
+		}).where("adapter_id", "=", "content-media").where("scope_type", "=", "collection").where("scope_key", "=", input.collectionSlug).where("collection_id", "=", input.collectionId).where("capture_state", "=", "active").where("reconciliation_required", "=", 0).where("change_epoch", "=", observed.change_epoch).where(sql`EXISTS (
+					SELECT 1
+					FROM _emdash_collections AS collection
+					WHERE collection.id = ${input.collectionId}
+						AND collection.slug = ${input.collectionSlug}
+				)`).where(sql`NOT EXISTS (
+					SELECT 1
+					FROM _emdash_media_usage_collection_deletions AS deletion
+					WHERE deletion.collection_id = ${input.collectionId}
+				)`).executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) > 0 ? {
+			outcome: "marked",
+			marker
+		} : { outcome: "lost" };
+	}
+	async recoverIncrementalFinalizations() {
+		const markerMatchesEpoch = isPostgres(this.db) ? sql`status.cursor LIKE ('incremental-finalize:' || status.change_epoch::text || ':%')` : sql`status.cursor LIKE ('incremental-finalize:' || CAST(status.change_epoch AS text) || ':%')`;
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		return (await sql`
+			UPDATE _emdash_media_usage_index_status AS status
+			SET status = 'complete',
+				completed_at = ${now},
+				cursor = NULL,
+				last_error_code = NULL,
+				last_incremental_success_at = ${now},
+				updated_at = ${now}
+			WHERE status.adapter_id = 'content-media'
+				AND status.scope_type = 'collection'
+				AND status.capture_state = 'active'
+				AND status.reconciliation_required = 0
+				AND status.cursor IS NOT NULL
+				AND ${markerMatchesEpoch}
+				AND EXISTS (
+					SELECT 1
+					FROM _emdash_collections AS collection
+					WHERE collection.id = status.collection_id
+						AND collection.slug = status.scope_key
+				)
+				AND NOT EXISTS (
+					SELECT 1
+					FROM _emdash_media_usage_collection_deletions AS deletion
+					WHERE deletion.collection_id = status.collection_id
+				)
+				AND NOT EXISTS (
+					SELECT 1
+					FROM _emdash_media_usage_work AS work
+					WHERE work.collection_id = status.collection_id
+				)
+			RETURNING collection_id
+		`.execute(this.db)).rows.length;
+	}
 	async recordIncrementalFailure(input) {
 		const now = this.sortableUtcTimestamp();
 		const automaticRunOwnsCoverage = sql`EXISTS (
@@ -799,6 +1412,67 @@ var MediaUsageRepository = class {
 				)`).executeTakeFirst();
 		return Number(result.numUpdatedRows ?? 0) > 0;
 	}
+	async recordIncrementalFailuresByCollection(input) {
+		const collectionIds = [...new Set(input.collectionIds)];
+		if (collectionIds.length === 0) return /* @__PURE__ */ new Set();
+		const collections = jsonTextValues(this.db, collectionIds);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const result = await sql`
+			WITH failed_collections AS (${collections})
+			UPDATE _emdash_media_usage_index_status AS status
+			SET status = CASE
+					WHEN EXISTS (
+						SELECT 1
+						FROM _emdash_media_usage_reconciliations AS reconciliation
+						WHERE reconciliation.collection_id = status.collection_id
+							AND reconciliation.run_token = status.cursor
+					) THEN status.status
+					WHEN status.reconciliation_required = 0 THEN 'partial'
+					WHEN status.status = 'running' THEN 'stale'
+					ELSE status.status
+				END,
+				completed_at = CASE
+					WHEN EXISTS (
+						SELECT 1
+						FROM _emdash_media_usage_reconciliations AS reconciliation
+						WHERE reconciliation.collection_id = status.collection_id
+							AND reconciliation.run_token = status.cursor
+					) THEN status.completed_at
+					WHEN status.reconciliation_required = 0 OR status.status = 'running' THEN NULL
+					ELSE status.completed_at
+				END,
+				cursor = CASE
+					WHEN EXISTS (
+						SELECT 1
+						FROM _emdash_media_usage_reconciliations AS reconciliation
+						WHERE reconciliation.collection_id = status.collection_id
+							AND reconciliation.run_token = status.cursor
+					) THEN status.cursor
+					WHEN status.status = 'running' THEN NULL
+					ELSE status.cursor
+				END,
+				last_error_code = ${input.errorCode},
+				updated_at = ${now}
+			WHERE status.adapter_id = 'content-media'
+				AND status.scope_type = 'collection'
+				AND status.collection_id IN (SELECT value FROM failed_collections)
+				AND EXISTS (
+					SELECT 1
+					FROM _emdash_media_usage_work AS work
+					WHERE work.collection_id = status.collection_id
+						AND work.state = 'failed'
+						AND work.last_error_code = ${input.errorCode}
+				)
+				AND EXISTS (
+					SELECT 1
+					FROM _emdash_collections AS collection
+					WHERE collection.id = status.collection_id
+						AND collection.slug = status.scope_key
+				)
+			RETURNING collection_id
+		`.execute(this.db);
+		return new Set(result.rows.map((row) => row.collection_id));
+	}
 	async findIndexStatus(identity) {
 		const row = await this.db.selectFrom("_emdash_media_usage_index_status").selectAll().where("adapter_id", "=", identity.adapterId).where("scope_type", "=", identity.scopeType).where("scope_key", "=", identity.scopeKey).executeTakeFirst();
 		return row ? rowToIndexStatus(row) : null;
@@ -901,6 +1575,31 @@ var MediaUsageRepository = class {
 					AND ${this.generationWriteLeaseExpiryIsInFuture("writer.expires_at")}
 			)`;
 	}
+	/**
+	* Gates a bounded cleanup scan on the lease and the tick's statement budget.
+	*
+	* The budget is re-read after the lease row because that read is itself a
+	* statement: an isolate suspended across it can resume with the budget spent.
+	*/
+	async admitCleanupScan(cleanupLease, canIssueStatement) {
+		if (!canIssueCleanupStatement(canIssueStatement)) return false;
+		if (!cleanupLease) return true;
+		return await this.holdsCleanupLease(cleanupLease) && canIssueCleanupStatement(canIssueStatement);
+	}
+	/**
+	* Reads the lease row on its own so a lost lease can short-circuit a sweep.
+	*
+	* As a row-level `EXISTS` inside a `LIMIT`ed scan this predicate is constant
+	* across every candidate row: when it is false the limit is unreachable and
+	* the scan reads the whole `created_at` range before returning nothing.
+	* Mutating statements still carry {@link activeCleanupLeaseExpression},
+	* which is what actually fences a displaced owner.
+	*/
+	async holdsCleanupLease(cleanupLease) {
+		let query = this.db.selectFrom("_emdash_media_usage_cleanup").select("task_key").where("task_key", "=", "projection_gc").where("lease_token", "=", cleanupLease.leaseToken).where(this.cleanupLeaseExpiryIsInFuture("_emdash_media_usage_cleanup.lease_expires_at"));
+		if (isPostgres(this.db)) query = query.forUpdate();
+		return await query.executeTakeFirst() !== void 0;
+	}
 	activeCleanupLeaseExpression(cleanupLease) {
 		const rowLock = isPostgres(this.db) ? sql` FOR UPDATE` : sql``;
 		return sql`EXISTS (
@@ -982,6 +1681,180 @@ var MediaUsageRepository = class {
 		}));
 		for (const rowBatch of chunks(rows, OCCURRENCE_INSERT_BATCH_SIZE)) await db.insertInto("_emdash_media_usage").values(rowBatch).execute();
 	}
+	async insertBatchOccurrences(rows) {
+		for (const rowBatch of chunkJsonRows(rows)) await sql`
+				WITH input AS (${this.occurrenceBatchInput(JSON.stringify(rowBatch))})
+				INSERT INTO _emdash_media_usage (
+					id, source_key, generation, field_slug, field_path, occurrence_index,
+					reference_type, media_id, provider, provider_asset_id, media_kind,
+					mime_type, created_at
+				)
+				SELECT
+					id, source_key, generation, field_slug, field_path, occurrence_index,
+					reference_type, media_id, provider, provider_asset_id, media_kind,
+					mime_type, created_at
+				FROM input
+				WHERE EXISTS (
+					SELECT 1
+					FROM _emdash_media_usage_generation_writes AS writer
+					WHERE writer.source_key = input.source_key
+						AND writer.generation = input.generation
+						AND writer.lease_token = input.lease_token
+						AND ${this.generationWriteLeaseExpiryIsInFuture("writer.expires_at")}
+				)
+			`.execute(this.db);
+	}
+	occurrenceBatchInput(payload) {
+		if (isPostgres(this.db)) return sql`
+				SELECT
+					entry.value ->> 'id' AS id,
+					entry.value ->> 'source_key' AS source_key,
+					entry.value ->> 'generation' AS generation,
+					entry.value ->> 'field_slug' AS field_slug,
+					entry.value ->> 'field_path' AS field_path,
+					CAST(entry.value ->> 'occurrence_index' AS integer) AS occurrence_index,
+					entry.value ->> 'reference_type' AS reference_type,
+					entry.value ->> 'media_id' AS media_id,
+					entry.value ->> 'provider' AS provider,
+					entry.value ->> 'provider_asset_id' AS provider_asset_id,
+					entry.value ->> 'media_kind' AS media_kind,
+					entry.value ->> 'mime_type' AS mime_type,
+					entry.value ->> 'created_at' AS created_at,
+					entry.value ->> 'lease_token' AS lease_token
+				FROM jsonb_array_elements(${payload}::jsonb) AS entry(value)
+			`;
+		return sql`
+			SELECT
+				json_extract(entry.value, '$.id') AS id,
+				json_extract(entry.value, '$.source_key') AS source_key,
+				json_extract(entry.value, '$.generation') AS generation,
+				json_extract(entry.value, '$.field_slug') AS field_slug,
+				json_extract(entry.value, '$.field_path') AS field_path,
+				CAST(json_extract(entry.value, '$.occurrence_index') AS integer) AS occurrence_index,
+				json_extract(entry.value, '$.reference_type') AS reference_type,
+				json_extract(entry.value, '$.media_id') AS media_id,
+				json_extract(entry.value, '$.provider') AS provider,
+				json_extract(entry.value, '$.provider_asset_id') AS provider_asset_id,
+				json_extract(entry.value, '$.media_kind') AS media_kind,
+				json_extract(entry.value, '$.mime_type') AS mime_type,
+				json_extract(entry.value, '$.created_at') AS created_at,
+				json_extract(entry.value, '$.lease_token') AS lease_token
+			FROM json_each(${payload}) AS entry
+		`;
+	}
+	sourceBatchInput(payload) {
+		if (isPostgres(this.db)) return sql`
+				SELECT
+					entry.value ->> 'source_key' AS source_key,
+					entry.value ->> 'source_type' AS source_type,
+					entry.value ->> 'collection_id' AS collection_id,
+					entry.value ->> 'collection_slug' AS collection_slug,
+					entry.value ->> 'content_id' AS content_id,
+					entry.value ->> 'source_variant' AS source_variant,
+					entry.value ->> 'locale' AS locale,
+					entry.value ->> 'translation_group' AS translation_group,
+					entry.value ->> 'content_slug' AS content_slug,
+					entry.value ->> 'content_title' AS content_title,
+					entry.value ->> 'content_status' AS content_status,
+					entry.value ->> 'content_scheduled_at' AS content_scheduled_at,
+					entry.value ->> 'content_deleted_at' AS content_deleted_at,
+					entry.value ->> 'revision_id' AS revision_id,
+					entry.value ->> 'current_generation' AS current_generation,
+					CAST(entry.value ->> 'schema_version' AS integer) AS schema_version,
+					entry.value ->> 'source_updated_at' AS source_updated_at,
+					CAST(entry.value ->> 'source_version' AS bigint) AS source_version,
+					entry.value ->> 'source_fingerprint' AS source_fingerprint,
+					CAST(entry.value ->> 'identity_version' AS integer) AS identity_version,
+					entry.value ->> 'source_completeness' AS source_completeness,
+					entry.value ->> 'last_attempted_at' AS last_attempted_at,
+					entry.value ->> 'last_error_code' AS last_error_code,
+					entry.value ->> 'indexed_at' AS indexed_at,
+					entry.value ->> 'updated_at' AS updated_at,
+					entry.value ->> 'lease_token' AS lease_token,
+					entry.value ->> 'expected_generation' AS expected_generation,
+					entry.value ->> 'expected_collection_id' AS expected_collection_id,
+					entry.value ->> 'expected_updated_at' AS expected_updated_at,
+					entry.value ->> 'expected_source_fingerprint' AS expected_source_fingerprint,
+					entry.value ->> 'expected_source_updated_at' AS expected_source_updated_at,
+					CAST(entry.value ->> 'expected_source_version' AS bigint) AS expected_source_version,
+					CAST(entry.value ->> 'expected_identity_version' AS integer) AS expected_identity_version,
+					entry.value ->> 'expected_revision_id' AS expected_revision_id,
+					entry.value ->> 'expected_source_completeness' AS expected_source_completeness,
+					entry.value ->> 'expected_last_attempted_at' AS expected_last_attempted_at,
+					entry.value ->> 'expected_last_error_code' AS expected_last_error_code
+				FROM jsonb_array_elements(${payload}::jsonb) AS entry(value)
+			`;
+		return sql`
+			SELECT
+				json_extract(entry.value, '$.source_key') AS source_key,
+				json_extract(entry.value, '$.source_type') AS source_type,
+				json_extract(entry.value, '$.collection_id') AS collection_id,
+				json_extract(entry.value, '$.collection_slug') AS collection_slug,
+				json_extract(entry.value, '$.content_id') AS content_id,
+				json_extract(entry.value, '$.source_variant') AS source_variant,
+				json_extract(entry.value, '$.locale') AS locale,
+				json_extract(entry.value, '$.translation_group') AS translation_group,
+				json_extract(entry.value, '$.content_slug') AS content_slug,
+				json_extract(entry.value, '$.content_title') AS content_title,
+				json_extract(entry.value, '$.content_status') AS content_status,
+				json_extract(entry.value, '$.content_scheduled_at') AS content_scheduled_at,
+				json_extract(entry.value, '$.content_deleted_at') AS content_deleted_at,
+				json_extract(entry.value, '$.revision_id') AS revision_id,
+				json_extract(entry.value, '$.current_generation') AS current_generation,
+				CAST(json_extract(entry.value, '$.schema_version') AS integer) AS schema_version,
+				json_extract(entry.value, '$.source_updated_at') AS source_updated_at,
+				CAST(json_extract(entry.value, '$.source_version') AS integer) AS source_version,
+				json_extract(entry.value, '$.source_fingerprint') AS source_fingerprint,
+				CAST(json_extract(entry.value, '$.identity_version') AS integer) AS identity_version,
+				json_extract(entry.value, '$.source_completeness') AS source_completeness,
+				json_extract(entry.value, '$.last_attempted_at') AS last_attempted_at,
+				json_extract(entry.value, '$.last_error_code') AS last_error_code,
+				json_extract(entry.value, '$.indexed_at') AS indexed_at,
+				json_extract(entry.value, '$.updated_at') AS updated_at,
+				json_extract(entry.value, '$.lease_token') AS lease_token,
+				json_extract(entry.value, '$.expected_generation') AS expected_generation,
+				json_extract(entry.value, '$.expected_collection_id') AS expected_collection_id,
+				json_extract(entry.value, '$.expected_updated_at') AS expected_updated_at,
+				json_extract(entry.value, '$.expected_source_fingerprint') AS expected_source_fingerprint,
+				json_extract(entry.value, '$.expected_source_updated_at') AS expected_source_updated_at,
+				CAST(json_extract(entry.value, '$.expected_source_version') AS integer) AS expected_source_version,
+				CAST(json_extract(entry.value, '$.expected_identity_version') AS integer) AS expected_identity_version,
+				json_extract(entry.value, '$.expected_revision_id') AS expected_revision_id,
+				json_extract(entry.value, '$.expected_source_completeness') AS expected_source_completeness,
+				json_extract(entry.value, '$.expected_last_attempted_at') AS expected_last_attempted_at,
+				json_extract(entry.value, '$.expected_last_error_code') AS expected_last_error_code
+			FROM json_each(${payload}) AS entry
+		`;
+	}
+	generationWriteBatchInput(payload) {
+		if (isPostgres(this.db)) return sql`
+				SELECT
+					entry.value ->> 'source_key' AS source_key,
+					entry.value ->> 'collection_id' AS collection_id,
+					entry.value ->> 'collection_slug' AS collection_slug,
+					entry.value ->> 'generation' AS generation,
+					entry.value ->> 'lease_token' AS lease_token,
+					entry.value ->> 'expires_at' AS expires_at,
+					entry.value ->> 'created_at' AS created_at
+				FROM jsonb_array_elements(${payload}::jsonb) AS entry(value)
+			`;
+		return sql`
+			SELECT
+				json_extract(entry.value, '$.source_key') AS source_key,
+				json_extract(entry.value, '$.collection_id') AS collection_id,
+				json_extract(entry.value, '$.collection_slug') AS collection_slug,
+				json_extract(entry.value, '$.generation') AS generation,
+				json_extract(entry.value, '$.lease_token') AS lease_token,
+				json_extract(entry.value, '$.expires_at') AS expires_at,
+				json_extract(entry.value, '$.created_at') AS created_at
+			FROM json_each(${payload}) AS entry
+		`;
+	}
+	batchRefsMatch(left, right) {
+		const leftRef = sql.ref(left);
+		const rightRef = sql.ref(right);
+		return isPostgres(this.db) ? sql`${leftRef} IS NOT DISTINCT FROM ${rightRef}` : sql`${leftRef} IS ${rightRef}`;
+	}
 	async lockCanonicalSourceCollection(db, source) {
 		if (source.collectionId === void 0 || source.collectionId === null) return true;
 		if (!source.collectionSlug) return false;
@@ -1507,10 +2380,6 @@ function rowToIndexStatus(row) {
 	};
 }
 
-//#endregion
-//#region src/media/usage/types.ts
-const CONTENT_SOURCE_SCHEMA_VERSION = 1;
-
 //#endregion
 //#region src/media/usage/content-fields.ts
 async function buildContentMediaUsageFieldFingerprint(discovery) {
@@ -1627,13 +2496,7 @@ function extractMediaUsageOccurrences({ fields, data }) {
 	for (const field of fields) {
 		const value = data[field.slug];
 		if (field.type === "image") {
-			addOccurrence(occurrences, seen, {
-				fieldSlug: field.slug,
-				fieldPath: field.slug,
-				referenceType: "image_field",
-				value,
-				fallbackKind: "image"
-			});
+			addImageOccurrences(occurrences, seen, field.slug, field.slug, value);
 			continue;
 		}
 		if (field.type === "file") {
@@ -1660,16 +2523,26 @@ function extractRepeaterOccurrences(occurrences, seen, fieldSlug, value, subFiel
 		if (!isRecord$1(item)) continue;
 		for (const subField of subFields) {
 			if (subField.type !== "image") continue;
-			addOccurrence(occurrences, seen, {
-				fieldSlug,
-				fieldPath: `${fieldSlug}[${itemIndex}].${subField.slug}`,
-				referenceType: "image_field",
-				value: item[subField.slug],
-				fallbackKind: "image"
-			});
+			addImageOccurrences(occurrences, seen, fieldSlug, `${fieldSlug}[${itemIndex}].${subField.slug}`, item[subField.slug]);
 		}
 	}
 }
+function addImageOccurrences(occurrences, seen, fieldSlug, fieldPath, value) {
+	addOccurrence(occurrences, seen, {
+		fieldSlug,
+		fieldPath,
+		referenceType: "image_field",
+		value,
+		fallbackKind: "image"
+	});
+	if (isRecord$1(value) && value.darkVariant != null) addOccurrence(occurrences, seen, {
+		fieldSlug,
+		fieldPath: `${fieldPath}.darkVariant`,
+		referenceType: "image_field",
+		value: value.darkVariant,
+		fallbackKind: "image"
+	});
+}
 function extractPortableTextOccurrences(occurrences, seen, fieldSlug, value) {
 	if (!Array.isArray(value)) return;
 	for (const [blockIndex, block] of value.entries()) {
@@ -1844,14 +2717,38 @@ const CONTENT_SYSTEM_COLUMNS = [
 	"translation_group"
 ];
 async function loadContentMediaUsageSnapshots(db, collectionSlug, contentId, fieldDiscovery, options = {}) {
-	validateIdentifier(collectionSlug, "collection slug");
-	if (options.identityVersion !== void 0 && !options.collectionId) throw new Error("Canonical media usage snapshots require a collection identity");
-	const discovery = fieldDiscovery ?? await loadContentMediaUsageFields(db, collectionSlug);
-	const row = await loadContentRow(db, collectionSlug, contentId, [...discovery.extractionFields.map((field) => field.slug), ...discovery.displayFieldSlugs], options.collectionId);
-	if (!row) return {
+	return (await loadContentMediaUsageSnapshotsBatch(db, collectionSlug, [contentId], fieldDiscovery, options)).get(contentId) ?? {
 		success: false,
 		error: "CONTENT_NOT_FOUND"
 	};
+}
+async function loadContentMediaUsageSnapshotsBatch(db, collectionSlug, contentIds, fieldDiscovery, options = {}, control = {}) {
+	validateIdentifier(collectionSlug, "collection slug");
+	if (options.identityVersion !== void 0 && !options.collectionId) throw new Error("Canonical media usage snapshots require a collection identity");
+	const discovery = fieldDiscovery ?? await loadContentMediaUsageFields(db, collectionSlug);
+	const rows = await loadContentRows(db, collectionSlug, contentIds, [...discovery.extractionFields.map((field) => field.slug), ...discovery.displayFieldSlugs], options.collectionId);
+	const revisions = await loadRevisionRows(db, Array.from(rows.values(), (row) => readNullableString(row.draft_revision_id)).filter((revisionId) => revisionId !== null));
+	const results = /* @__PURE__ */ new Map();
+	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 = 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 !== void 0 && occurrenceCount + itemOccurrenceCount > control.maxOccurrenceCount || control.maxProjectionBytes !== void 0 && projectionBytes + itemProjectionBytes > control.maxProjectionBytes)) break;
+		results.set(contentId, result);
+		occurrenceCount += itemOccurrenceCount;
+		projectionBytes += itemProjectionBytes;
+	}
+	return results;
+}
+async function buildContentMediaUsageSnapshots(row, collectionSlug, discovery, options, revisions) {
 	const collectionId = readString(row[CONTENT_COLLECTION_ID_RESULT]);
 	if (!collectionId) throw new Error("Media usage snapshot query did not return a collection identity");
 	const columnsData = projectData(row, discovery.extractionFields.map((field) => field.slug));
@@ -1894,7 +2791,7 @@ async function loadContentMediaUsageSnapshots(db, collectionSlug, contentId, fie
 			sourceVariant: "draft_overlay",
 			revisionId: draftRevisionId
 		});
-		const revisionResult = await loadRevisionRow(db, draftRevisionId);
+		const revisionResult = revisions.get(draftRevisionId);
 		if (!revisionResult) return {
 			success: false,
 			error: "DRAFT_REVISION_NOT_FOUND",
@@ -1957,40 +2854,52 @@ async function loadContentMediaUsageSnapshots(db, collectionSlug, contentId, fie
 		snapshots
 	};
 }
-async function loadContentRow(db, collectionSlug, contentId, fieldSlugs, expectedCollectionId) {
+async function loadContentRows(db, collectionSlug, contentIds, fieldSlugs, expectedCollectionId) {
 	const tableName = getContentTableName(collectionSlug);
 	const columnRefs = uniqueColumns([...CONTENT_SYSTEM_COLUMNS, ...fieldSlugs]).map((column) => sql.ref(`content.${column}`));
-	return (await sql`
+	const rows = /* @__PURE__ */ new Map();
+	const uniqueContentIds = [...new Set(contentIds)];
+	if (uniqueContentIds.length === 0) return rows;
+	const result = await sql`
+		WITH requested AS (${jsonTextValues(db, uniqueContentIds)})
 		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)).rows[0] ?? null;
-}
-async function loadRevisionRow(db, revisionId) {
-	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
-		}
-	};
+	`.execute(db);
+	for (const row of result.rows) {
+		const contentId = readString(row.id);
+		if (contentId) rows.set(contentId, row);
+	}
+	return rows;
+}
+async function loadRevisionRows(db, revisionIds) {
+	const revisions = /* @__PURE__ */ new Map();
+	const uniqueRevisionIds = [...new Set(revisionIds)];
+	if (uniqueRevisionIds.length === 0) return revisions;
+	const rows = await sql`
+		WITH requested AS (${jsonTextValues(db, uniqueRevisionIds)})
+		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) {
 	const { collectionId, collectionSlug, identityVersion, row, displayData, sourceVariant, revisionId } = input;
@@ -2102,8 +3011,11 @@ const CONTENT_USAGE_LOCKS_KEY = Symbol.for("emdash.mediaUsage.contentLocks");
 const CONTENT_USAGE_COLLECTION_LOCKS_KEY = Symbol.for("emdash.mediaUsage.collectionLocks");
 const CONTENT_USAGE_REFRESH_MAX_ATTEMPTS = 2;
 const MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS = Object.freeze({
-	maxOccurrenceMutationUnitsPerClaim: 12,
-	maxProjectionMutationBytesPerClaim: 512 * 1024
+	maxOccurrenceMutationUnitsPerClaim: 500,
+	maxProjectionMutationBytesPerVariant: 2e6,
+	maxProjectionMutationBytesPerClaim: 4e6,
+	maxOccurrenceMutationUnitsPerBatch: 5e4,
+	maxProjectionMutationBytesPerBatch: 16e6
 });
 const ZERO_RESULT = {
 	success: true,
@@ -2111,10 +3023,10 @@ const ZERO_RESULT = {
 	deletedSourceCount: 0,
 	failedSourceCount: 0
 };
-function createContentMediaUsageAdmissionBudget() {
+function createContentMediaUsageAdmissionBudget(limits = {}) {
 	return {
-		remainingOccurrenceMutationUnits: MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxOccurrenceMutationUnitsPerClaim,
-		remainingProjectionMutationBytes: MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxProjectionMutationBytesPerClaim,
+		remainingOccurrenceMutationUnits: limits.maxOccurrenceMutationUnits ?? MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxOccurrenceMutationUnitsPerClaim,
+		remainingProjectionMutationBytes: limits.maxProjectionMutationBytes ?? MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxProjectionMutationBytesPerClaim,
 		hasReservedMutation: false
 	};
 }
@@ -2123,20 +3035,23 @@ async function planContentMediaUsageProjectionAdmission(repo, snapshots, observe
 	const absentSources = canonicalSourceKeys.filter((sourceKey) => !snapshotSourceKeys.has(sourceKey)).map((sourceKey) => observedSources.get(sourceKey)).filter((source) => source !== void 0);
 	let deletionOccurrenceUnits = 0;
 	let deletionBytes = 0;
+	let largestDeletionBytes = 0;
 	for (const source of absentSources) {
 		const measurement = await repo.measureSourceGenerationDeletion(source.sourceKey, source.currentGeneration, MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxOccurrenceMutationUnitsPerClaim);
 		if (measurement.exceedsOccurrenceLimit) return budget.hasReservedMutation ? { outcome: "claim_budget_deferred" } : { 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 = /* @__PURE__ */ new Set();
-	let cost = projectionAdmissionCost(snapshots, noOpSourceKeys, deletionOccurrenceUnits, deletionBytes);
+	let cost = projectionAdmissionCost(snapshots, noOpSourceKeys, deletionOccurrenceUnits, deletionBytes, largestDeletionBytes);
 	if (exceedsProjectionAdmissionLimits(cost)) {
 		for (const snapshot of snapshots) {
 			const expectedSource = observedSources.get(snapshot.source.sourceKey);
 			if (expectedSource && await repo.projectionMatchesExpectedSource(snapshot.source, expectedSource)) noOpSourceKeys.add(snapshot.source.sourceKey);
 		}
-		cost = projectionAdmissionCost(snapshots, noOpSourceKeys, deletionOccurrenceUnits, deletionBytes);
+		cost = projectionAdmissionCost(snapshots, noOpSourceKeys, deletionOccurrenceUnits, deletionBytes, largestDeletionBytes);
 	}
 	if (exceedsProjectionAdmissionLimits(cost)) return budget.hasReservedMutation ? { outcome: "claim_budget_deferred" } : { outcome: "intrinsic_resource_limit" };
 	if (cost.occurrenceMutationUnits > budget.remainingOccurrenceMutationUnits || cost.projectionMutationBytes > budget.remainingProjectionMutationBytes) return { outcome: "claim_budget_deferred" };
@@ -2150,19 +3065,21 @@ async function planContentMediaUsageProjectionAdmission(repo, snapshots, observe
 		...cost
 	};
 }
-function projectionAdmissionCost(snapshots, noOpSourceKeys, deletionOccurrenceUnits, deletionBytes) {
+function projectionAdmissionCost(snapshots, noOpSourceKeys, deletionOccurrenceUnits, deletionBytes, largestDeletionBytes) {
 	return snapshots.reduce((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
+		projectionMutationBytes: deletionBytes,
+		largestProjectionMutationBytes: largestDeletionBytes
 	});
 }
 function exceedsProjectionAdmissionLimits(cost) {
-	return cost.occurrenceMutationUnits > MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxOccurrenceMutationUnitsPerClaim || cost.projectionMutationBytes > MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxProjectionMutationBytesPerClaim;
+	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;
 }
 function storedMediaUsageSourceByteLength(source) {
 	return new TextEncoder().encode(JSON.stringify(source)).byteLength;
@@ -2171,13 +3088,133 @@ async function refreshContentMediaUsage(db, collectionSlug, contentId) {
 	validateIdentifier(collectionSlug, "collection slug");
 	return withContentUsageCollectionLock(collectionSlug, () => withContentUsageLock(collectionSlug, contentId, () => refreshContentMediaUsageUnlocked(db, collectionSlug, contentId, {})));
 }
-async function refreshContentMediaUsageForWork(db, collectionId, collectionSlug, contentId) {
-	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
-	})));
+async function refreshContentMediaUsageForWorkBatch(db, items, options = {}) {
+	const results = /* @__PURE__ */ new Map();
+	const batchBudget = createContentMediaUsageAdmissionBudget({
+		maxOccurrenceMutationUnits: MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxOccurrenceMutationUnitsPerBatch,
+		maxProjectionMutationBytes: MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxProjectionMutationBytesPerBatch
+	});
+	const collections = /* @__PURE__ */ new Map();
+	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 = [];
+			const newSourceKeys = /* @__PURE__ */ new Map();
+			const existingSourceProjections = [];
+			const unchangedSourceProjections = [];
+			const existingSourceKeys = /* @__PURE__ */ new Map();
+			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]));
+				const existing = itemSourceKeys.map((sourceKey) => observedSources.get(sourceKey)).filter((source) => source !== void 0);
+				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 = [];
+				const unchanged = [];
+				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(db, collectionSlug, contentId, options) {
 	try {
@@ -2212,17 +3249,13 @@ async function refreshContentMediaUsageUnlocked(db, collectionSlug, contentId, o
 async function refreshContentMediaUsageAttempt(db, collectionSlug, contentId, options) {
 	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, void 0, options.collectionId ? {
+	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
 	} : void 0);
 	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(repo, [], observedSources, canonicalSourceKeys, options.admissionBudget);
 			if (admission.outcome !== "admitted") return admissionFailureResult(admission.outcome);
@@ -2237,11 +3270,7 @@ async function refreshContentMediaUsageAttempt(db, collectionSlug, contentId, op
 		}
 		return options.durableWork ? snapshotFailureResult(snapshotsResult) : 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,
@@ -2267,11 +3296,7 @@ async function refreshContentMediaUsageAttempt(db, collectionSlug, contentId, op
 		});
 		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,
@@ -2299,6 +3324,9 @@ async function refreshContentMediaUsageAttempt(db, collectionSlug, contentId, op
 		failedSourceCount: 0
 	};
 }
+function contentRefreshKey(collectionId, contentId) {
+	return `${collectionId}\u0000${contentId}`;
+}
 function contentSourceKeys(collectionSlug, contentId, collectionId) {
 	return MEDIA_USAGE_CONTENT_SOURCE_VARIANTS.map((sourceVariant) => buildContentMediaUsageSourceKey({
 		collectionId,
@@ -2556,5 +3584,5 @@ function getContentUsageCollectionLocks() {
 }
 
 //#endregion
-export { loadContentMediaUsageFields as _, findNonTranslatableSiblingContentIds as a, markContentMediaUsageCollectionStaleSafely as c, withContentUsageCollectionLock as d, loadContentMediaUsageSnapshots as f, buildContentMediaUsageFieldFingerprint as g, MediaUsageFieldDiscoveryError as h, deleteContentMediaUsageCollection as i, refreshContentMediaUsageAfterWrite as l, buildContentMediaUsageSourceKey as m, CONTENT_MEDIA_USAGE_COLLECTION_SCOPE as n, invalidateContentMediaUsageSchemaChange as o, MEDIA_USAGE_CONTENT_SOURCE_VARIANTS as p, deleteContentMediaUsage as r, markContentMediaUsageCollectionStale as s, CONTENT_MEDIA_USAGE_ADAPTER_ID as t, refreshContentMediaUsageForWork as u, CONTENT_SOURCE_SCHEMA_VERSION as v, MediaUsageRepository as y };
-//# sourceMappingURL=content-refresh-B_8SJzuU.mjs.map
+export { buildContentMediaUsageFieldFingerprint as _, deleteContentMediaUsageCollection as a, jsonTextValues as b, markContentMediaUsageCollectionStale as c, refreshContentMediaUsageForWorkBatch as d, withContentUsageCollectionLock as f, MediaUsageFieldDiscoveryError as g, buildContentMediaUsageSourceKey as h, deleteContentMediaUsage as i, markContentMediaUsageCollectionStaleSafely as l, MEDIA_USAGE_CONTENT_SOURCE_VARIANTS as m, CONTENT_MEDIA_USAGE_COLLECTION_SCOPE as n, findNonTranslatableSiblingContentIds as o, loadContentMediaUsageSnapshots as p, contentRefreshKey as r, invalidateContentMediaUsageSchemaChange as s, CONTENT_MEDIA_USAGE_ADAPTER_ID as t, refreshContentMediaUsageAfterWrite as u, loadContentMediaUsageFields as v, CONTENT_SOURCE_SCHEMA_VERSION as x, MediaUsageRepository as y };
+//# sourceMappingURL=content-refresh-Bwp-8yGy.mjs.map