emdash 0.32.0 → 0.34.0

package/dist/content-refresh-DNERP4-f.mjs

@@ -0,0 +1,2560 @@
+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-DfPax1I0.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 { sql } from "kysely";
+import { ulid } from "ulidx";
+
+//#region src/media/usage/projection-fingerprint.ts
+const MEDIA_USAGE_PROJECTION_FINGERPRINT_VERSION = 1;
+const FINGERPRINT_PREFIX = `media-usage-projection:v${MEDIA_USAGE_PROJECTION_FINGERPRINT_VERSION}:sha256:`;
+const FINGERPRINT_PATTERN = new RegExp(`^${FINGERPRINT_PREFIX}[a-f0-9]{64}$`);
+async function buildMediaUsageProjectionFingerprint(input) {
+	if (!input.collectionId) throw new Error("Media usage projection fingerprints require a collection identity");
+	const canonicalOccurrences = input.occurrences.map((occurrence) => ({
+		fieldSlug: occurrence.fieldSlug,
+		fieldPath: occurrence.fieldPath,
+		occurrenceIndex: occurrence.occurrenceIndex ?? 0,
+		referenceType: occurrence.referenceType,
+		mediaId: occurrence.mediaId,
+		provider: occurrence.provider,
+		providerAssetId: occurrence.providerAssetId,
+		mediaKind: occurrence.mediaKind ?? null,
+		mimeType: occurrence.mimeType ?? null
+	})).map((occurrence) => ({
+		occurrence,
+		key: canonicalJson(occurrence)
+	})).toSorted((a, b) => compareCanonicalStrings(a.key, b.key)).map(({ occurrence }) => occurrence);
+	return buildCanonicalSha256Fingerprint(FINGERPRINT_PREFIX, {
+		fingerprintVersion: MEDIA_USAGE_PROJECTION_FINGERPRINT_VERSION,
+		collectionId: input.collectionId,
+		extractionSchema: normalizeExtractionFields(input.extractionFields),
+		source: {
+			sourceKey: input.source.sourceKey,
+			sourceType: input.source.sourceType,
+			collectionSlug: input.source.collectionSlug ?? null,
+			contentId: input.source.contentId ?? null,
+			sourceVariant: input.source.sourceVariant,
+			locale: input.source.locale ?? null,
+			translationGroup: input.source.translationGroup ?? null,
+			contentSlug: input.source.contentSlug ?? null,
+			contentTitle: input.source.contentTitle ?? null,
+			contentStatus: input.source.contentStatus ?? null,
+			contentScheduledAt: input.source.contentScheduledAt ?? null,
+			contentDeletedAt: input.source.contentDeletedAt ?? null,
+			revisionId: input.source.revisionId ?? null,
+			schemaVersion: input.source.schemaVersion ?? 1,
+			sourceCompleteness: input.source.sourceCompleteness ?? "complete"
+		},
+		occurrences: canonicalOccurrences
+	});
+}
+async function buildCanonicalSha256Fingerprint(prefix, payload) {
+	const encodedPayload = new TextEncoder().encode(canonicalJson(payload));
+	const digest = await crypto.subtle.digest("SHA-256", encodedPayload);
+	return {
+		fingerprint: `${prefix}${Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("")}`,
+		byteLength: encodedPayload.byteLength
+	};
+}
+function normalizeExtractionFields(fields) {
+	return fields.map((field) => {
+		if (field.type !== "repeater") return {
+			slug: field.slug,
+			type: field.type
+		};
+		return {
+			slug: field.slug,
+			type: field.type,
+			subFields: (field.validation?.subFields ?? []).map((subField) => ({
+				slug: subField.slug,
+				type: subField.type
+			})).toSorted((a, b) => compareCanonicalStrings(a.slug, b.slug))
+		};
+	}).toSorted((a, b) => compareCanonicalStrings(String(a.slug), String(b.slug)));
+}
+function compareCanonicalStrings(a, b) {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+function isMediaUsageProjectionFingerprint(value) {
+	return typeof value === "string" && FINGERPRINT_PATTERN.test(value);
+}
+function canonicalJson(value) {
+	return JSON.stringify(canonicalize(value));
+}
+function canonicalize(value) {
+	if (value === void 0) return null;
+	if (typeof value === "bigint") return value.toString();
+	if (typeof value === "number") return Number.isFinite(value) ? value : null;
+	if (Array.isArray(value)) return value.map((item) => canonicalize(item));
+	if (!isRecord$3(value)) return value;
+	const canonical = {};
+	for (const key of Object.keys(value).toSorted()) canonical[key] = canonicalize(value[key]);
+	return canonical;
+}
+function isRecord$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/database/repositories/media-usage.ts
+const OCCURRENCE_BIND_COLUMNS = 13;
+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));
+function cleanupDeleteBatchSize(cleanupLease) {
+	return cleanupLease ? SQL_BATCH_SIZE - 3 : SQL_BATCH_SIZE;
+}
+function canIssueCleanupStatement(canIssueStatement) {
+	return canIssueStatement?.() ?? true;
+}
+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;
+}
+const CONTENT_SOURCE_ELIGIBILITY = sql`(
+	s.source_variant = 'draft_overlay'
+	OR (
+		s.source_variant = 'columns'
+		AND (
+			s.content_status = 'published'
+			OR NOT EXISTS (
+				SELECT 1
+				FROM _emdash_media_usage_sources AS overlay
+				WHERE overlay.source_type = 'content'
+					AND overlay.collection_slug = s.collection_slug
+					AND overlay.content_id = s.content_id
+					AND overlay.source_variant = 'draft_overlay'
+					AND ${contentSourceMatchesActiveCollection("overlay", "s.collection_id")}
+			)
+		)
+	)
+)`;
+function contentSourceMatchesActiveCollection(source, currentCollectionId) {
+	return sql`(
+		NOT EXISTS (
+			SELECT 1
+			FROM _emdash_media_usage_activation AS activation
+			WHERE activation.task_key = 'incremental_capture'
+				AND activation.state = 'active'
+		)
+		OR (
+			${sql.ref(`${source}.collection_id`)} = ${sql.ref(currentCollectionId)}
+			AND ${sql.ref(`${source}.identity_version`)} = 1
+		)
+	)`;
+}
+/** Persistence-only repository for the internal media usage projection tables. */
+var MediaUsageRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async replaceSource(source, occurrences) {
+		const generation = ulid();
+		if (!await this.withGenerationWriteLease(source, generation, async (leaseToken, now) => {
+			await withTransaction(this.db, async (trx) => {
+				if (!await this.lockCanonicalSourceCollection(trx, source)) throw new Error(`Media usage collection is no longer current for ${source.sourceKey}`);
+				await this.insertOccurrences(trx, source.sourceKey, generation, occurrences, now);
+				if (!await this.upsertSource(trx, source, generation, now, leaseToken)) throw new Error(`Media usage generation lease expired for ${source.sourceKey}`);
+			});
+		})) throw new Error(`Media usage collection is no longer current for ${source.sourceKey}`);
+		const replaced = await this.findSource(source.sourceKey);
+		if (!replaced) throw new Error(`Media usage source ${source.sourceKey} was not persisted`);
+		return replaced;
+	}
+	async replaceSourceIfCurrent(source, occurrences, expectedCurrentGeneration) {
+		if (expectedCurrentGeneration !== null && await this.projectionMatchesCurrentGeneration(source, expectedCurrentGeneration)) return {
+			replaced: false,
+			unchanged: true,
+			source: null
+		};
+		const generation = ulid();
+		let replaced = false;
+		await this.withGenerationWriteLease(source, generation, async (leaseToken, now) => {
+			const row = this.buildSourceRow(source, generation, now);
+			await withTransaction(this.db, async (trx) => {
+				if (!await this.lockCanonicalSourceCollection(trx, source)) return;
+				await this.insertOccurrences(trx, source.sourceKey, generation, occurrences, now);
+				if (expectedCurrentGeneration === null) {
+					replaced = await this.insertSourceIfAbsent(trx, row, leaseToken);
+					return;
+				}
+				replaced = await this.updateSourceIfGeneration(trx, row, expectedCurrentGeneration, leaseToken);
+			});
+		});
+		return {
+			replaced,
+			unchanged: false,
+			source: replaced ? null : await this.findSource(source.sourceKey)
+		};
+	}
+	async findSource(sourceKey) {
+		const row = await this.db.selectFrom("_emdash_media_usage_sources").selectAll().where("source_key", "=", sourceKey).executeTakeFirst();
+		return row ? rowToSource(row) : null;
+	}
+	async findSources(sourceKeys) {
+		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) {
+				const source = rowToSource(row);
+				sources.set(source.sourceKey, source);
+			}
+		}
+		return sources;
+	}
+	async measureSourceGenerationDeletion(sourceKey, generation, maxOccurrences) {
+		if (!Number.isSafeInteger(maxOccurrences) || maxOccurrences < 0) throw new Error("Media usage deletion measurement requires a non-negative row limit");
+		const payload = sql`
+			COALESCE(field_slug, '') || COALESCE(field_path, '') ||
+			COALESCE(reference_type, '') || COALESCE(media_id, '') ||
+			COALESCE(provider, '') || COALESCE(provider_asset_id, '') ||
+			COALESCE(media_kind, '') || COALESCE(mime_type, '')
+		`;
+		const occurrenceBytes = isPostgres(this.db) ? sql`octet_length(${payload})` : sql`length(CAST(${payload} AS BLOB))`;
+		const rows = await this.db.selectFrom("_emdash_media_usage").select(occurrenceBytes.as("occurrence_bytes")).where("source_key", "=", sourceKey).where("generation", "=", generation).limit(maxOccurrences + 1).execute();
+		return {
+			occurrenceCount: rows.length,
+			occurrenceBytes: rows.reduce((total, row) => total + Number(row.occurrence_bytes), 0),
+			exceedsOccurrenceLimit: rows.length > maxOccurrences
+		};
+	}
+	async replaceSourceIfMatching(source, occurrences, expectedSource) {
+		if (expectedSource !== null && await this.projectionMatchesExpectedSource(source, expectedSource)) return {
+			replaced: false,
+			unchanged: true,
+			source: null
+		};
+		const generation = ulid();
+		let replaced = false;
+		await this.withGenerationWriteLease(source, generation, async (leaseToken, now) => {
+			const row = this.buildSourceRow(source, generation, now);
+			await withTransaction(this.db, async (trx) => {
+				if (!await this.lockCanonicalSourceCollection(trx, source)) return;
+				await this.insertOccurrences(trx, source.sourceKey, generation, occurrences, now);
+				if (expectedSource === null) {
+					replaced = await this.insertSourceIfAbsent(trx, row, leaseToken);
+					return;
+				}
+				replaced = await this.updateSourceIfMatching(trx, row, expectedSource, leaseToken);
+			});
+		});
+		return {
+			replaced,
+			unchanged: false,
+			source: replaced ? null : await this.findSource(source.sourceKey)
+		};
+	}
+	async markSourceAttempted(source) {
+		if (source.collectionId !== void 0 && source.collectionId !== null) {
+			const expectedSource = await this.findSource(source.sourceKey);
+			if (!(await this.markSourceAttemptedIfMatching(source, expectedSource)).attempted) throw new Error(`Canonical media usage source ${source.sourceKey} is no longer current`);
+			const attempted = await this.findSource(source.sourceKey);
+			if (!attempted) throw new Error(`Media usage source ${source.sourceKey} was not persisted`);
+			return attempted;
+		}
+		const generation = ulid();
+		await this.withGenerationWriteLease(source, generation, async (leaseToken, now) => {
+			const row = this.buildAttemptedSourceRow(source, generation, now);
+			const updates = this.attemptedSourceUpdateSet(source, row);
+			if (((await this.db.insertInto("_emdash_media_usage_sources").values(row).onConflict((oc) => oc.column("source_key").doUpdateSet(updates)).executeTakeFirst()).numInsertedOrUpdatedRows ?? 0n) <= 0n) throw new Error(`Media usage generation lease expired for ${source.sourceKey}`);
+		});
+		const attempted = await this.findSource(source.sourceKey);
+		if (!attempted) throw new Error(`Media usage source ${source.sourceKey} was not persisted`);
+		return attempted;
+	}
+	async markSourceAttemptedIfMatching(source, expectedSource) {
+		const generation = ulid();
+		let attempted = false;
+		if (expectedSource === null) await this.withGenerationWriteLease(source, generation, async (leaseToken, now) => {
+			const row = this.buildAttemptedSourceRow(source, generation, now);
+			await withTransaction(this.db, async (trx) => {
+				if (!await this.lockCanonicalSourceCollection(trx, source)) return;
+				attempted = await this.persistSourceIfWriteLease(trx, row, leaseToken, sql`ON CONFLICT (source_key) DO NOTHING`);
+			});
+		});
+		else {
+			const row = this.buildAttemptedSourceRow(source, generation, (/* @__PURE__ */ new Date()).toISOString());
+			await withTransaction(this.db, async (trx) => {
+				if (!await this.lockCanonicalSourceCollection(trx, source)) return;
+				attempted = await this.updateAttemptedSourceIfMatching(trx, source, row, expectedSource);
+			});
+		}
+		return {
+			attempted,
+			source: attempted ? null : await this.findSource(source.sourceKey)
+		};
+	}
+	async findActiveEntryCountsByMediaIds(mediaIds) {
+		const uniqueMediaIds = [...new Set(mediaIds)];
+		const counts = new Map(uniqueMediaIds.map((mediaId) => [mediaId, 0]));
+		for (const mediaIdBatch of chunks(uniqueMediaIds, SQL_BATCH_SIZE)) {
+			const visibleEntries = this.currentContentMediaUsageBaseQuery().select([
+				"u.media_id as media_id",
+				"s.collection_slug as collection_slug",
+				"s.content_id as content_id"
+			]).where("u.media_id", "in", mediaIdBatch).where((eb) => eb.not(eb.exists(eb.selectFrom("_emdash_media_usage_sources as deleted_source").select("deleted_source.source_key").where("deleted_source.source_type", "=", "content").whereRef("deleted_source.collection_slug", "=", "s.collection_slug").whereRef("deleted_source.content_id", "=", "s.content_id").where("deleted_source.source_variant", "in", ["columns", "draft_overlay"]).where(contentSourceMatchesActiveCollection("deleted_source", "collection.id")).where("deleted_source.content_deleted_at", "is not", null)))).distinct().as("visible_entries");
+			const rows = await this.db.selectFrom(visibleEntries).select("media_id").select((eb) => eb.fn.countAll().as("usage_count")).groupBy("media_id").execute();
+			for (const row of rows) if (row.media_id !== null) counts.set(row.media_id, Number(row.usage_count));
+		}
+		return counts;
+	}
+	async findCollectionIndexStatusScopes(identity) {
+		return (await this.db.selectFrom("_emdash_collections as collection").leftJoin("_emdash_media_usage_index_status as status", (join) => join.on("status.adapter_id", "=", identity.adapterId).on("status.scope_type", "=", identity.scopeType).onRef("status.scope_key", "=", "collection.slug")).select([
+			"collection.slug as collection_slug",
+			"status.status as status",
+			"status.schema_version as schema_version",
+			"status.reconciliation_required as reconciliation_required"
+		]).orderBy("collection.slug", "asc").execute()).map((row) => ({
+			collectionSlug: row.collection_slug,
+			status: row.status,
+			schemaVersion: row.schema_version === null ? null : Number(row.schema_version),
+			reconciliationRequired: row.reconciliation_required !== null && Number(row.reconciliation_required) !== 0
+		}));
+	}
+	async findCurrentEntryUsagePageByMediaId(mediaId, options = {}) {
+		const requestedLimit = Math.floor(options.limit ?? 50);
+		const limit = Number.isFinite(requestedLimit) ? Math.min(Math.max(1, requestedLimit), 100) : 50;
+		const cursor = options.cursor ? decodeCursor(options.cursor) : null;
+		if (cursor && (cursor.orderValue.length === 0 || cursor.id.length === 0)) throw new InvalidCursorError(options.cursor ?? "");
+		let matchedGroups = this.currentContentMediaUsageBaseQuery().select([
+			"collection.id as collection_id",
+			"s.collection_slug as collection_slug",
+			"s.content_id as content_id"
+		]).where("u.media_id", "=", mediaId).distinct();
+		if (cursor) matchedGroups = matchedGroups.where((eb) => eb.or([eb("s.collection_slug", ">", cursor.orderValue), eb.and([eb("s.collection_slug", "=", cursor.orderValue), eb("s.content_id", ">", cursor.id)])]));
+		matchedGroups = matchedGroups.orderBy("s.collection_slug", "asc").orderBy("s.content_id", "asc").limit(limit + 1);
+		const rows = await this.db.with("matched_groups", () => matchedGroups).with("page_groups", (db) => db.selectFrom("matched_groups").selectAll().orderBy("collection_slug", "asc").orderBy("content_id", "asc").limit(limit)).with("entry_state", (db) => db.selectFrom("page_groups as page").crossJoin("_emdash_media_usage_sources as state").select([
+			"page.collection_id",
+			"page.collection_slug",
+			"page.content_id"
+		]).select((eb) => eb.fn.max("state.content_deleted_at").as("entry_deleted_at")).whereRef("page.collection_slug", "=", "state.collection_slug").whereRef("page.content_id", "=", "state.content_id").where("state.source_type", "=", "content").where("state.source_variant", "in", ["columns", "draft_overlay"]).where(contentSourceMatchesActiveCollection("state", "page.collection_id")).groupBy([
+			"page.collection_id",
+			"page.collection_slug",
+			"page.content_id"
+		])).selectFrom("entry_state as page").crossJoin("_emdash_media_usage_sources as s").crossJoin("_emdash_media_usage as u").whereRef("page.collection_slug", "=", "s.collection_slug").whereRef("page.content_id", "=", "s.content_id").where(contentSourceMatchesActiveCollection("s", "page.collection_id")).whereRef("s.source_key", "=", "u.source_key").whereRef("s.current_generation", "=", "u.generation").select(currentUsageSelect).select("page.entry_deleted_at").select(sql`CASE
+					WHEN (SELECT COUNT(*) FROM matched_groups) > ${limit} THEN 1
+					ELSE 0
+				END`.as("has_more")).where("u.media_id", "=", mediaId).where("s.source_type", "=", "content").where("s.collection_slug", "is not", null).where("s.content_id", "is not", null).where("s.source_variant", "in", ["columns", "draft_overlay"]).where(CONTENT_SOURCE_ELIGIBILITY).orderBy("s.collection_slug", "asc").orderBy("s.content_id", "asc").orderBy("s.source_variant", "asc").orderBy("s.source_key", "asc").orderBy("u.field_path", "asc").orderBy("u.occurrence_index", "asc").orderBy("u.id", "asc").execute();
+		const items = groupUsageRows(rows);
+		const result = { items };
+		if (Number(rows[0]?.has_more ?? 0) === 1 && items.length > 0) {
+			const last = items.at(-1);
+			result.nextCursor = encodeCursor(last.collectionSlug, last.contentId);
+		}
+		return result;
+	}
+	async findCurrentUsageByMediaId(mediaId) {
+		return (await this.db.selectFrom("_emdash_media_usage_sources as s").innerJoin("_emdash_media_usage as u", (join) => join.onRef("u.source_key", "=", "s.source_key").onRef("u.generation", "=", "s.current_generation")).select(currentUsageSelect).where("u.media_id", "=", mediaId).orderBy("s.source_key", "asc").orderBy("u.field_path", "asc").orderBy("u.occurrence_index", "asc").execute()).map(rowToUsageRecord);
+	}
+	async findCurrentUsageByProviderAsset(provider, providerAssetId) {
+		return (await this.db.selectFrom("_emdash_media_usage_sources as s").innerJoin("_emdash_media_usage as u", (join) => join.onRef("u.source_key", "=", "s.source_key").onRef("u.generation", "=", "s.current_generation")).select(currentUsageSelect).where("u.provider", "=", provider).where("u.provider_asset_id", "=", providerAssetId).orderBy("s.source_key", "asc").orderBy("u.field_path", "asc").orderBy("u.occurrence_index", "asc").execute()).map(rowToUsageRecord);
+	}
+	async findCurrentUsagePageByMediaId(mediaId, options = {}) {
+		return this.findCurrentUsagePage((query) => query.where("u.media_id", "=", mediaId), options);
+	}
+	async findCurrentUsagePageByProviderAsset(provider, providerAssetId, options = {}) {
+		return this.findCurrentUsagePage((query) => query.where("u.provider", "=", provider).where("u.provider_asset_id", "=", providerAssetId), options);
+	}
+	async deleteSource(sourceKey) {
+		return this.deleteSources([sourceKey]);
+	}
+	async deleteSourceIfCurrent(sourceKey, expectedCurrentGeneration) {
+		let deleted = false;
+		await withTransaction(this.db, async (trx) => {
+			await this.lockCleanupBeforeSourceDelete(trx);
+			const result = await trx.deleteFrom("_emdash_media_usage_sources").where("source_key", "=", sourceKey).where("current_generation", "=", expectedCurrentGeneration).executeTakeFirst();
+			deleted = Number(result.numDeletedRows ?? 0) > 0;
+			if (!deleted) return;
+			await this.deleteSourceGenerationOccurrences(trx, sourceKey, expectedCurrentGeneration);
+		});
+		return {
+			deleted,
+			source: await this.findSource(sourceKey)
+		};
+	}
+	async deleteSourceIfMatching(sourceKey, expectedSource) {
+		let deleted = false;
+		await withTransaction(this.db, async (trx) => {
+			await this.lockCleanupBeforeSourceDelete(trx);
+			const result = await trx.deleteFrom("_emdash_media_usage_sources").where("source_key", "=", sourceKey).where(this.sourceMatchExpression(expectedSource)).where(this.currentCollectionExists(expectedSource.collectionId, expectedSource.collectionSlug)).executeTakeFirst();
+			deleted = Number(result.numDeletedRows ?? 0) > 0;
+			if (!deleted) return;
+			await this.deleteSourceGenerationOccurrences(trx, sourceKey, expectedSource.currentGeneration);
+		});
+		return {
+			deleted,
+			source: await this.findSource(sourceKey)
+		};
+	}
+	async deleteSourceIfMatchingContentAbsent(sourceKey, expectedSource, collectionSlug, contentId) {
+		validateIdentifier(collectionSlug, "collection slug");
+		const tableName = `ec_${collectionSlug}`;
+		let deleted = false;
+		await withTransaction(this.db, async (trx) => {
+			await this.lockCleanupBeforeSourceDelete(trx);
+			const result = await trx.deleteFrom("_emdash_media_usage_sources").where("source_key", "=", sourceKey).where(this.sourceMatchExpression(expectedSource)).where(this.currentCollectionExists(expectedSource.collectionId, expectedSource.collectionSlug)).where(sql`NOT EXISTS (SELECT 1 FROM ${sql.ref(tableName)} WHERE id = ${contentId})`).executeTakeFirst();
+			deleted = Number(result.numDeletedRows ?? 0) > 0;
+			if (!deleted) return;
+			await this.deleteSourceGenerationOccurrences(trx, sourceKey, expectedSource.currentGeneration);
+		});
+		const contentPresent = deleted ? false : await this.contentRowExists(tableName, contentId);
+		return {
+			deleted,
+			contentPresent,
+			source: deleted || contentPresent ? null : await this.findSource(sourceKey)
+		};
+	}
+	async deleteSources(sourceKeys) {
+		return this.deleteSourceKeys(sourceKeys);
+	}
+	async deleteContentSources(collectionSlug, contentId) {
+		const sourceKeys = (await this.db.selectFrom("_emdash_media_usage_sources").select("source_key").where("source_type", "=", "content").where("collection_slug", "=", collectionSlug).where("content_id", "=", contentId).execute()).map((row) => row.source_key);
+		return this.deleteSourceKeys(sourceKeys);
+	}
+	async deleteCollectionSources(collectionSlug) {
+		let deleted = 0;
+		while (true) {
+			const sourceRows = await this.db.selectFrom("_emdash_media_usage_sources").select("source_key").where("source_type", "=", "content").where("collection_slug", "=", collectionSlug).orderBy("source_key", "asc").limit(SQL_BATCH_SIZE).execute();
+			if (sourceRows.length === 0) break;
+			deleted += await this.deleteSourceKeys(sourceRows.map((row) => row.source_key));
+		}
+		return deleted;
+	}
+	async findCollectionContentSources(collectionSlug, collectionId) {
+		let query = this.db.selectFrom("_emdash_media_usage_sources").selectAll().where("source_type", "=", "content").where("collection_slug", "=", collectionSlug).orderBy("source_key", "asc");
+		if (collectionId !== void 0) query = query.where("collection_id", "=", collectionId);
+		return (await query.execute()).map((row) => rowToSource(row));
+	}
+	async claimMediaUsageCleanup(input) {
+		const leaseDurationSeconds = cleanupDurationSeconds(input.leaseDurationSeconds);
+		const nextEligibleDelaySeconds = cleanupDurationSeconds(input.nextEligibleDelaySeconds);
+		const sweepSafetyWindowSeconds = cleanupDurationSeconds(input.sweepSafetyWindowSeconds);
+		const claimedAt = this.cleanupTimestampOffset(0);
+		const leaseExpiresAt = this.cleanupTimestampOffset(leaseDurationSeconds);
+		const nextEligibleAt = this.cleanupTimestampOffset(nextEligibleDelaySeconds);
+		const sweepBeforeAt = this.cleanupTimestampOffset(-sweepSafetyWindowSeconds);
+		const row = await this.db.updateTable("_emdash_media_usage_cleanup").set({
+			lease_token: input.leaseToken,
+			lease_expires_at: leaseExpiresAt,
+			next_eligible_at: nextEligibleAt,
+			last_started_at: claimedAt,
+			updated_at: claimedAt,
+			scan_before_at: sql`CASE
+					WHEN scan_before_at IS NULL THEN ${sweepBeforeAt}
+					ELSE scan_before_at
+				END`
+		}).where("task_key", "=", "projection_gc").where(this.cleanupTimestampIsDue("next_eligible_at")).where((eb) => eb.or([eb("lease_token", "is", null), this.cleanupTimestampIsDue("lease_expires_at")])).returning([
+			"cursor_created_at",
+			"cursor_id",
+			"last_started_at",
+			"scan_before_at",
+			"consecutive_failures"
+		]).executeTakeFirst();
+		if (!row) return null;
+		if (!row.last_started_at || !row.scan_before_at) throw new Error("Media usage cleanup claim did not persist its database timestamps");
+		return {
+			leaseToken: input.leaseToken,
+			cursor: row.cursor_created_at && row.cursor_id ? {
+				createdAt: row.cursor_created_at,
+				id: row.cursor_id
+			} : null,
+			claimedAt: row.last_started_at,
+			scanBeforeAt: row.scan_before_at,
+			consecutiveFailures: row.consecutive_failures
+		};
+	}
+	async findMediaUsageCleanupCandidates(input) {
+		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",
+			"u.generation as generation",
+			"u.created_at as created_at",
+			"s.current_generation as current_generation",
+			"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)])]));
+		return (await query.execute()).map((row) => ({
+			id: row.id,
+			sourceKey: row.source_key,
+			generation: row.generation,
+			createdAt: row.created_at,
+			currentGeneration: row.current_generation,
+			indexedAt: row.indexed_at,
+			writeLeaseExpiresAt: row.write_lease_expires_at
+		}));
+	}
+	async completeMediaUsageCleanup(input) {
+		const updates = {
+			lease_token: null,
+			lease_expires_at: null,
+			cursor_created_at: input.sweepComplete ? null : input.nextCursor?.createdAt ?? null,
+			cursor_id: input.sweepComplete ? null : input.nextCursor?.id ?? null,
+			...input.sweepComplete ? { scan_before_at: null } : {},
+			consecutive_failures: 0,
+			last_completed_at: this.cleanupTimestampOffset(0),
+			last_candidate_count: input.candidateCount,
+			last_deleted_orphans: input.deletedOrphans,
+			last_deleted_stale: input.deletedStale,
+			last_deleted_abandoned: input.deletedAbandoned,
+			last_deleted_write_leases: input.deletedWriteLeases,
+			last_backlog_lower_bound: input.backlogLowerBound,
+			last_scan_has_more: input.scanHasMore ? 1 : 0,
+			last_duration_ms: input.durationMs,
+			last_error_code: null,
+			updated_at: this.cleanupTimestampOffset(0)
+		};
+		const result = await this.db.updateTable("_emdash_media_usage_cleanup").set(updates).where("task_key", "=", "projection_gc").where("lease_token", "=", input.leaseToken).where(this.cleanupLeaseExpiryIsInFuture("_emdash_media_usage_cleanup.lease_expires_at")).executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) > 0;
+	}
+	async failMediaUsageCleanup(input) {
+		const retryDelaySeconds = cleanupDurationSeconds(input.retryDelaySeconds);
+		const result = await this.db.updateTable("_emdash_media_usage_cleanup").set({
+			lease_token: null,
+			lease_expires_at: null,
+			next_eligible_at: this.cleanupTimestampOffset(retryDelaySeconds),
+			consecutive_failures: input.consecutiveFailures,
+			last_completed_at: this.cleanupTimestampOffset(0),
+			last_duration_ms: input.durationMs,
+			last_error_code: input.errorCode,
+			updated_at: this.cleanupTimestampOffset(0)
+		}).where("task_key", "=", "projection_gc").where("lease_token", "=", input.leaseToken).where(this.cleanupLeaseExpiryIsInFuture("_emdash_media_usage_cleanup.lease_expires_at")).executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) > 0;
+	}
+	async deleteOrphanOccurrencesOlderThan(cutoff, limit, options = {}) {
+		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();
+		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();
+		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();
+		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 (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));
+		const result = await deleteQuery.executeTakeFirst();
+		return Number(result.numDeletedRows ?? 0);
+	}
+	async upsertIndexStatus(input) {
+		const now = input.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+		const row = {
+			adapter_id: input.adapterId,
+			scope_type: input.scopeType,
+			scope_key: input.scopeKey,
+			status: input.status,
+			schema_version: input.schemaVersion ?? 1,
+			started_at: input.startedAt ?? null,
+			completed_at: input.completedAt ?? null,
+			cursor: input.cursor ?? null,
+			indexed_source_count: input.indexedSourceCount ?? 0,
+			failed_source_count: input.failedSourceCount ?? 0,
+			last_error_code: input.lastErrorCode ?? null,
+			updated_at: now
+		};
+		await this.db.insertInto("_emdash_media_usage_index_status").values(row).onConflict((oc) => oc.columns([
+			"adapter_id",
+			"scope_type",
+			"scope_key"
+		]).doUpdateSet({
+			status: row.status,
+			schema_version: row.schema_version,
+			started_at: row.started_at,
+			completed_at: row.completed_at,
+			cursor: row.cursor,
+			indexed_source_count: row.indexed_source_count,
+			failed_source_count: row.failed_source_count,
+			last_error_code: row.last_error_code,
+			updated_at: row.updated_at
+		})).execute();
+		const status = await this.findIndexStatus(input);
+		if (!status) throw new Error(`Media usage index status ${input.adapterId}:${input.scopeType}:${input.scopeKey} was not persisted`);
+		return status;
+	}
+	async invalidateIndexStatusForSchemaChange(collectionSlug) {
+		const result = await this.db.updateTable("_emdash_media_usage_index_status as status").set({
+			change_epoch: sql`change_epoch + 1`,
+			status: "stale",
+			completed_at: null,
+			cursor: null,
+			last_error_code: "CONTENT_USAGE_STALE",
+			reconciliation_required: 1,
+			updated_at: this.sortableUtcTimestamp()
+		}).where("status.adapter_id", "=", "content-media").where("status.scope_type", "=", "collection").where("status.scope_key", "=", collectionSlug).where("status.capture_state", "=", "active").where((eb) => eb.exists(eb.selectFrom("_emdash_collections as collection").select("collection.id").whereRef("collection.id", "=", "status.collection_id").whereRef("collection.slug", "=", "status.scope_key"))).where(sql`EXISTS (
+					SELECT 1
+					FROM _emdash_media_usage_activation AS activation
+					WHERE activation.task_key = 'incremental_capture'
+						AND activation.state = 'active'
+				)`).executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) === 1;
+	}
+	async beginIndexStatusRepair(input) {
+		return this.upsertIndexStatus({
+			adapterId: input.adapterId,
+			scopeType: input.scopeType,
+			scopeKey: input.scopeKey,
+			status: "running",
+			schemaVersion: input.schemaVersion,
+			startedAt: input.startedAt,
+			completedAt: null,
+			cursor: input.runToken,
+			indexedSourceCount: 0,
+			failedSourceCount: 0,
+			lastErrorCode: null,
+			updatedAt: input.updatedAt
+		});
+	}
+	async finalizeIndexStatusRepairIfRunning(input) {
+		const updates = {
+			status: input.status,
+			completed_at: input.completedAt,
+			cursor: null,
+			indexed_source_count: input.indexedSourceCount ?? 0,
+			failed_source_count: input.failedSourceCount ?? 0,
+			last_error_code: input.lastErrorCode ?? null,
+			updated_at: input.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+		};
+		if (input.schemaVersion !== void 0) updates.schema_version = input.schemaVersion;
+		const result = await this.db.updateTable("_emdash_media_usage_index_status").set(updates).where("adapter_id", "=", input.adapterId).where("scope_type", "=", input.scopeType).where("scope_key", "=", input.scopeKey).where("status", "=", "running").where("cursor", "=", input.runToken).executeTakeFirst();
+		return {
+			finalized: Number(result.numUpdatedRows ?? 0) > 0,
+			status: await this.findIndexStatus(input)
+		};
+	}
+	async beginIndexStatusRepairAtCurrentEpoch(input) {
+		const now = this.sortableUtcTimestamp();
+		const row = await this.db.updateTable("_emdash_media_usage_index_status").set({
+			status: "running",
+			schema_version: input.schemaVersion,
+			started_at: now,
+			completed_at: null,
+			cursor: input.runToken,
+			indexed_source_count: 0,
+			failed_source_count: 0,
+			last_error_code: null,
+			reconciliation_required: 1,
+			updated_at: now
+		}).where("adapter_id", "=", input.adapterId).where("scope_type", "=", input.scopeType).where("scope_key", "=", input.scopeKey).where("collection_id", "=", input.collectionId).where("capture_state", "=", "active").where(sql`EXISTS (
+					SELECT 1
+					FROM _emdash_collections AS collection
+					WHERE collection.id = ${input.collectionId}
+						AND collection.slug = ${input.scopeKey}
+				)`).where(sql`EXISTS (
+					SELECT 1
+					FROM _emdash_media_usage_activation AS activation
+					WHERE activation.task_key = 'incremental_capture'
+						AND activation.state = 'active'
+				)`).returning(["change_epoch", "started_at"]).executeTakeFirst();
+		if (!row?.started_at) return null;
+		return {
+			changeEpoch: row.change_epoch,
+			startedAt: row.started_at
+		};
+	}
+	async finalizeIndexStatusRepairAtEpoch(input) {
+		const now = this.sortableUtcTimestamp();
+		const updates = {
+			status: input.status,
+			schema_version: input.schemaVersion,
+			completed_at: now,
+			cursor: null,
+			indexed_source_count: input.indexedSourceCount,
+			failed_source_count: input.failedSourceCount,
+			last_error_code: input.lastErrorCode,
+			reconciliation_required: input.status === "complete" ? 0 : 1,
+			updated_at: now
+		};
+		let query = this.db.updateTable("_emdash_media_usage_index_status").set(updates).where("adapter_id", "=", input.adapterId).where("scope_type", "=", input.scopeType).where("scope_key", "=", input.scopeKey).where("collection_id", "=", input.collectionId).where("status", "=", "running").where("cursor", "=", input.runToken).where("change_epoch", "=", input.startingEpoch).where(sql`EXISTS (
+					SELECT 1
+					FROM _emdash_collections AS collection
+					WHERE collection.id = ${input.collectionId}
+						AND collection.slug = ${input.scopeKey}
+				)`);
+		if (input.status === "complete") query = query.where(sql`NOT EXISTS (
+					SELECT 1
+					FROM _emdash_media_usage_work AS work
+					WHERE work.collection_id = ${input.collectionId}
+				)`);
+		const result = await query.executeTakeFirst();
+		const finalized = Number(result.numUpdatedRows ?? 0) > 0;
+		if (!finalized) await this.db.updateTable("_emdash_media_usage_index_status").set({
+			status: "stale",
+			completed_at: null,
+			cursor: null,
+			last_error_code: "CONTENT_USAGE_REPAIR_CONFLICT",
+			reconciliation_required: 1,
+			updated_at: this.sortableUtcTimestamp()
+		}).where("adapter_id", "=", input.adapterId).where("scope_type", "=", input.scopeType).where("scope_key", "=", input.scopeKey).where("collection_id", "=", input.collectionId).where("status", "=", "running").where("cursor", "=", input.runToken).execute();
+		return {
+			finalized,
+			status: await this.findIndexStatusForCollection(input, input.collectionId)
+		};
+	}
+	async recordIncrementalSuccess(input) {
+		const observed = await this.db.selectFrom("_emdash_media_usage_index_status").select("change_epoch").where("adapter_id", "=", "content-media").where("scope_type", "=", "collection").where("scope_key", "=", input.collectionSlug).where("collection_id", "=", input.collectionId).where("capture_state", "=", "active").where(sql`EXISTS (
+					SELECT 1
+					FROM _emdash_collections AS collection
+					WHERE collection.id = ${input.collectionId}
+						AND collection.slug = ${input.collectionSlug}
+				)`).executeTakeFirst();
+		if (!observed) return false;
+		const canComplete = sql`(
+			reconciliation_required = 0
+			AND status IN ('complete', 'stale', 'partial')
+			AND NOT EXISTS (
+				SELECT 1
+				FROM _emdash_media_usage_work AS work
+				WHERE work.collection_id = ${input.collectionId}
+			)
+		)`;
+		const now = this.sortableUtcTimestamp();
+		const result = await this.db.updateTable("_emdash_media_usage_index_status").set({
+			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`,
+			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 (
+					SELECT 1
+					FROM _emdash_collections AS collection
+					WHERE collection.id = ${input.collectionId}
+						AND collection.slug = ${input.collectionSlug}
+				)`).executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) > 0;
+	}
+	async recordIncrementalFailure(input) {
+		const now = this.sortableUtcTimestamp();
+		const automaticRunOwnsCoverage = sql`EXISTS (
+			SELECT 1
+			FROM _emdash_media_usage_reconciliations AS reconciliation
+			WHERE reconciliation.collection_id = ${input.collectionId}
+				AND reconciliation.run_token = cursor
+		)`;
+		const result = await this.db.updateTable("_emdash_media_usage_index_status").set({
+			status: sql`CASE
+					WHEN ${automaticRunOwnsCoverage} THEN status
+					WHEN reconciliation_required = 0 THEN 'partial'
+					WHEN status = 'running' THEN 'stale'
+					ELSE status
+				END`,
+			completed_at: sql`CASE
+					WHEN ${automaticRunOwnsCoverage} THEN completed_at
+					WHEN reconciliation_required = 0 OR status = 'running' THEN NULL
+					ELSE completed_at
+				END`,
+			cursor: sql`CASE
+					WHEN ${automaticRunOwnsCoverage} THEN cursor
+					WHEN status = 'running' THEN NULL
+					ELSE cursor
+				END`,
+			last_error_code: input.errorCode,
+			updated_at: now
+		}).where("adapter_id", "=", "content-media").where("scope_type", "=", "collection").where("scope_key", "=", input.collectionSlug).where("collection_id", "=", input.collectionId).where(sql`EXISTS (
+					SELECT 1
+					FROM _emdash_media_usage_work AS work
+					WHERE work.collection_id = ${input.collectionId}
+						AND work.content_id = ${input.contentId}
+						AND work.work_version = ${input.workVersion}
+						AND work.state = 'failed'
+						AND work.last_error_code = ${input.errorCode}
+				)`).where(sql`EXISTS (
+					SELECT 1
+					FROM _emdash_collections AS collection
+					WHERE collection.id = ${input.collectionId}
+						AND collection.slug = ${input.collectionSlug}
+				)`).executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) > 0;
+	}
+	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;
+	}
+	async findIndexStatusForCollection(identity, collectionId) {
+		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).where("collection_id", "=", collectionId).executeTakeFirst();
+		return row ? rowToIndexStatus(row) : null;
+	}
+	async deleteIndexStatus(identity, collectionId) {
+		let query = this.db.deleteFrom("_emdash_media_usage_index_status").where("adapter_id", "=", identity.adapterId).where("scope_type", "=", identity.scopeType).where("scope_key", "=", identity.scopeKey);
+		if (collectionId !== void 0) query = query.where("collection_id", "=", collectionId);
+		const result = await query.executeTakeFirst();
+		return Number(result.numDeletedRows ?? 0);
+	}
+	sortableUtcTimestamp() {
+		return isPostgres(this.db) ? sql`to_char(clock_timestamp() AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')` : sql`strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
+	}
+	async findCurrentUsagePage(applyFilter, options) {
+		const limit = Math.min(Math.max(1, options.limit ?? 50), 100);
+		let query = applyFilter(this.currentUsageBaseQuery()).orderBy("u.id", "asc").limit(limit + 1);
+		if (options.cursor) {
+			const { id } = decodeCursor(options.cursor);
+			query = query.where("u.id", ">", id);
+		}
+		const rows = await query.execute();
+		const items = rows.slice(0, limit).map(rowToUsageRecord);
+		const result = { items };
+		if (rows.length > limit && items.length > 0) {
+			const last = items.at(-1);
+			result.nextCursor = encodeCursor(last.occurrence.id, last.occurrence.id);
+		}
+		return result;
+	}
+	currentUsageBaseQuery() {
+		return this.db.selectFrom("_emdash_media_usage_sources as s").innerJoin("_emdash_media_usage as u", (join) => join.onRef("u.source_key", "=", "s.source_key").onRef("u.generation", "=", "s.current_generation")).select(currentUsageSelect);
+	}
+	currentContentMediaUsageBaseQuery() {
+		return this.db.selectFrom("_emdash_media_usage as u").crossJoin("_emdash_media_usage_sources as s").innerJoin("_emdash_collections as collection", "collection.slug", "s.collection_slug").whereRef("s.source_key", "=", "u.source_key").whereRef("s.current_generation", "=", "u.generation").where("s.source_type", "=", "content").where("s.collection_slug", "is not", null).where("s.content_id", "is not", null).where("s.source_variant", "in", ["columns", "draft_overlay"]).where(contentSourceMatchesActiveCollection("s", "collection.id")).where(CONTENT_SOURCE_ELIGIBILITY);
+	}
+	async deleteOrphanCandidateIds(ids, cutoff, cleanupLease, canIssueStatement) {
+		let deleted = 0;
+		for (const idBatch of chunks([...ids], cleanupDeleteBatchSize(cleanupLease))) {
+			if (!canIssueCleanupStatement(canIssueStatement)) break;
+			if (cleanupLease) {
+				await this.markOrphanCandidatesForCleanup(idBatch, cutoff, cleanupLease);
+				if (!canIssueCleanupStatement(canIssueStatement)) break;
+			}
+			let query = this.db.deleteFrom("_emdash_media_usage").where("id", "in", idBatch).where("created_at", "<", cutoff).where(sql`NOT EXISTS (SELECT 1 FROM _emdash_media_usage_sources source WHERE source.source_key = _emdash_media_usage.source_key)`).where(this.noActiveGenerationWriteExpression());
+			if (cleanupLease) query = query.where("cleanup_lease_token", "=", cleanupLease.leaseToken).where(this.activeCleanupLeaseExpression(cleanupLease));
+			const result = await query.executeTakeFirst();
+			deleted += Number(result.numDeletedRows ?? 0);
+		}
+		return deleted;
+	}
+	async deleteStaleCandidateIds(ids, cutoff, cleanupLease, canIssueStatement) {
+		let deleted = 0;
+		for (const idBatch of chunks([...ids], cleanupDeleteBatchSize(cleanupLease))) {
+			if (!canIssueCleanupStatement(canIssueStatement)) break;
+			if (cleanupLease) {
+				await this.markStaleCandidatesForCleanup(idBatch, cutoff, cleanupLease);
+				if (!canIssueCleanupStatement(canIssueStatement)) break;
+			}
+			let query = this.db.deleteFrom("_emdash_media_usage").where("id", "in", idBatch).where("created_at", "<", cutoff).where((eb) => eb.exists(eb.selectFrom("_emdash_media_usage_sources as source").select("source.source_key").whereRef("source.source_key", "=", "_emdash_media_usage.source_key").whereRef("source.current_generation", "!=", "_emdash_media_usage.generation").whereRef("_emdash_media_usage.created_at", "<", "source.indexed_at"))).where(this.noActiveGenerationWriteExpression());
+			if (cleanupLease) query = query.where("cleanup_lease_token", "=", cleanupLease.leaseToken).where(this.activeCleanupLeaseExpression(cleanupLease));
+			const result = await query.executeTakeFirst();
+			deleted += Number(result.numDeletedRows ?? 0);
+		}
+		return deleted;
+	}
+	async deleteAbandonedCandidateIds(ids, cutoff, cleanupLease, canIssueStatement) {
+		let deleted = 0;
+		for (const idBatch of chunks([...ids], cleanupDeleteBatchSize(cleanupLease))) {
+			if (!canIssueCleanupStatement(canIssueStatement)) break;
+			if (cleanupLease) {
+				await this.markAbandonedCandidatesForCleanup(idBatch, cutoff, cleanupLease);
+				if (!canIssueCleanupStatement(canIssueStatement)) break;
+			}
+			let query = this.db.deleteFrom("_emdash_media_usage").where("id", "in", idBatch).where("created_at", "<", cutoff).where((eb) => eb.exists(eb.selectFrom("_emdash_media_usage_sources as source").select("source.source_key").whereRef("source.source_key", "=", "_emdash_media_usage.source_key").whereRef("source.current_generation", "!=", "_emdash_media_usage.generation").whereRef("_emdash_media_usage.created_at", ">=", "source.indexed_at"))).where(this.noActiveGenerationWriteExpression());
+			if (cleanupLease) query = query.where("cleanup_lease_token", "=", cleanupLease.leaseToken).where(this.activeCleanupLeaseExpression(cleanupLease));
+			const result = await query.executeTakeFirst();
+			deleted += Number(result.numDeletedRows ?? 0);
+		}
+		return deleted;
+	}
+	async markOrphanCandidatesForCleanup(ids, cutoff, cleanupLease) {
+		await this.db.updateTable("_emdash_media_usage").set({ cleanup_lease_token: cleanupLease.leaseToken }).where("id", "in", ids).where("created_at", "<", cutoff).where(sql`NOT EXISTS (SELECT 1 FROM _emdash_media_usage_sources source WHERE source.source_key = _emdash_media_usage.source_key)`).where(this.noActiveGenerationWriteExpression()).where(this.activeCleanupLeaseExpression(cleanupLease)).execute();
+	}
+	async markStaleCandidatesForCleanup(ids, cutoff, cleanupLease) {
+		await this.db.updateTable("_emdash_media_usage").set({ cleanup_lease_token: cleanupLease.leaseToken }).where("id", "in", ids).where("created_at", "<", cutoff).where((eb) => eb.exists(eb.selectFrom("_emdash_media_usage_sources as source").select("source.source_key").whereRef("source.source_key", "=", "_emdash_media_usage.source_key").whereRef("source.current_generation", "!=", "_emdash_media_usage.generation").whereRef("_emdash_media_usage.created_at", "<", "source.indexed_at"))).where(this.noActiveGenerationWriteExpression()).where(this.activeCleanupLeaseExpression(cleanupLease)).execute();
+	}
+	async markAbandonedCandidatesForCleanup(ids, cutoff, cleanupLease) {
+		await this.db.updateTable("_emdash_media_usage").set({ cleanup_lease_token: cleanupLease.leaseToken }).where("id", "in", ids).where("created_at", "<", cutoff).where((eb) => eb.exists(eb.selectFrom("_emdash_media_usage_sources as source").select("source.source_key").whereRef("source.source_key", "=", "_emdash_media_usage.source_key").whereRef("source.current_generation", "!=", "_emdash_media_usage.generation").whereRef("_emdash_media_usage.created_at", ">=", "source.indexed_at"))).where(this.noActiveGenerationWriteExpression()).where(this.activeCleanupLeaseExpression(cleanupLease)).execute();
+	}
+	noActiveGenerationWriteExpression(usageTable = "_emdash_media_usage") {
+		return sql`NOT EXISTS (
+				SELECT 1
+				FROM _emdash_media_usage_generation_writes AS writer
+				WHERE writer.source_key = ${sql.ref(`${usageTable}.source_key`)}
+					AND writer.generation = ${sql.ref(`${usageTable}.generation`)}
+					AND ${this.generationWriteLeaseExpiryIsInFuture("writer.expires_at")}
+			)`;
+	}
+	activeCleanupLeaseExpression(cleanupLease) {
+		const rowLock = isPostgres(this.db) ? sql` FOR UPDATE` : sql``;
+		return sql`EXISTS (
+				SELECT 1
+				FROM _emdash_media_usage_cleanup AS cleanup
+				WHERE cleanup.task_key = 'projection_gc'
+					AND cleanup.lease_token = ${cleanupLease.leaseToken}
+					AND ${this.cleanupLeaseExpiryIsInFuture("cleanup.lease_expires_at")}
+				${rowLock}
+			)`;
+	}
+	cleanupLeaseExpiryIsInFuture(column) {
+		const leaseExpiresAt = sql.ref(column);
+		return isPostgres(this.db) ? sql`${leaseExpiresAt}::timestamptz > clock_timestamp()` : sql`${leaseExpiresAt} > strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
+	}
+	cleanupTimestampIsDue(column) {
+		const timestamp = sql.ref(column);
+		return isPostgres(this.db) ? sql`${timestamp}::timestamptz <= clock_timestamp()` : sql`${timestamp} <= strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
+	}
+	cleanupTimestampOffset(offsetSeconds) {
+		if (isPostgres(this.db)) return sql`to_char(
+				(clock_timestamp() AT TIME ZONE 'UTC') + (${offsetSeconds} * INTERVAL '1 second'),
+				'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"'
+			)`;
+		return sql`strftime(
+			'%Y-%m-%dT%H:%M:%fZ',
+			'now',
+			${`${offsetSeconds >= 0 ? "+" : ""}${offsetSeconds} seconds`}
+		)`;
+	}
+	generationWriteLeaseHasExpired(column) {
+		const leaseExpiresAt = sql.ref(column);
+		return isPostgres(this.db) ? sql`${leaseExpiresAt}::timestamptz <= clock_timestamp()` : sql`${leaseExpiresAt} <= strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
+	}
+	async deleteSourceKeys(sourceKeys) {
+		const uniqueSourceKeys = [...new Set(sourceKeys)];
+		if (uniqueSourceKeys.length === 0) return 0;
+		return withTransaction(this.db, async (trx) => {
+			await this.lockCleanupBeforeSourceDelete(trx);
+			let deleted = 0;
+			for (const sourceKeyBatch of chunks(uniqueSourceKeys, SQL_BATCH_SIZE)) {
+				const result = await trx.deleteFrom("_emdash_media_usage_sources").where("source_key", "in", sourceKeyBatch).executeTakeFirst();
+				deleted += Number(result.numDeletedRows ?? 0);
+				await trx.updateTable("_emdash_media_usage").set({ cleanup_lease_token: null }).where("source_key", "in", sourceKeyBatch).execute();
+				await trx.deleteFrom("_emdash_media_usage").where("source_key", "in", sourceKeyBatch).execute();
+			}
+			return deleted;
+		});
+	}
+	async deleteSourceGenerationOccurrences(db, sourceKey, generation) {
+		await db.updateTable("_emdash_media_usage").set({ cleanup_lease_token: null }).where("source_key", "=", sourceKey).where("generation", "=", generation).execute();
+		await db.deleteFrom("_emdash_media_usage").where("source_key", "=", sourceKey).where("generation", "=", generation).execute();
+	}
+	async lockCleanupBeforeSourceDelete(db) {
+		if (!isPostgres(this.db)) return;
+		await sql`
+			SELECT 1
+			FROM _emdash_media_usage_cleanup
+			WHERE task_key = 'projection_gc'
+			FOR SHARE
+		`.execute(db);
+	}
+	async insertOccurrences(db, sourceKey, generation, occurrences, now) {
+		if (occurrences.length === 0) return;
+		const rows = occurrences.map((occurrence) => ({
+			id: ulid(),
+			source_key: sourceKey,
+			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
+		}));
+		for (const rowBatch of chunks(rows, OCCURRENCE_INSERT_BATCH_SIZE)) await db.insertInto("_emdash_media_usage").values(rowBatch).execute();
+	}
+	async lockCanonicalSourceCollection(db, source) {
+		if (source.collectionId === void 0 || source.collectionId === null) return true;
+		if (!source.collectionSlug) return false;
+		if (!isPostgres(this.db)) return true;
+		return await db.selectFrom("_emdash_collections").select("id").where("id", "=", source.collectionId).where("slug", "=", source.collectionSlug).forKeyShare().executeTakeFirst() !== void 0;
+	}
+	async upsertSource(db, source, generation, now, leaseToken) {
+		const row = this.buildSourceRow(source, generation, now);
+		return this.persistSourceIfWriteLease(db, row, leaseToken, sql`
+				ON CONFLICT (source_key) DO UPDATE SET
+					source_type = excluded.source_type,
+					collection_id = excluded.collection_id,
+					collection_slug = excluded.collection_slug,
+					content_id = excluded.content_id,
+					source_variant = excluded.source_variant,
+					locale = excluded.locale,
+					translation_group = excluded.translation_group,
+					content_slug = excluded.content_slug,
+					content_title = excluded.content_title,
+					content_status = excluded.content_status,
+					content_scheduled_at = excluded.content_scheduled_at,
+					content_deleted_at = excluded.content_deleted_at,
+					revision_id = excluded.revision_id,
+					current_generation = excluded.current_generation,
+					schema_version = excluded.schema_version,
+					source_updated_at = excluded.source_updated_at,
+					source_version = excluded.source_version,
+					source_fingerprint = excluded.source_fingerprint,
+					identity_version = excluded.identity_version,
+					source_completeness = excluded.source_completeness,
+					last_attempted_at = excluded.last_attempted_at,
+					last_error_code = excluded.last_error_code,
+					indexed_at = excluded.indexed_at,
+					updated_at = excluded.updated_at
+			`);
+	}
+	async insertSourceIfAbsent(db, row, leaseToken) {
+		return this.persistSourceIfWriteLease(db, row, leaseToken, sql`ON CONFLICT (source_key) DO NOTHING`);
+	}
+	async persistSourceIfWriteLease(db, row, leaseToken, conflict) {
+		const result = await sql`
+			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
+				${row.source_key},
+				${row.source_type},
+				${row.collection_id},
+				${row.collection_slug},
+				${row.content_id},
+				${row.source_variant},
+				${row.locale},
+				${row.translation_group},
+				${row.content_slug},
+				${row.content_title},
+				${row.content_status},
+				${row.content_scheduled_at},
+				${row.content_deleted_at},
+				${row.revision_id},
+				${row.current_generation},
+				${row.schema_version},
+				${row.source_updated_at},
+				${row.source_version},
+				${row.source_fingerprint},
+				${row.identity_version},
+				${row.source_completeness},
+				${row.last_attempted_at},
+				${row.last_error_code},
+				${row.indexed_at},
+				${row.updated_at}
+			WHERE EXISTS (
+				SELECT 1
+				FROM _emdash_media_usage_generation_writes
+				WHERE source_key = ${row.source_key}
+					AND generation = ${row.current_generation}
+					AND lease_token = ${leaseToken}
+					AND ${this.generationWriteLeaseExpiryIsInFuture("expires_at")}
+			)
+			AND ${this.currentCollectionExists(row.collection_id, row.collection_slug)}
+			AND ${this.currentCanonicalContentExists(row)}
+			${conflict}
+		`.execute(db);
+		return Number(result.numAffectedRows ?? 0) > 0;
+	}
+	generationWriteLeaseExpression(row, leaseToken) {
+		return (eb) => eb.exists(eb.selectFrom("_emdash_media_usage_generation_writes").select("source_key").where("source_key", "=", row.source_key).where("generation", "=", row.current_generation).where("lease_token", "=", leaseToken).where(this.generationWriteLeaseExpiryIsInFuture("_emdash_media_usage_generation_writes.expires_at")));
+	}
+	generationWriteLeaseExpiryIsInFuture(column) {
+		const leaseExpiresAt = sql.ref(column);
+		return isPostgres(this.db) ? sql`${leaseExpiresAt}::timestamptz > clock_timestamp()` : sql`${leaseExpiresAt} > strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
+	}
+	async withGenerationWriteLease(source, generation, write) {
+		const leaseToken = ulid();
+		const owner = (await sql`
+			INSERT INTO _emdash_media_usage_generation_writes (
+				source_key, generation, lease_token, expires_at, created_at
+			)
+			SELECT
+				${source.sourceKey},
+				${generation},
+				${leaseToken},
+				${this.generationWriteLeaseTimestampOffset(MEDIA_USAGE_GENERATION_WRITE_LEASE_MS / 1e3)},
+				${this.generationWriteLeaseTimestampOffset(0)}
+			WHERE ${this.currentCollectionExists(source.collectionId ?? null, source.collectionSlug ?? null)}
+			RETURNING created_at
+		`.execute(this.db)).rows[0];
+		if (!owner) return false;
+		try {
+			await write(leaseToken, owner.created_at);
+			return true;
+		} finally {
+			try {
+				await this.db.deleteFrom("_emdash_media_usage_generation_writes").where("source_key", "=", source.sourceKey).where("generation", "=", generation).where("lease_token", "=", leaseToken).execute();
+			} catch (error) {
+				console.error("[media-usage] Failed to release generation write lease:", error);
+			}
+		}
+	}
+	generationWriteLeaseTimestampOffset(offsetSeconds) {
+		if (isPostgres(this.db)) return sql`to_char(
+				(clock_timestamp() AT TIME ZONE 'UTC') + (${offsetSeconds} * INTERVAL '1 second'),
+				'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"'
+			)`;
+		return sql`strftime(
+			'%Y-%m-%dT%H:%M:%fZ',
+			'now',
+			${`${offsetSeconds >= 0 ? "+" : ""}${offsetSeconds} seconds`}
+		)`;
+	}
+	async updateSourceIfGeneration(db, row, expectedCurrentGeneration, leaseToken) {
+		const result = await db.updateTable("_emdash_media_usage_sources").set(this.sourceUpdateSet(row)).where("source_key", "=", row.source_key).where("current_generation", "=", expectedCurrentGeneration).where(this.generationWriteLeaseExpression(row, leaseToken)).where(this.currentCollectionExists(row.collection_id, row.collection_slug)).where(this.currentCanonicalContentExists(row)).executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) > 0;
+	}
+	async updateSourceIfMatching(db, row, expectedSource, leaseToken) {
+		const result = await db.updateTable("_emdash_media_usage_sources").set(this.sourceUpdateSet(row)).where("source_key", "=", row.source_key).where(this.sourceMatchExpression(expectedSource)).where(this.generationWriteLeaseExpression(row, leaseToken)).where(this.currentCollectionExists(row.collection_id, row.collection_slug)).where(this.currentCanonicalContentExists(row)).executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) > 0;
+	}
+	async updateAttemptedSourceIfMatching(db, source, row, expectedSource) {
+		const result = await db.updateTable("_emdash_media_usage_sources").set(this.attemptedSourceUpdateSet(source, row)).where("source_key", "=", row.source_key).where(this.sourceMatchExpression(expectedSource)).where(this.currentCollectionExists(row.collection_id, row.collection_slug)).where(this.currentCanonicalContentExists(row)).executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) > 0;
+	}
+	sourceMatchExpression(expectedSource) {
+		return (eb) => eb.and([
+			eb("current_generation", "=", expectedSource.currentGeneration),
+			eb("source_completeness", "=", expectedSource.sourceCompleteness),
+			this.nullableStringExpression(eb, "collection_id", expectedSource.collectionId),
+			this.nullableStringExpression(eb, "updated_at", expectedSource.updatedAt),
+			this.nullableStringExpression(eb, "source_fingerprint", expectedSource.sourceFingerprint),
+			this.nullableStringExpression(eb, "source_updated_at", expectedSource.sourceUpdatedAt),
+			this.nullableNumberExpression(eb, "source_version", expectedSource.sourceVersion),
+			this.nullableNumberExpression(eb, "identity_version", expectedSource.identityVersion),
+			this.nullableStringExpression(eb, "revision_id", expectedSource.revisionId),
+			this.nullableStringExpression(eb, "last_attempted_at", expectedSource.lastAttemptedAt),
+			this.nullableStringExpression(eb, "last_error_code", expectedSource.lastErrorCode)
+		]);
+	}
+	async projectionMatchesCurrentGeneration(source, expectedCurrentGeneration) {
+		const fingerprint = source.sourceFingerprint;
+		if (!isMediaUsageProjectionFingerprint(fingerprint)) return false;
+		return await this.db.selectFrom("_emdash_media_usage_sources").select("source_key").where("source_key", "=", source.sourceKey).where("current_generation", "=", expectedCurrentGeneration).where("source_fingerprint", "=", fingerprint).where("source_completeness", "=", source.sourceCompleteness ?? "complete").where("last_error_code", "is", null).where(this.currentCollectionExists(source.collectionId ?? null, source.collectionSlug ?? null)).executeTakeFirst() !== void 0;
+	}
+	async projectionMatchesExpectedSource(source, expectedSource) {
+		const fingerprint = source.sourceFingerprint;
+		if (!isMediaUsageProjectionFingerprint(fingerprint) || expectedSource.sourceFingerprint !== fingerprint || expectedSource.sourceCompleteness !== (source.sourceCompleteness ?? "complete") || expectedSource.lastErrorCode !== null) return false;
+		return await this.db.selectFrom("_emdash_media_usage_sources").select("source_key").where("source_key", "=", source.sourceKey).where(this.sourceMatchExpression(expectedSource)).where(this.currentCollectionExists(source.collectionId ?? null, source.collectionSlug ?? null)).executeTakeFirst() !== void 0;
+	}
+	nullableStringExpression(eb, column, value) {
+		return value === null ? eb(column, "is", null) : eb(column, "=", value);
+	}
+	currentCollectionExists(collectionId, collectionSlug) {
+		if (collectionId === null) return sql`1 = 1`;
+		return sql`EXISTS (
+			SELECT 1
+			FROM _emdash_collections
+			WHERE id = ${collectionId}
+				AND slug = ${collectionSlug}
+		)`;
+	}
+	currentCanonicalContentExists(row) {
+		if (row.collection_id === null || row.identity_version !== 1 || row.source_type !== "content") return sql`1 = 1`;
+		if (!row.collection_slug || !row.content_id || row.source_version === null || row.source_updated_at === null) return sql`1 = 0`;
+		validateIdentifier(row.collection_slug, "collection slug");
+		const tableName = `ec_${row.collection_slug}`;
+		validateIdentifier(tableName, "content table");
+		const revisionColumn = row.source_variant === "columns" ? "live_revision_id" : row.source_variant === "draft_overlay" ? "draft_revision_id" : null;
+		if (!revisionColumn) return sql`1 = 0`;
+		const revision = sql.ref(`content.${revisionColumn}`);
+		const revisionMatches = row.revision_id === null ? sql`${revision} IS NULL` : sql`${revision} = ${row.revision_id}`;
+		return sql`EXISTS (
+			SELECT 1
+			FROM ${sql.ref(tableName)} AS content
+			WHERE content.id = ${row.content_id}
+				AND content.version = ${row.source_version}
+				AND content.updated_at = ${row.source_updated_at}
+				AND ${revisionMatches}
+		)`;
+	}
+	nullableNumberExpression(eb, column, value) {
+		return value === null ? eb(column, "is", null) : eb(column, "=", value);
+	}
+	async contentRowExists(tableName, contentId) {
+		return (await sql`
+			SELECT id
+			FROM ${sql.ref(tableName)}
+			WHERE id = ${contentId}
+			LIMIT 1
+		`.execute(this.db)).rows.length > 0;
+	}
+	buildSourceRow(source, generation, now) {
+		return {
+			source_key: source.sourceKey,
+			source_type: source.sourceType,
+			collection_id: source.collectionId ?? null,
+			collection_slug: source.collectionSlug ?? null,
+			content_id: source.contentId ?? null,
+			source_variant: source.sourceVariant,
+			locale: source.locale ?? null,
+			translation_group: source.translationGroup ?? null,
+			content_slug: source.contentSlug ?? null,
+			content_title: source.contentTitle ?? null,
+			content_status: source.contentStatus ?? null,
+			content_scheduled_at: source.contentScheduledAt ?? null,
+			content_deleted_at: source.contentDeletedAt ?? null,
+			revision_id: source.revisionId ?? null,
+			current_generation: generation,
+			schema_version: source.schemaVersion ?? 1,
+			source_updated_at: source.sourceUpdatedAt ?? null,
+			source_version: source.sourceVersion ?? null,
+			source_fingerprint: source.sourceFingerprint ?? null,
+			identity_version: source.identityVersion ?? null,
+			source_completeness: source.sourceCompleteness ?? "complete",
+			last_attempted_at: source.lastAttemptedAt ?? now,
+			last_error_code: null,
+			indexed_at: now,
+			updated_at: now
+		};
+	}
+	buildAttemptedSourceRow(source, generation, now) {
+		return {
+			source_key: source.sourceKey,
+			source_type: source.sourceType,
+			collection_id: source.collectionId ?? null,
+			collection_slug: source.collectionSlug ?? null,
+			content_id: source.contentId ?? null,
+			source_variant: source.sourceVariant,
+			locale: source.locale ?? null,
+			translation_group: source.translationGroup ?? null,
+			content_slug: source.contentSlug ?? null,
+			content_title: source.contentTitle ?? null,
+			content_status: source.contentStatus ?? null,
+			content_scheduled_at: source.contentScheduledAt ?? null,
+			content_deleted_at: source.contentDeletedAt ?? null,
+			revision_id: source.revisionId ?? null,
+			current_generation: generation,
+			schema_version: source.schemaVersion ?? 1,
+			source_updated_at: source.sourceUpdatedAt ?? null,
+			source_version: source.sourceVersion ?? null,
+			source_fingerprint: source.sourceFingerprint ?? null,
+			identity_version: source.identityVersion ?? null,
+			source_completeness: source.sourceCompleteness ?? (source.lastErrorCode ? "failed" : "unknown"),
+			last_attempted_at: source.lastAttemptedAt ?? now,
+			last_error_code: source.lastErrorCode ?? null,
+			indexed_at: now,
+			updated_at: now
+		};
+	}
+	attemptedSourceUpdateSet(source, row) {
+		const updates = {
+			source_type: row.source_type,
+			source_variant: row.source_variant,
+			source_completeness: row.source_completeness,
+			last_attempted_at: row.last_attempted_at,
+			last_error_code: row.last_error_code,
+			updated_at: row.updated_at
+		};
+		if (source.collectionSlug !== void 0) updates.collection_slug = row.collection_slug;
+		if (source.collectionId !== void 0) updates.collection_id = row.collection_id;
+		if (source.contentId !== void 0) updates.content_id = row.content_id;
+		if (source.locale !== void 0) updates.locale = row.locale;
+		if (source.translationGroup !== void 0) updates.translation_group = row.translation_group;
+		if (source.contentSlug !== void 0) updates.content_slug = row.content_slug;
+		if (source.contentTitle !== void 0) updates.content_title = row.content_title;
+		if (source.contentStatus !== void 0) updates.content_status = row.content_status;
+		if (source.contentScheduledAt !== void 0) updates.content_scheduled_at = row.content_scheduled_at;
+		if (source.contentDeletedAt !== void 0) updates.content_deleted_at = row.content_deleted_at;
+		if (source.revisionId !== void 0) updates.revision_id = row.revision_id;
+		if (source.schemaVersion !== void 0) updates.schema_version = row.schema_version;
+		if (source.sourceUpdatedAt !== void 0) updates.source_updated_at = row.source_updated_at;
+		if (source.sourceVersion !== void 0) updates.source_version = row.source_version;
+		if (source.sourceFingerprint !== void 0) updates.source_fingerprint = row.source_fingerprint;
+		if (source.identityVersion !== void 0) updates.identity_version = row.identity_version;
+		return updates;
+	}
+	sourceUpdateSet(row) {
+		return {
+			source_type: row.source_type,
+			collection_id: row.collection_id,
+			collection_slug: row.collection_slug,
+			content_id: row.content_id,
+			source_variant: row.source_variant,
+			locale: row.locale,
+			translation_group: row.translation_group,
+			content_slug: row.content_slug,
+			content_title: row.content_title,
+			content_status: row.content_status,
+			content_scheduled_at: row.content_scheduled_at,
+			content_deleted_at: row.content_deleted_at,
+			revision_id: row.revision_id,
+			current_generation: row.current_generation,
+			schema_version: row.schema_version,
+			source_updated_at: row.source_updated_at,
+			source_version: row.source_version,
+			source_fingerprint: row.source_fingerprint,
+			identity_version: row.identity_version,
+			source_completeness: row.source_completeness,
+			last_attempted_at: row.last_attempted_at,
+			last_error_code: row.last_error_code,
+			indexed_at: row.indexed_at,
+			updated_at: row.updated_at
+		};
+	}
+};
+const currentUsageSelect = [
+	"s.source_key as source_key",
+	"s.source_type as source_type",
+	"s.collection_id as collection_id",
+	"s.collection_slug as collection_slug",
+	"s.content_id as content_id",
+	"s.source_variant as source_variant",
+	"s.locale as locale",
+	"s.translation_group as translation_group",
+	"s.content_slug as content_slug",
+	"s.content_title as content_title",
+	"s.content_status as content_status",
+	"s.content_scheduled_at as content_scheduled_at",
+	"s.content_deleted_at as content_deleted_at",
+	"s.revision_id as revision_id",
+	"s.current_generation as current_generation",
+	"s.schema_version as schema_version",
+	"s.source_updated_at as source_updated_at",
+	"s.source_version as source_version",
+	"s.source_fingerprint as source_fingerprint",
+	"s.identity_version as identity_version",
+	"s.source_completeness as source_completeness",
+	"s.last_attempted_at as last_attempted_at",
+	"s.last_error_code as last_error_code",
+	"s.indexed_at as indexed_at",
+	"s.created_at as source_created_at",
+	"s.updated_at as source_row_updated_at",
+	"u.id as occurrence_id",
+	"u.generation as generation",
+	"u.field_slug as field_slug",
+	"u.field_path as field_path",
+	"u.occurrence_index as occurrence_index",
+	"u.reference_type as reference_type",
+	"u.media_id as media_id",
+	"u.provider as provider",
+	"u.provider_asset_id as provider_asset_id",
+	"u.media_kind as media_kind",
+	"u.mime_type as mime_type",
+	"u.created_at as occurrence_created_at"
+];
+function groupUsageRows(rows) {
+	const groups = [];
+	for (const row of rows) {
+		if (row.collection_slug === null || row.content_id === null) continue;
+		const record = rowToUsageRecord(row);
+		let group = groups.at(-1);
+		if (!group || group.collectionSlug !== row.collection_slug || group.contentId !== row.content_id) {
+			group = {
+				collectionSlug: row.collection_slug,
+				contentId: row.content_id,
+				contentDeletedAt: row.entry_deleted_at,
+				sources: []
+			};
+			groups.push(group);
+		}
+		let source = group.sources.at(-1);
+		if (!source || source.source.sourceKey !== record.source.sourceKey) {
+			source = {
+				source: record.source,
+				occurrences: []
+			};
+			group.sources.push(source);
+		}
+		source.occurrences.push(record.occurrence);
+	}
+	return groups;
+}
+function rowToSource(row) {
+	return {
+		sourceKey: row.source_key,
+		sourceType: row.source_type,
+		collectionId: row.collection_id,
+		collectionSlug: row.collection_slug,
+		contentId: row.content_id,
+		sourceVariant: row.source_variant,
+		locale: row.locale,
+		translationGroup: row.translation_group,
+		contentSlug: row.content_slug,
+		contentTitle: row.content_title,
+		contentStatus: row.content_status,
+		contentScheduledAt: row.content_scheduled_at,
+		contentDeletedAt: row.content_deleted_at,
+		revisionId: row.revision_id,
+		currentGeneration: row.current_generation,
+		schemaVersion: Number(row.schema_version),
+		sourceUpdatedAt: row.source_updated_at,
+		sourceVersion: row.source_version === null ? null : Number(row.source_version),
+		sourceFingerprint: row.source_fingerprint,
+		identityVersion: row.identity_version === null ? null : Number(row.identity_version),
+		sourceCompleteness: row.source_completeness,
+		lastAttemptedAt: row.last_attempted_at,
+		lastErrorCode: row.last_error_code,
+		indexedAt: row.indexed_at,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function rowToOccurrence(row) {
+	return {
+		id: row.id,
+		sourceKey: row.source_key,
+		generation: row.generation,
+		fieldSlug: row.field_slug,
+		fieldPath: row.field_path,
+		occurrenceIndex: Number(row.occurrence_index),
+		referenceType: row.reference_type,
+		mediaId: row.media_id,
+		provider: row.provider,
+		providerAssetId: row.provider_asset_id,
+		mediaKind: row.media_kind,
+		mimeType: row.mime_type,
+		createdAt: row.created_at
+	};
+}
+function rowToUsageRecord(row) {
+	return {
+		source: rowToSource({
+			source_key: row.source_key,
+			source_type: row.source_type,
+			collection_id: row.collection_id,
+			collection_slug: row.collection_slug,
+			content_id: row.content_id,
+			source_variant: row.source_variant,
+			locale: row.locale,
+			translation_group: row.translation_group,
+			content_slug: row.content_slug,
+			content_title: row.content_title,
+			content_status: row.content_status,
+			content_scheduled_at: row.content_scheduled_at,
+			content_deleted_at: row.content_deleted_at,
+			revision_id: row.revision_id,
+			current_generation: row.current_generation,
+			schema_version: row.schema_version,
+			source_updated_at: row.source_updated_at,
+			source_version: row.source_version,
+			source_fingerprint: row.source_fingerprint,
+			identity_version: row.identity_version,
+			source_completeness: row.source_completeness,
+			last_attempted_at: row.last_attempted_at,
+			last_error_code: row.last_error_code,
+			indexed_at: row.indexed_at,
+			created_at: row.source_created_at,
+			updated_at: row.source_row_updated_at
+		}),
+		occurrence: rowToOccurrence({
+			id: row.occurrence_id,
+			source_key: row.source_key,
+			generation: row.generation,
+			field_slug: row.field_slug,
+			field_path: row.field_path,
+			occurrence_index: row.occurrence_index,
+			reference_type: row.reference_type,
+			media_id: row.media_id,
+			provider: row.provider,
+			provider_asset_id: row.provider_asset_id,
+			media_kind: row.media_kind,
+			mime_type: row.mime_type,
+			created_at: row.occurrence_created_at,
+			cleanup_lease_token: null
+		})
+	};
+}
+function rowToIndexStatus(row) {
+	return {
+		adapterId: row.adapter_id,
+		scopeType: row.scope_type,
+		scopeKey: row.scope_key,
+		status: row.status,
+		schemaVersion: Number(row.schema_version),
+		startedAt: row.started_at,
+		completedAt: row.completed_at,
+		cursor: row.cursor,
+		indexedSourceCount: Number(row.indexed_source_count),
+		failedSourceCount: Number(row.failed_source_count),
+		lastErrorCode: row.last_error_code,
+		updatedAt: row.updated_at
+	};
+}
+
+//#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) {
+	return (await buildCanonicalSha256Fingerprint("media-usage-fields:v1:sha256:", {
+		fingerprintVersion: 1,
+		contentSourceSchemaVersion: CONTENT_SOURCE_SCHEMA_VERSION,
+		extractionFields: discovery.extractionFields.map((field) => ({
+			slug: field.slug,
+			type: field.type,
+			...field.type === "repeater" ? { subFields: (field.validation?.subFields ?? []).map((subField) => ({
+				slug: subField.slug,
+				type: subField.type
+			})).toSorted(compareFieldIdentity) } : {}
+		})).toSorted(compareFieldIdentity),
+		displayFieldSlugs: discovery.displayFieldSlugs.toSorted(compareStrings)
+	})).fingerprint;
+}
+var MediaUsageFieldDiscoveryError = class extends Error {
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+		this.name = "MediaUsageFieldDiscoveryError";
+	}
+};
+const DISPLAY_FIELD_SLUGS = ["title", "name"];
+const SUPPORTED_TOP_LEVEL_TYPES = [
+	"file",
+	"image",
+	"portableText"
+];
+async function loadContentMediaUsageFields(db, collectionSlug, collectionId) {
+	validateIdentifier(collectionSlug, "collection slug");
+	let query = db.selectFrom("_emdash_fields").innerJoin("_emdash_collections", "_emdash_collections.id", "_emdash_fields.collection_id").select([
+		"_emdash_fields.slug",
+		"_emdash_fields.type",
+		"_emdash_fields.validation"
+	]).where("_emdash_collections.slug", "=", collectionSlug);
+	if (collectionId !== void 0) query = query.where("_emdash_collections.id", "=", collectionId);
+	const rows = await query.execute();
+	const extractionFields = [];
+	const rowBySlug = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		rowBySlug.set(row.slug, row);
+		if (isSupportedTopLevelType(row.type)) {
+			validateIdentifier(row.slug, "media usage field slug");
+			extractionFields.push({
+				slug: row.slug,
+				type: row.type
+			});
+			continue;
+		}
+		if (row.type === "repeater") {
+			validateIdentifier(row.slug, "media usage field slug");
+			const subFields = normalizeRepeaterImageSubFields(row.validation);
+			if (subFields.length > 0) extractionFields.push({
+				slug: row.slug,
+				type: "repeater",
+				validation: { subFields }
+			});
+		}
+	}
+	extractionFields.sort((a, b) => a.slug.localeCompare(b.slug));
+	return {
+		extractionFields,
+		displayFieldSlugs: DISPLAY_FIELD_SLUGS.filter((slug) => {
+			if (!rowBySlug.has(slug)) return false;
+			validateIdentifier(slug, "media usage display field slug");
+			return true;
+		})
+	};
+}
+function normalizeRepeaterImageSubFields(rawValidation) {
+	const validation = parseValidation(rawValidation);
+	if (!isRecord$2(validation) || !Array.isArray(validation.subFields)) return [];
+	const subFields = [];
+	for (const subField of validation.subFields) {
+		if (!isRecord$2(subField) || subField.type !== "image") continue;
+		if (typeof subField.slug !== "string") continue;
+		validateIdentifier(subField.slug, "media usage repeater sub-field slug");
+		subFields.push({
+			slug: subField.slug,
+			type: "image"
+		});
+	}
+	return subFields.toSorted((a, b) => a.slug.localeCompare(b.slug));
+}
+function parseValidation(rawValidation) {
+	if (!rawValidation) return null;
+	try {
+		return JSON.parse(rawValidation);
+	} catch {
+		throw new MediaUsageFieldDiscoveryError("Repeater field validation must be valid JSON before media usage can be discovered", "INVALID_REPEATER_VALIDATION");
+	}
+}
+function isSupportedTopLevelType(value) {
+	return SUPPORTED_TOP_LEVEL_TYPES.includes(value);
+}
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function compareFieldIdentity(a, b) {
+	return compareStrings(a.slug, b.slug);
+}
+function compareStrings(a, b) {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+
+//#endregion
+//#region src/media/usage/extractor.ts
+const URL_LIKE_RE = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+function extractMediaUsageOccurrences({ fields, data }) {
+	const occurrences = [];
+	const seen = /* @__PURE__ */ new Set();
+	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"
+			});
+			continue;
+		}
+		if (field.type === "file") {
+			addOccurrence(occurrences, seen, {
+				fieldSlug: field.slug,
+				fieldPath: field.slug,
+				referenceType: "file_field",
+				value,
+				fallbackKind: null
+			});
+			continue;
+		}
+		if (field.type === "repeater") {
+			extractRepeaterOccurrences(occurrences, seen, field.slug, value, field.validation?.subFields);
+			continue;
+		}
+		if (field.type === "portableText") extractPortableTextOccurrences(occurrences, seen, field.slug, value);
+	}
+	return occurrences;
+}
+function extractRepeaterOccurrences(occurrences, seen, fieldSlug, value, subFields) {
+	if (!Array.isArray(value) || !Array.isArray(subFields)) return;
+	for (const [itemIndex, item] of value.entries()) {
+		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"
+			});
+		}
+	}
+}
+function extractPortableTextOccurrences(occurrences, seen, fieldSlug, value) {
+	if (!Array.isArray(value)) return;
+	for (const [blockIndex, block] of value.entries()) {
+		if (!isRecord$1(block) || block._type !== "image" || !isRecord$1(block.asset)) continue;
+		const provider = normalizeProvider(block.asset.provider);
+		const ref = readPortableTextAssetRef(block.asset, provider);
+		if (!ref) continue;
+		addRefOccurrence(occurrences, seen, {
+			fieldSlug,
+			fieldPath: `${fieldSlug}[${blockIndex}].asset.${ref.key}`,
+			referenceType: "portable_text_image",
+			ref: buildMediaRef({
+				id: ref.id,
+				provider,
+				mimeType: normalizeMimeValue(block.asset.mimeType),
+				fallbackKind: "image"
+			})
+		});
+	}
+}
+function addOccurrence(occurrences, seen, input) {
+	const ref = readMediaRef(input.value, input.fallbackKind);
+	if (!ref) return;
+	addRefOccurrence(occurrences, seen, {
+		fieldSlug: input.fieldSlug,
+		fieldPath: input.fieldPath,
+		referenceType: input.referenceType,
+		ref
+	});
+}
+function addRefOccurrence(occurrences, seen, input) {
+	if (!input.ref) return;
+	const occurrence = {
+		fieldSlug: input.fieldSlug,
+		fieldPath: input.fieldPath,
+		occurrenceIndex: 0,
+		referenceType: input.referenceType,
+		mediaId: input.ref.mediaId,
+		provider: input.ref.provider,
+		providerAssetId: input.ref.providerAssetId,
+		mediaKind: input.ref.mediaKind,
+		mimeType: input.ref.mimeType
+	};
+	const key = [
+		occurrence.fieldSlug,
+		occurrence.fieldPath,
+		occurrence.occurrenceIndex,
+		occurrence.referenceType,
+		occurrence.provider,
+		occurrence.providerAssetId,
+		occurrence.mediaId ?? ""
+	].join("\0");
+	if (seen.has(key)) return;
+	seen.add(key);
+	occurrences.push(occurrence);
+}
+function readMediaRef(value, fallbackKind) {
+	if (typeof value === "string") {
+		const id = normalizeLocalMediaId(value);
+		return id ? buildMediaRef({
+			id,
+			provider: "local",
+			mimeType: null,
+			fallbackKind
+		}) : null;
+	}
+	if (!isRecord$1(value)) return null;
+	const provider = normalizeProvider(value.provider);
+	const id = provider === "local" ? normalizeLocalMediaId(value.id) : normalizeStableId(value.id);
+	if (!id) return null;
+	return buildMediaRef({
+		id,
+		provider,
+		mimeType: normalizeMimeValue(value.mimeType),
+		fallbackKind
+	});
+}
+function buildMediaRef(input) {
+	const provider = normalizeProvider(input.provider);
+	if (provider === "external") return null;
+	return {
+		mediaId: provider === "local" ? input.id : null,
+		provider,
+		providerAssetId: input.id,
+		mediaKind: mediaKindFromMime(input.mimeType) ?? input.fallbackKind,
+		mimeType: input.mimeType
+	};
+}
+function readPortableTextAssetRef(asset, provider) {
+	const normalizeId = provider === "local" ? normalizeLocalMediaId : normalizeStableId;
+	const ref = normalizeId(asset._ref);
+	if (ref) return {
+		key: "_ref",
+		id: ref
+	};
+	const id = normalizeId(asset.id);
+	if (id) return {
+		key: "id",
+		id
+	};
+	return null;
+}
+function normalizeProvider(value) {
+	return readString$1(value)?.trim() || "local";
+}
+function normalizeLocalMediaId(value) {
+	const id = normalizeStableId(value);
+	if (!id) return null;
+	return id.includes("/") ? null : id;
+}
+function normalizeStableId(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	if (!trimmed) return null;
+	if (URL_LIKE_RE.test(trimmed)) return null;
+	if (trimmed.startsWith(INTERNAL_MEDIA_PREFIX)) return null;
+	return trimmed;
+}
+function normalizeMimeValue(value) {
+	if (typeof value !== "string") return null;
+	const normalized = normalizeMime(value);
+	return normalized.includes("/") ? normalized : null;
+}
+function mediaKindFromMime(mimeType) {
+	if (!mimeType) return null;
+	if (mimeType.startsWith("image/")) return "image";
+	if (mimeType.startsWith("video/")) return "video";
+	if (mimeType.startsWith("audio/")) return "audio";
+	if (mimeType.startsWith("font/") || mimeType.startsWith("application/font-")) return "font";
+	if (mimeType.startsWith("text/")) return "text";
+	if (isDocumentMime(mimeType)) return "document";
+	if (isArchiveMime(mimeType)) return "archive";
+	return "other";
+}
+function isDocumentMime(mimeType) {
+	return mimeType === "application/pdf" || mimeType === "application/msword" || mimeType === "application/rtf" || mimeType === "application/vnd.ms-excel" || mimeType === "application/vnd.ms-powerpoint" || mimeType.startsWith("application/vnd.openxmlformats-officedocument.");
+}
+function isArchiveMime(mimeType) {
+	return mimeType === "application/zip" || mimeType === "application/gzip" || mimeType === "application/x-tar" || mimeType === "application/x-7z-compressed" || mimeType === "application/x-rar-compressed" || mimeType === "application/vnd.rar";
+}
+function readString$1(value) {
+	return typeof value === "string" ? value : null;
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/media/usage/source-key.ts
+const MEDIA_USAGE_CONTENT_SOURCE_VARIANTS = ["columns", "draft_overlay"];
+function buildContentMediaUsageSourceKey(input) {
+	if (input.collectionId) return `content:${input.collectionId}:${input.contentId}:${input.sourceVariant}`;
+	return `content:${input.collectionSlug}:${input.contentId}:${input.sourceVariant}`;
+}
+
+//#endregion
+//#region src/media/usage/content-snapshots.ts
+const CONTENT_COLLECTION_ID_RESULT = "__emdash_media_usage_collection_id";
+const CONTENT_SYSTEM_COLUMNS = [
+	"id",
+	"slug",
+	"status",
+	"created_at",
+	"updated_at",
+	"published_at",
+	"scheduled_at",
+	"deleted_at",
+	"version",
+	"live_revision_id",
+	"draft_revision_id",
+	"locale",
+	"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 {
+		success: false,
+		error: "CONTENT_NOT_FOUND"
+	};
+	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));
+	const displayData = projectRawData(row, discovery.displayFieldSlugs);
+	const occurrences = extractMediaUsageOccurrences({
+		fields: discovery.extractionFields,
+		data: columnsData
+	});
+	const columnsRevisionId = readNullableString(row.live_revision_id);
+	const columnsSource = buildContentSource({
+		collectionId: options.collectionId,
+		collectionSlug,
+		identityVersion: options.identityVersion,
+		row,
+		displayData,
+		sourceVariant: "columns",
+		revisionId: columnsRevisionId
+	});
+	const columnsProjection = await buildMediaUsageProjectionFingerprint({
+		collectionId,
+		source: columnsSource,
+		occurrences,
+		extractionFields: discovery.extractionFields
+	});
+	columnsSource.sourceFingerprint = columnsProjection.fingerprint;
+	const snapshots = [{
+		source: columnsSource,
+		occurrences,
+		fields: discovery.extractionFields,
+		projectionByteLength: columnsProjection.byteLength
+	}];
+	const draftRevisionId = readNullableString(row.draft_revision_id);
+	if (draftRevisionId) {
+		const attemptedDraftSource = buildContentSource({
+			collectionId: options.collectionId,
+			collectionSlug,
+			identityVersion: options.identityVersion,
+			row,
+			displayData,
+			sourceVariant: "draft_overlay",
+			revisionId: draftRevisionId
+		});
+		const revisionResult = await loadRevisionRow(db, draftRevisionId);
+		if (!revisionResult) return {
+			success: false,
+			error: "DRAFT_REVISION_NOT_FOUND",
+			source: attemptedDraftSource,
+			snapshots
+		};
+		if (!revisionResult.success) return {
+			success: false,
+			error: "DRAFT_REVISION_INVALID",
+			source: attemptedDraftSource,
+			snapshots
+		};
+		const revision = revisionResult.revision;
+		if (revision.collection !== collectionSlug || revision.entryId !== row.id) return {
+			success: false,
+			error: "DRAFT_REVISION_MISMATCH",
+			source: attemptedDraftSource,
+			snapshots
+		};
+		const revisionData = stripRevisionMetadata(revision.data);
+		const draftOverlayData = {
+			...columnsData,
+			...revisionData
+		};
+		const draftDisplayData = {
+			...displayData,
+			...projectPresentData(revisionData, discovery.displayFieldSlugs)
+		};
+		const draftContentSlug = readNullableString(revision.data._slug) ?? readNullableString(row.slug);
+		const draftOccurrences = extractMediaUsageOccurrences({
+			fields: discovery.extractionFields,
+			data: draftOverlayData
+		});
+		const draftSource = buildContentSource({
+			collectionId: options.collectionId,
+			collectionSlug,
+			identityVersion: options.identityVersion,
+			row,
+			displayData: draftDisplayData,
+			sourceVariant: "draft_overlay",
+			revisionId: draftRevisionId,
+			contentSlug: draftContentSlug
+		});
+		const draftProjection = await buildMediaUsageProjectionFingerprint({
+			collectionId,
+			source: draftSource,
+			occurrences: draftOccurrences,
+			extractionFields: discovery.extractionFields
+		});
+		draftSource.sourceFingerprint = draftProjection.fingerprint;
+		snapshots.push({
+			source: draftSource,
+			occurrences: draftOccurrences,
+			fields: discovery.extractionFields,
+			projectionByteLength: draftProjection.byteLength
+		});
+	}
+	return {
+		success: true,
+		snapshots
+	};
+}
+async function loadContentRow(db, collectionSlug, contentId, fieldSlugs, expectedCollectionId) {
+	const tableName = getContentTableName(collectionSlug);
+	const columnRefs = uniqueColumns([...CONTENT_SYSTEM_COLUMNS, ...fieldSlugs]).map((column) => sql.ref(`content.${column}`));
+	return (await sql`
+		SELECT
+			${sql.join(columnRefs, sql`, `)},
+			collection.id AS __emdash_media_usage_collection_id
+		FROM ${sql.ref(tableName)} AS content
+		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
+		}
+	};
+}
+function buildContentSource(input) {
+	const { collectionId, collectionSlug, identityVersion, row, displayData, sourceVariant, revisionId } = input;
+	const contentId = readString(row.id) ?? "";
+	const contentSlug = input.contentSlug ?? readNullableString(row.slug);
+	return {
+		sourceKey: buildContentMediaUsageSourceKey({
+			collectionId,
+			collectionSlug,
+			contentId,
+			sourceVariant
+		}),
+		sourceType: "content",
+		collectionId,
+		collectionSlug,
+		contentId,
+		sourceVariant,
+		locale: readNullableString(row.locale),
+		translationGroup: readNullableString(row.translation_group),
+		contentSlug,
+		contentTitle: deriveContentTitle(displayData, contentSlug, contentId),
+		contentStatus: readNullableString(row.status),
+		contentScheduledAt: readNullableString(row.scheduled_at),
+		contentDeletedAt: readNullableString(row.deleted_at),
+		revisionId,
+		schemaVersion: CONTENT_SOURCE_SCHEMA_VERSION,
+		sourceUpdatedAt: readNullableString(row.updated_at),
+		sourceVersion: readNumber(row.version),
+		identityVersion
+	};
+}
+function projectData(row, fieldSlugs) {
+	const data = {};
+	for (const fieldSlug of fieldSlugs) data[fieldSlug] = deserializeValue(row[fieldSlug] ?? null);
+	return data;
+}
+function projectRawData(row, fieldSlugs) {
+	const data = {};
+	for (const fieldSlug of fieldSlugs) data[fieldSlug] = row[fieldSlug] ?? null;
+	return data;
+}
+function projectPresentData(row, fieldSlugs) {
+	const data = {};
+	for (const fieldSlug of fieldSlugs) if (Object.hasOwn(row, fieldSlug)) data[fieldSlug] = row[fieldSlug];
+	return data;
+}
+function uniqueColumns(columns) {
+	const unique = [...new Set(columns)];
+	for (const column of unique) validateIdentifier(column, "content media usage column");
+	return unique;
+}
+function getContentTableName(collectionSlug) {
+	validateIdentifier(collectionSlug, "collection slug");
+	return `ec_${collectionSlug}`;
+}
+function deserializeValue(value) {
+	if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+	return value;
+}
+function parseRevisionData(value) {
+	if (typeof value === "string") try {
+		const parsed = JSON.parse(value);
+		return isRecord(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+	return isRecord(value) ? value : null;
+}
+function stripRevisionMetadata(data) {
+	const stripped = {};
+	for (const [key, value] of Object.entries(data)) if (!key.startsWith("_")) stripped[key] = value;
+	return stripped;
+}
+function deriveContentTitle(displayData, contentSlug, contentId) {
+	for (const fieldSlug of ["title", "name"]) {
+		const value = displayData[fieldSlug];
+		if (typeof value === "string" && value.trim()) return value;
+	}
+	return contentSlug ?? contentId;
+}
+function readString(value) {
+	return typeof value === "string" ? value : null;
+}
+function readNullableString(value) {
+	return value === null || value === void 0 ? null : readString(value);
+}
+function readNumber(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "bigint") return Number(value);
+	if (typeof value === "string" && value) {
+		const parsed = Number(value);
+		return Number.isFinite(parsed) ? parsed : null;
+	}
+	return null;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/media/usage/content-refresh.ts
+const CONTENT_MEDIA_USAGE_ADAPTER_ID = "content-media";
+const CONTENT_MEDIA_USAGE_COLLECTION_SCOPE = "collection";
+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
+});
+const ZERO_RESULT = {
+	success: true,
+	refreshedSourceCount: 0,
+	deletedSourceCount: 0,
+	failedSourceCount: 0
+};
+function createContentMediaUsageAdmissionBudget() {
+	return {
+		remainingOccurrenceMutationUnits: MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxOccurrenceMutationUnitsPerClaim,
+		remainingProjectionMutationBytes: MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxProjectionMutationBytesPerClaim,
+		hasReservedMutation: false
+	};
+}
+async function planContentMediaUsageProjectionAdmission(repo, snapshots, observedSources, canonicalSourceKeys, budget) {
+	const snapshotSourceKeys = new Set(snapshots.map((snapshot) => snapshot.source.sourceKey));
+	const absentSources = canonicalSourceKeys.filter((sourceKey) => !snapshotSourceKeys.has(sourceKey)).map((sourceKey) => observedSources.get(sourceKey)).filter((source) => source !== void 0);
+	let deletionOccurrenceUnits = 0;
+	let deletionBytes = 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 noOpSourceKeys = /* @__PURE__ */ new Set();
+	let cost = projectionAdmissionCost(snapshots, noOpSourceKeys, deletionOccurrenceUnits, deletionBytes);
+	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);
+	}
+	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" };
+	budget.remainingOccurrenceMutationUnits -= cost.occurrenceMutationUnits;
+	budget.remainingProjectionMutationBytes -= cost.projectionMutationBytes;
+	if (cost.occurrenceMutationUnits > 0 || cost.projectionMutationBytes > 0) budget.hasReservedMutation = true;
+	return {
+		outcome: "admitted",
+		noOpSourceKeys,
+		absentSources,
+		...cost
+	};
+}
+function projectionAdmissionCost(snapshots, noOpSourceKeys, deletionOccurrenceUnits, deletionBytes) {
+	return snapshots.reduce((cost, snapshot) => {
+		if (noOpSourceKeys.has(snapshot.source.sourceKey)) return cost;
+		cost.occurrenceMutationUnits += snapshot.occurrences.length;
+		cost.projectionMutationBytes += snapshot.projectionByteLength;
+		return cost;
+	}, {
+		occurrenceMutationUnits: deletionOccurrenceUnits,
+		projectionMutationBytes: deletionBytes
+	});
+}
+function exceedsProjectionAdmissionLimits(cost) {
+	return cost.occurrenceMutationUnits > MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxOccurrenceMutationUnitsPerClaim || cost.projectionMutationBytes > MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxProjectionMutationBytesPerClaim;
+}
+function storedMediaUsageSourceByteLength(source) {
+	return new TextEncoder().encode(JSON.stringify(source)).byteLength;
+}
+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 refreshContentMediaUsageUnlocked(db, collectionSlug, contentId, options) {
+	try {
+		let conflictResult = null;
+		if (options.durableWork) options.admissionBudget = createContentMediaUsageAdmissionBudget();
+		for (let attempt = 0; attempt < CONTENT_USAGE_REFRESH_MAX_ATTEMPTS; attempt++) {
+			const result = await refreshContentMediaUsageAttempt(db, collectionSlug, contentId, options);
+			if (result.errorCode !== "CONTENT_USAGE_GENERATION_CONFLICT") return result;
+			conflictResult = result;
+			if (options.admissionBudget?.hasReservedMutation) break;
+		}
+		if (options.durableWork) return generationConflictResult({
+			refreshedSourceCount: conflictResult?.refreshedSourceCount ?? 0,
+			deletedSourceCount: conflictResult?.deletedSourceCount ?? 0
+		});
+		return markGenerationConflict(db, collectionSlug, {
+			refreshedSourceCount: conflictResult?.refreshedSourceCount ?? 0,
+			deletedSourceCount: conflictResult?.deletedSourceCount ?? 0
+		});
+	} catch (error) {
+		console.error(`[media-usage] Failed to refresh ${collectionSlug}/${contentId}:`, error);
+		if (!options.durableWork) await markContentMediaUsageCollectionStaleSafely(db, collectionSlug, "CONTENT_USAGE_REFRESH_ERROR");
+		return {
+			success: false,
+			refreshedSourceCount: 0,
+			deletedSourceCount: 0,
+			failedSourceCount: 0,
+			errorCode: "CONTENT_USAGE_REFRESH_ERROR"
+		};
+	}
+}
+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 ? {
+		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);
+			return deleteCanonicalContentSourcesIfAbsent(repo, admission.absentSources, collectionSlug, contentId);
+		}
+		if (snapshotsResult.error === "CONTENT_NOT_FOUND" && !await contentCollectionExists(db, collectionSlug)) {
+			const deletedSourceCount = await repo.deleteContentSources(collectionSlug, contentId);
+			return {
+				...ZERO_RESULT,
+				deletedSourceCount
+			};
+		}
+		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
+		});
+		const deletedSourceCount = await repo.deleteContentSources(collectionSlug, contentId);
+		return {
+			...ZERO_RESULT,
+			deletedSourceCount
+		};
+	}
+	const admission = options.admissionBudget ? await planContentMediaUsageProjectionAdmission(repo, snapshotsResult.snapshots, observedSources, canonicalSourceKeys, options.admissionBudget) : null;
+	if (admission && admission.outcome !== "admitted") return admissionFailureResult(admission.outcome);
+	let refreshedSourceCount = 0;
+	for (const snapshot of snapshotsResult.snapshots) {
+		if (admission?.outcome === "admitted" && admission.noOpSourceKeys.has(snapshot.source.sourceKey)) {
+			refreshedSourceCount++;
+			continue;
+		}
+		const result = await repo.replaceSourceIfMatching(snapshot.source, snapshot.occurrences, observedSources.get(snapshot.source.sourceKey) ?? null);
+		if (result.unchanged) {
+			refreshedSourceCount++;
+			continue;
+		}
+		if (!result.replaced) return generationConflictResult({
+			refreshedSourceCount,
+			deletedSourceCount: 0
+		});
+		refreshedSourceCount++;
+	}
+	if (!await contentCollectionExists(db, collectionSlug, options.collectionId)) {
+		if (options.collectionId) return generationConflictResult({
+			refreshedSourceCount,
+			deletedSourceCount: 0
+		});
+		const deletedSourceCount = await repo.deleteContentSources(collectionSlug, contentId);
+		return {
+			...ZERO_RESULT,
+			deletedSourceCount
+		};
+	}
+	const expectedSourceKeys = new Set(snapshotsResult.snapshots.map((snapshot) => snapshot.source.sourceKey));
+	const absentSources = admission?.outcome === "admitted" ? admission.absentSources : canonicalSourceKeys.filter((sourceKey) => !expectedSourceKeys.has(sourceKey)).map((sourceKey) => observedSources.get(sourceKey)).filter((source) => source !== void 0);
+	let deletedSourceCount = 0;
+	for (const expectedSource of absentSources) {
+		const result = await repo.deleteSourceIfMatching(expectedSource.sourceKey, expectedSource);
+		if (result.deleted) {
+			deletedSourceCount++;
+			continue;
+		}
+		if (result.source) return generationConflictResult({
+			refreshedSourceCount,
+			deletedSourceCount
+		});
+	}
+	return {
+		success: true,
+		refreshedSourceCount,
+		deletedSourceCount,
+		failedSourceCount: 0
+	};
+}
+function contentSourceKeys(collectionSlug, contentId, collectionId) {
+	return MEDIA_USAGE_CONTENT_SOURCE_VARIANTS.map((sourceVariant) => buildContentMediaUsageSourceKey({
+		collectionId,
+		collectionSlug,
+		contentId,
+		sourceVariant
+	}));
+}
+function admissionFailureResult(outcome) {
+	return {
+		...generationConflictResult({
+			refreshedSourceCount: 0,
+			deletedSourceCount: 0
+		}),
+		errorCode: outcome === "intrinsic_resource_limit" ? "CONTENT_USAGE_RESOURCE_LIMIT" : "CONTENT_USAGE_GENERATION_CONFLICT"
+	};
+}
+async function markGenerationConflict(db, collectionSlug, counts) {
+	await markContentMediaUsageCollectionStaleSafely(db, collectionSlug, "CONTENT_USAGE_GENERATION_CONFLICT");
+	return {
+		success: false,
+		refreshedSourceCount: counts.refreshedSourceCount,
+		deletedSourceCount: counts.deletedSourceCount,
+		failedSourceCount: 0,
+		errorCode: "CONTENT_USAGE_GENERATION_CONFLICT"
+	};
+}
+function generationConflictResult(counts) {
+	return {
+		success: false,
+		refreshedSourceCount: counts.refreshedSourceCount,
+		deletedSourceCount: counts.deletedSourceCount,
+		failedSourceCount: 0,
+		errorCode: "CONTENT_USAGE_GENERATION_CONFLICT"
+	};
+}
+async function contentCollectionExists(db, collectionSlug, collectionId) {
+	let query = db.selectFrom("_emdash_collections").select("id").where("slug", "=", collectionSlug);
+	if (collectionId) query = query.where("id", "=", collectionId);
+	return await query.executeTakeFirst() !== void 0;
+}
+async function deleteContentMediaUsage(db, collectionSlug, contentId) {
+	validateIdentifier(collectionSlug, "collection slug");
+	return withContentUsageCollectionLock(collectionSlug, () => withContentUsageLock(collectionSlug, contentId, () => deleteContentMediaUsageUnlocked(db, collectionSlug, contentId)));
+}
+async function deleteContentMediaUsageUnlocked(db, collectionSlug, contentId) {
+	try {
+		const deletedSourceCount = await new MediaUsageRepository(db).deleteContentSources(collectionSlug, contentId);
+		return {
+			...ZERO_RESULT,
+			deletedSourceCount
+		};
+	} catch (error) {
+		console.error(`[media-usage] Failed to delete usage for ${collectionSlug}/${contentId}:`, error);
+		await markContentMediaUsageCollectionStaleSafely(db, collectionSlug, "CONTENT_USAGE_DELETE_ERROR");
+		return {
+			success: false,
+			refreshedSourceCount: 0,
+			deletedSourceCount: 0,
+			failedSourceCount: 0,
+			errorCode: "CONTENT_USAGE_DELETE_ERROR"
+		};
+	}
+}
+async function deleteContentMediaUsageCollection(db, collectionSlug) {
+	validateIdentifier(collectionSlug, "collection slug");
+	return withContentUsageCollectionLock(collectionSlug, () => deleteContentMediaUsageCollectionUnlocked(db, collectionSlug));
+}
+async function deleteContentMediaUsageCollectionUnlocked(db, collectionSlug) {
+	try {
+		const repo = new MediaUsageRepository(db);
+		const deletedSourceCount = await repo.deleteCollectionSources(collectionSlug);
+		await repo.deleteIndexStatus({
+			adapterId: CONTENT_MEDIA_USAGE_ADAPTER_ID,
+			scopeType: CONTENT_MEDIA_USAGE_COLLECTION_SCOPE,
+			scopeKey: collectionSlug
+		});
+		return {
+			...ZERO_RESULT,
+			deletedSourceCount
+		};
+	} catch (error) {
+		console.error(`[media-usage] Failed to delete usage for collection ${collectionSlug}:`, error);
+		try {
+			await new MediaUsageRepository(db).deleteIndexStatus({
+				adapterId: CONTENT_MEDIA_USAGE_ADAPTER_ID,
+				scopeType: CONTENT_MEDIA_USAGE_COLLECTION_SCOPE,
+				scopeKey: collectionSlug
+			});
+		} catch (statusError) {
+			console.error(`[media-usage] Failed to clear usage status for deleted collection ${collectionSlug}:`, statusError);
+		}
+		return {
+			success: false,
+			refreshedSourceCount: 0,
+			deletedSourceCount: 0,
+			failedSourceCount: 0,
+			errorCode: "CONTENT_USAGE_DELETE_ERROR"
+		};
+	}
+}
+async function refreshContentMediaUsageAfterWrite(db, collectionSlug, contentId) {
+	const result = await refreshContentMediaUsage(db, collectionSlug, contentId);
+	if (!result.success) console.error(`[media-usage] Usage refresh for ${collectionSlug}/${contentId} finished with ${result.errorCode}`);
+}
+async function markContentMediaUsageCollectionStale(db, collectionSlug, lastErrorCode) {
+	validateIdentifier(collectionSlug, "collection slug");
+	const repo = new MediaUsageRepository(db);
+	const identity = {
+		adapterId: CONTENT_MEDIA_USAGE_ADAPTER_ID,
+		scopeType: CONTENT_MEDIA_USAGE_COLLECTION_SCOPE,
+		scopeKey: collectionSlug
+	};
+	const existing = await repo.findIndexStatus(identity);
+	await repo.upsertIndexStatus({
+		...identity,
+		status: "stale",
+		schemaVersion: existing?.schemaVersion ?? CONTENT_SOURCE_SCHEMA_VERSION,
+		startedAt: existing?.startedAt ?? null,
+		completedAt: existing?.completedAt ?? null,
+		cursor: existing?.cursor ?? null,
+		indexedSourceCount: existing?.indexedSourceCount ?? 0,
+		failedSourceCount: existing?.failedSourceCount ?? 0,
+		lastErrorCode
+	});
+}
+async function invalidateContentMediaUsageSchemaChange(db, collectionSlug) {
+	validateIdentifier(collectionSlug, "collection slug");
+	if (!await tableExists(db, "_emdash_media_usage_activation")) return false;
+	if ((await db.selectFrom("_emdash_media_usage_activation").select("state").where("task_key", "=", "incremental_capture").executeTakeFirst())?.state !== "active") return false;
+	if (!await new MediaUsageRepository(db).invalidateIndexStatusForSchemaChange(collectionSlug)) throw new Error(`Cannot invalidate media usage coverage for collection ${collectionSlug}`);
+	return true;
+}
+async function findNonTranslatableSiblingContentIds(db, collectionSlug, updatedContentId, translationGroup, updatedData) {
+	if (!isI18nEnabled() || !updatedData || !translationGroup) return [];
+	validateIdentifier(collectionSlug, "collection slug");
+	const collection = await db.selectFrom("_emdash_collections").select("id").where("slug", "=", collectionSlug).executeTakeFirst();
+	if (!collection) return [];
+	const touchedNonTranslatableSlugs = (await db.selectFrom("_emdash_fields").select("slug").where("collection_id", "=", collection.id).where("translatable", "=", 0).execute()).filter((field) => field.slug in updatedData).map((field) => field.slug);
+	if (touchedNonTranslatableSlugs.length === 0) return [];
+	const usageFields = await loadContentMediaUsageFields(db, collectionSlug);
+	const usageRelevantSlugs = new Set([...usageFields.extractionFields.map((field) => field.slug), ...usageFields.displayFieldSlugs]);
+	if (!touchedNonTranslatableSlugs.some((slug) => usageRelevantSlugs.has(slug))) return [];
+	const tableName = `ec_${collectionSlug}`;
+	return (await sql`
+		SELECT id
+		FROM ${sql.ref(tableName)}
+		WHERE translation_group = ${translationGroup}
+		AND id != ${updatedContentId}
+		ORDER BY id ASC
+	`.execute(db)).rows.map((row) => row.id);
+}
+async function markSnapshotFailure(db, collectionSlug, result) {
+	const repo = new MediaUsageRepository(db);
+	if (result.source) await repo.markSourceAttempted({
+		...result.source,
+		sourceCompleteness: "failed",
+		lastErrorCode: result.error
+	});
+	await markContentMediaUsageCollectionStale(db, collectionSlug, result.error);
+	return {
+		success: false,
+		refreshedSourceCount: 0,
+		deletedSourceCount: 0,
+		failedSourceCount: result.source ? 1 : 0,
+		errorCode: result.error
+	};
+}
+function snapshotFailureResult(result) {
+	return {
+		success: false,
+		refreshedSourceCount: 0,
+		deletedSourceCount: 0,
+		failedSourceCount: result.source ? 1 : 0,
+		errorCode: result.error
+	};
+}
+async function deleteCanonicalContentSourcesIfAbsent(repo, observedSources, collectionSlug, contentId) {
+	let deletedSourceCount = 0;
+	for (const source of observedSources) {
+		const result = await repo.deleteSourceIfMatchingContentAbsent(source.sourceKey, source, collectionSlug, contentId);
+		if (result.deleted) {
+			deletedSourceCount++;
+			continue;
+		}
+		if (result.contentPresent || result.source) return generationConflictResult({
+			refreshedSourceCount: 0,
+			deletedSourceCount
+		});
+	}
+	return {
+		...ZERO_RESULT,
+		deletedSourceCount
+	};
+}
+async function markContentMediaUsageCollectionStaleSafely(db, collectionSlug, lastErrorCode) {
+	try {
+		await markContentMediaUsageCollectionStale(db, collectionSlug, lastErrorCode);
+		return true;
+	} catch (error) {
+		console.error(`[media-usage] Failed to mark ${collectionSlug} stale:`, error);
+		return false;
+	}
+}
+async function withContentUsageLock(collectionSlug, contentId, fn) {
+	const locks = getContentUsageLocks();
+	const lockKey = `${collectionSlug}\0${contentId}`;
+	const previous = locks.get(lockKey) ?? Promise.resolve();
+	let releaseCurrent;
+	const current = new Promise((resolve) => {
+		releaseCurrent = resolve;
+	});
+	const next = previous.catch(() => {}).then(() => current);
+	locks.set(lockKey, next);
+	try {
+		await previous.catch(() => {});
+		return await fn();
+	} finally {
+		releaseCurrent();
+		if (locks.get(lockKey) === next) locks.delete(lockKey);
+	}
+}
+async function withContentUsageCollectionLock(collectionSlug, fn) {
+	const locks = getContentUsageCollectionLocks();
+	const previous = locks.get(collectionSlug) ?? Promise.resolve();
+	let releaseCurrent;
+	const current = new Promise((resolve) => {
+		releaseCurrent = resolve;
+	});
+	const next = previous.catch(() => {}).then(() => current);
+	locks.set(collectionSlug, next);
+	try {
+		await previous.catch(() => {});
+		return await fn();
+	} finally {
+		releaseCurrent();
+		if (locks.get(collectionSlug) === next) locks.delete(collectionSlug);
+	}
+}
+function getContentUsageLocks() {
+	const global = globalThis;
+	const existing = global[CONTENT_USAGE_LOCKS_KEY];
+	if (existing instanceof Map) return existing;
+	const locks = /* @__PURE__ */ new Map();
+	global[CONTENT_USAGE_LOCKS_KEY] = locks;
+	return locks;
+}
+function getContentUsageCollectionLocks() {
+	const global = globalThis;
+	const existing = global[CONTENT_USAGE_COLLECTION_LOCKS_KEY];
+	if (existing instanceof Map) return existing;
+	const locks = /* @__PURE__ */ new Map();
+	global[CONTENT_USAGE_COLLECTION_LOCKS_KEY] = locks;
+	return locks;
+}
+
+//#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-DNERP4-f.mjs.map