emdash 0.39.1 → 0.40.1

package/dist/media-usage-De-zeR9E.mjs

@@ -0,0 +1,1629 @@
+import { u as __exportAll } from "./runner-1y4J9fJB.mjs";
+import { t as validateIdentifier } from "./validate-DANX1-Qi.mjs";
+import { u as isPostgres } from "./dialect-helpers-7_IqPdh9.mjs";
+import { getRequestContext } from "./request-context.mjs";
+import { i as InvalidCursorError } from "./types-BkUg2yHx.mjs";
+import { t as withTransaction } from "./transaction-BcJO4Tmc.mjs";
+import { t as MediaRepository } from "./media-CPXTbb1R.mjs";
+import { a as continueMediaUsageActivation, n as MediaUsageActivationVersionMismatchError, s as getMediaUsageActivationStatus, t as MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION } from "./activation-LOkDM5WT.mjs";
+import { B as CONTENT_MEDIA_USAGE_ADAPTER_ID, D as contentRefreshKey, G as jsonTextValues, K as CONTENT_SOURCE_SCHEMA_VERSION, R as buildContentMediaUsageFieldFingerprint, V as CONTENT_MEDIA_USAGE_COLLECTION_SCOPE, W as MediaUsageRepository, j as refreshContentMediaUsageForWorkBatch, z as loadContentMediaUsageFields } from "./block-type-registry-DUI_3KxT.mjs";
+import { t as MediaUsageWorkRepository } from "./media-usage-work-C2OZLCAd.mjs";
+import { n as repairContentMediaUsageCollection, t as repairContentMediaUsageAll } from "./content-repair-Q8IUrpLL.mjs";
+import { t as processDueMediaUsageCollectionDeletions } from "./collection-deletion-processor-Br6rxs3u.mjs";
+import { n as MEDIA_USAGE_SITE_SETTING_OPTIONS, r as groupSiteSettingMediaUsage } from "./site-settings-DOgRUoFX.mjs";
+import { t as ErrorCode } from "./errors-BF0_LFhW.mjs";
+import { sql } from "kysely";
+import { ulid } from "ulidx";
+
+//#region src/media/usage/reconciliation.ts
+const ACTIVATION_KEY = "incremental_capture";
+const CONTENT_ADAPTER_ID = "content-media";
+const COLLECTION_SCOPE = "collection";
+const MAX_CANDIDATES = 100;
+const MAX_PORTABLE_DURATION_SECONDS = 365 * 24 * 60 * 60;
+const STABLE_ERROR_CODE_PATTERN = /^[A-Z][A-Z0-9_]{0,63}$/;
+var MediaUsageReconciliationRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async findByIdentity(collectionId, runToken) {
+		assertIdentity({
+			collectionId,
+			runToken
+		});
+		const row = await this.db.selectFrom("_emdash_media_usage_reconciliations").selectAll().where("collection_id", "=", collectionId).where("run_token", "=", runToken).executeTakeFirst();
+		return row ? rowToRecord(row) : null;
+	}
+	async beginRun(claim) {
+		const now = timestampOffset(this.db, 0);
+		const sameRun = sql`status = 'running' AND cursor = ${claim.runToken}`;
+		return (await this.db.updateTable("_emdash_media_usage_index_status as status").set({
+			status: "running",
+			started_at: sql`CASE WHEN ${sameRun} THEN started_at ELSE ${now} END`,
+			completed_at: null,
+			cursor: claim.runToken,
+			indexed_source_count: 0,
+			failed_source_count: 0,
+			last_error_code: null,
+			change_epoch: sql`CASE WHEN ${sameRun} THEN change_epoch ELSE change_epoch + 1 END`,
+			reconciliation_required: 1,
+			updated_at: now
+		}).where("status.adapter_id", "=", CONTENT_ADAPTER_ID).where("status.scope_type", "=", COLLECTION_SCOPE).where("status.collection_id", "=", claim.collectionId).where("status.scope_key", "=", claim.collectionSlug).where("status.capture_state", "=", "active").where("status.reconciliation_required", "=", 1).where((eb) => eb.or([eb("status.status", "!=", "running"), eb("status.cursor", "=", claim.runToken)])).where(this.liveClaimExists(claim)).returning("change_epoch").executeTakeFirst())?.change_epoch ?? null;
+	}
+	async findScanUpperId(claim) {
+		const tableName = contentTableName(claim.collectionSlug);
+		return (await sql`
+			SELECT content.id
+			FROM ${sql.ref(tableName)} AS content
+			WHERE ${this.liveClaimExistsSql(claim)}
+			ORDER BY content.id DESC
+			LIMIT 1
+		`.execute(this.db)).rows[0]?.id ?? null;
+	}
+	async initializeScan(input) {
+		const result = await this.db.updateTable("_emdash_media_usage_reconciliations as reconciliation").set({
+			target_epoch: input.targetEpoch,
+			field_fingerprint: input.fieldFingerprint,
+			phase: "scan",
+			scan_cursor: null,
+			scan_upper_id: input.scanUpperId,
+			source_cursor: null,
+			source_upper_key: null,
+			attempt_count: 0,
+			last_error_code: null,
+			updated_at: timestampOffset(this.db, 0)
+		}).where("reconciliation.collection_id", "=", input.claim.collectionId).where("reconciliation.run_token", "=", input.claim.runToken).where("reconciliation.target_epoch", "is", null).where("reconciliation.state", "=", "leased").where("reconciliation.lease_token", "=", input.claim.leaseToken).where(liveLease(this.db)).where(this.statusOwnsRun(input.claim, input.targetEpoch)).executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) === 1;
+	}
+	async findScanPage(reconciliation, limit) {
+		if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1e3) throw new Error("Reconciliation scan page limit must be from 1 to 1000");
+		if (!reconciliation.leaseToken || reconciliation.targetEpoch === null) return [];
+		const tableName = contentTableName(reconciliation.collectionSlug);
+		const lowerBound = reconciliation.scanCursor ? sql`AND content.id > ${reconciliation.scanCursor}` : sql``;
+		const upperBound = reconciliation.scanUpperId ? sql`AND content.id <= ${reconciliation.scanUpperId}` : sql`AND 1 = 0`;
+		return (await sql`
+			SELECT content.id
+			FROM ${sql.ref(tableName)} AS content
+			WHERE 1 = 1
+				${lowerBound}
+				${upperBound}
+				AND ${this.liveClaimExistsSql(reconciliation)}
+			ORDER BY content.id ASC
+			LIMIT ${limit}
+		`.execute(this.db)).rows.map((row) => row.id);
+	}
+	async checkpointScan(input) {
+		let query = this.db.updateTable("_emdash_media_usage_reconciliations as reconciliation").set({
+			scan_cursor: input.nextCursor,
+			attempt_count: 0,
+			last_error_code: null,
+			updated_at: timestampOffset(this.db, 0)
+		}).where("reconciliation.collection_id", "=", input.claim.collectionId).where("reconciliation.run_token", "=", input.claim.runToken).where("reconciliation.target_epoch", "=", input.targetEpoch).where("reconciliation.state", "=", "leased").where("reconciliation.phase", "=", "scan").where("reconciliation.lease_token", "=", input.claim.leaseToken).where(liveLease(this.db)).where(this.statusOwnsRun(input.claim, input.targetEpoch));
+		query = input.previousCursor ? query.where("reconciliation.scan_cursor", "=", input.previousCursor) : query.where("reconciliation.scan_cursor", "is", null);
+		const result = await query.executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) === 1;
+	}
+	async ownsRun(claim, targetEpoch) {
+		const result = await sql`
+			SELECT ${this.statusOwnsRun(claim, targetEpoch)} AS owned
+		`.execute(this.db);
+		return Boolean(result.rows[0]?.owned);
+	}
+	async restartRun(claim, previousEpoch) {
+		const now = timestampOffset(this.db, 0);
+		const interruptedRestart = sql`status = 'running'
+			AND cursor = ${claim.runToken}
+			AND change_epoch > ${previousEpoch}`;
+		return (await this.db.updateTable("_emdash_media_usage_index_status as status").set({
+			status: "running",
+			started_at: sql`CASE WHEN ${interruptedRestart} THEN started_at ELSE ${now} END`,
+			completed_at: null,
+			cursor: claim.runToken,
+			last_error_code: null,
+			change_epoch: sql`CASE WHEN ${interruptedRestart} THEN change_epoch ELSE change_epoch + 1 END`,
+			reconciliation_required: 1,
+			updated_at: now
+		}).where("status.adapter_id", "=", CONTENT_ADAPTER_ID).where("status.scope_type", "=", COLLECTION_SCOPE).where("status.collection_id", "=", claim.collectionId).where("status.scope_key", "=", claim.collectionSlug).where("status.capture_state", "=", "active").where("status.reconciliation_required", "=", 1).where((eb) => eb.or([eb("status.status", "!=", "running"), eb("status.cursor", "=", claim.runToken)])).where(this.liveClaimExists(claim)).returning("change_epoch").executeTakeFirst())?.change_epoch ?? null;
+	}
+	async restartScan(input) {
+		const result = await this.db.updateTable("_emdash_media_usage_reconciliations as reconciliation").set({
+			target_epoch: input.targetEpoch,
+			field_fingerprint: input.fieldFingerprint,
+			phase: "scan",
+			scan_cursor: null,
+			scan_upper_id: input.scanUpperId,
+			source_cursor: null,
+			source_upper_key: null,
+			attempt_count: 0,
+			next_attempt_at: timestampOffset(this.db, 0),
+			last_error_code: null,
+			updated_at: timestampOffset(this.db, 0)
+		}).where("reconciliation.collection_id", "=", input.claim.collectionId).where("reconciliation.run_token", "=", input.claim.runToken).where("reconciliation.target_epoch", "=", input.previousEpoch).where("reconciliation.state", "=", "leased").where("reconciliation.lease_token", "=", input.claim.leaseToken).where(liveLease(this.db)).where(this.statusOwnsRun(input.claim, input.targetEpoch)).executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) === 1;
+	}
+	async findWorkBarrier(collectionId) {
+		if (!collectionId) throw new Error("Reconciliation work barrier requires a collection ID");
+		const failed = await this.db.selectFrom("_emdash_media_usage_work").select("last_error_code").where("collection_id", "=", collectionId).where("state", "=", "failed").orderBy("content_id").limit(1).executeTakeFirst();
+		if (failed) return {
+			state: "failed",
+			errorCode: failed.last_error_code ?? "MEDIA_USAGE_PROCESSING_FAILED"
+		};
+		return await this.db.selectFrom("_emdash_media_usage_work").select("content_id").where("collection_id", "=", collectionId).limit(1).executeTakeFirst() ? { state: "pending" } : { state: "empty" };
+	}
+	async findSourceUpperKey(claim, targetEpoch) {
+		return (await this.db.selectFrom("_emdash_media_usage_sources as source").select("source.source_key").where("source.source_type", "=", "content").where("source.collection_id", "=", claim.collectionId).where("source.identity_version", "=", 1).where(this.liveClaimExists(claim)).where(this.statusOwnsRun(claim, targetEpoch)).orderBy("source.source_key", "desc").limit(1).executeTakeFirst())?.source_key ?? null;
+	}
+	async transitionToSources(input) {
+		const result = await this.db.updateTable("_emdash_media_usage_reconciliations as reconciliation").set({
+			phase: "sources",
+			source_cursor: null,
+			source_upper_key: input.sourceUpperKey,
+			attempt_count: 0,
+			last_error_code: null,
+			updated_at: timestampOffset(this.db, 0)
+		}).where("reconciliation.collection_id", "=", input.claim.collectionId).where("reconciliation.run_token", "=", input.claim.runToken).where("reconciliation.target_epoch", "=", input.targetEpoch).where("reconciliation.field_fingerprint", "=", input.fieldFingerprint).where("reconciliation.state", "=", "leased").where("reconciliation.phase", "=", "scan").where("reconciliation.lease_token", "=", input.claim.leaseToken).where(liveLease(this.db)).where(this.statusOwnsRun(input.claim, input.targetEpoch)).where((eb) => eb.not(eb.exists(eb.selectFrom("_emdash_media_usage_work as work").select("work.content_id").where("work.collection_id", "=", input.claim.collectionId)))).executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) === 1;
+	}
+	async findSourcePage(reconciliation, limit) {
+		if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1e3) throw new Error("Reconciliation source page limit must be from 1 to 1000");
+		if (!reconciliation.leaseToken || reconciliation.targetEpoch === null) return [];
+		let query = this.db.selectFrom("_emdash_media_usage_sources as source").select([
+			"source.source_key",
+			"source.content_id",
+			"source.source_variant"
+		]).where("source.source_type", "=", "content").where("source.collection_id", "=", reconciliation.collectionId).where("source.identity_version", "=", 1).where(this.liveClaimExists(reconciliation)).where(this.statusOwnsRun(reconciliation, reconciliation.targetEpoch));
+		if (reconciliation.sourceCursor) query = query.where("source.source_key", ">", reconciliation.sourceCursor);
+		if (reconciliation.sourceUpperKey) query = query.where("source.source_key", "<=", reconciliation.sourceUpperKey);
+		else query = query.where(sql`1 = 0`);
+		return (await query.orderBy("source.source_key").limit(limit).execute()).map((row) => ({
+			sourceKey: row.source_key,
+			contentId: row.content_id,
+			sourceVariant: row.source_variant
+		}));
+	}
+	async findMissingContentIds(collectionSlug, contentIds) {
+		const unique = [...new Set(contentIds)];
+		if (unique.length === 0) return [];
+		if (unique.length > 1e3 || unique.some((contentId) => !contentId)) throw new Error("Reconciliation source page has invalid content identity");
+		const tableName = contentTableName(collectionSlug);
+		const existing = await sql`
+			WITH requested AS (${jsonTextValues(this.db, unique)})
+			SELECT content.id
+			FROM ${sql.ref(tableName)} AS content
+			INNER JOIN requested ON requested.value = content.id
+		`.execute(this.db);
+		const present = new Set(existing.rows.map((row) => row.id));
+		return unique.filter((contentId) => !present.has(contentId));
+	}
+	async checkpointSources(input) {
+		let query = this.db.updateTable("_emdash_media_usage_reconciliations as reconciliation").set({
+			source_cursor: input.nextCursor,
+			attempt_count: 0,
+			last_error_code: null,
+			updated_at: timestampOffset(this.db, 0)
+		}).where("reconciliation.collection_id", "=", input.claim.collectionId).where("reconciliation.run_token", "=", input.claim.runToken).where("reconciliation.target_epoch", "=", input.targetEpoch).where("reconciliation.state", "=", "leased").where("reconciliation.phase", "=", "sources").where("reconciliation.lease_token", "=", input.claim.leaseToken).where(liveLease(this.db)).where(this.statusOwnsRun(input.claim, input.targetEpoch));
+		query = input.previousCursor ? query.where("reconciliation.source_cursor", "=", input.previousCursor) : query.where("reconciliation.source_cursor", "is", null);
+		const result = await query.executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) === 1;
+	}
+	async finishFailedCoverage(collectionId, runToken) {
+		assertIdentity({
+			collectionId,
+			runToken
+		});
+		const now = timestampOffset(this.db, 0);
+		const result = await this.db.updateTable("_emdash_media_usage_index_status as status").set({
+			status: sql`CASE WHEN EXISTS (
+					SELECT 1 FROM _emdash_media_usage_sources AS source
+					WHERE source.source_type = 'content'
+						AND source.collection_id = ${collectionId}
+						AND source.identity_version = 1
+					LIMIT 1
+				) THEN 'partial' ELSE 'failed' END`,
+			completed_at: null,
+			cursor: null,
+			last_error_code: sql`CASE WHEN (
+					SELECT reconciliation.last_error_code
+					FROM _emdash_media_usage_reconciliations AS reconciliation
+					WHERE reconciliation.collection_id = ${collectionId}
+						AND reconciliation.run_token = ${runToken}
+				) = 'MEDIA_USAGE_RECONCILIATION_ENTRY_FAILED'
+				THEN COALESCE(
+					(SELECT work.last_error_code
+					 FROM _emdash_media_usage_work AS work
+					 WHERE work.collection_id = ${collectionId} AND work.state = 'failed'
+					 ORDER BY work.content_id LIMIT 1),
+					'MEDIA_USAGE_RECONCILIATION_ENTRY_FAILED'
+				)
+				ELSE (
+					SELECT reconciliation.last_error_code
+					FROM _emdash_media_usage_reconciliations AS reconciliation
+					WHERE reconciliation.collection_id = ${collectionId}
+						AND reconciliation.run_token = ${runToken}
+				) END`,
+			reconciliation_required: 1,
+			updated_at: now
+		}).where("status.adapter_id", "=", CONTENT_ADAPTER_ID).where("status.scope_type", "=", COLLECTION_SCOPE).where("status.collection_id", "=", collectionId).where("status.status", "=", "running").where("status.cursor", "=", runToken).where(sql`status.change_epoch = (
+				SELECT reconciliation.target_epoch
+				FROM _emdash_media_usage_reconciliations AS reconciliation
+				WHERE reconciliation.collection_id = ${collectionId}
+					AND reconciliation.run_token = ${runToken}
+			)`).where((eb) => eb.exists(eb.selectFrom("_emdash_media_usage_reconciliations as reconciliation").select("reconciliation.collection_id").where("reconciliation.collection_id", "=", collectionId).where("reconciliation.run_token", "=", runToken).where("reconciliation.state", "=", "failed"))).executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) === 1;
+	}
+	async finalizeCoverage(input) {
+		const now = timestampOffset(this.db, 0);
+		const result = await this.db.updateTable("_emdash_media_usage_index_status as status").set({
+			status: "complete",
+			schema_version: input.schemaVersion,
+			completed_at: now,
+			cursor: null,
+			last_error_code: null,
+			reconciliation_required: 0,
+			updated_at: now
+		}).where("status.adapter_id", "=", CONTENT_ADAPTER_ID).where("status.scope_type", "=", COLLECTION_SCOPE).where("status.collection_id", "=", input.claim.collectionId).where("status.scope_key", "=", input.claim.collectionSlug).where("status.capture_state", "=", "active").where("status.reconciliation_required", "=", 1).where("status.status", "=", "running").where("status.cursor", "=", input.claim.runToken).where("status.change_epoch", "=", input.targetEpoch).where((eb) => eb.not(eb.exists(eb.selectFrom("_emdash_media_usage_work as work").select("work.content_id").where("work.collection_id", "=", input.claim.collectionId)))).where((eb) => eb.exists(eb.selectFrom("_emdash_media_usage_reconciliations as reconciliation").innerJoin("_emdash_collections as collection", (join) => join.onRef("collection.id", "=", "reconciliation.collection_id").onRef("collection.slug", "=", "reconciliation.collection_slug")).select("reconciliation.collection_id").where("reconciliation.collection_id", "=", input.claim.collectionId).where("reconciliation.run_token", "=", input.claim.runToken).where("reconciliation.target_epoch", "=", input.targetEpoch).where("reconciliation.field_fingerprint", "=", input.fieldFingerprint).where("reconciliation.state", "=", "leased").where("reconciliation.phase", "=", "sources").where("reconciliation.lease_token", "=", input.claim.leaseToken).where(liveLease(this.db, "reconciliation.lease_expires_at")).where((inner) => inner.not(inner.exists(inner.selectFrom("_emdash_media_usage_collection_deletions as deletion").select("deletion.collection_id").where("deletion.collection_id", "=", input.claim.collectionId)))))).where((eb) => eb.exists(eb.selectFrom("_emdash_media_usage_activation as activation").select("activation.task_key").where("activation.task_key", "=", ACTIVATION_KEY).where("activation.state", "=", "active"))).executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) === 1;
+	}
+	async deleteFinalized(claim) {
+		const result = await this.db.deleteFrom("_emdash_media_usage_reconciliations as reconciliation").where("reconciliation.collection_id", "=", claim.collectionId).where("reconciliation.run_token", "=", claim.runToken).where("reconciliation.state", "=", "leased").where("reconciliation.lease_token", "=", claim.leaseToken).where((eb) => eb.exists(eb.selectFrom("_emdash_media_usage_index_status as status").select("status.collection_id").where("status.collection_id", "=", claim.collectionId).where("status.scope_key", "=", claim.collectionSlug).where("status.status", "=", "complete").where("status.reconciliation_required", "=", 0))).executeTakeFirst();
+		return Number(result.numDeletedRows ?? 0) === 1;
+	}
+	async deleteOneObsolete() {
+		return (await sql`
+			DELETE FROM _emdash_media_usage_reconciliations
+			WHERE (collection_id, run_token) IN (
+				SELECT reconciliation.collection_id, reconciliation.run_token
+				FROM _emdash_media_usage_reconciliations AS reconciliation
+				INNER JOIN _emdash_media_usage_index_status AS status
+					ON status.collection_id = reconciliation.collection_id
+					AND status.scope_key = reconciliation.collection_slug
+				WHERE status.adapter_id = ${CONTENT_ADAPTER_ID}
+					AND status.scope_type = ${COLLECTION_SCOPE}
+					AND status.reconciliation_required = 0
+				ORDER BY reconciliation.updated_at, reconciliation.collection_id
+				LIMIT 1
+			)
+			RETURNING collection_id
+		`.execute(this.db)).rows.length === 1;
+	}
+	liveClaimExists(claim) {
+		return this.liveClaimExistsSql(claim);
+	}
+	liveClaimExistsSql(claim) {
+		return sql`EXISTS (
+			SELECT 1
+			FROM _emdash_media_usage_reconciliations AS reconciliation
+			INNER JOIN _emdash_collections AS collection
+				ON collection.id = reconciliation.collection_id
+				AND collection.slug = reconciliation.collection_slug
+			WHERE reconciliation.collection_id = ${claim.collectionId}
+				AND reconciliation.collection_slug = ${claim.collectionSlug}
+				AND reconciliation.run_token = ${claim.runToken}
+				AND reconciliation.state = 'leased'
+				AND reconciliation.lease_token = ${claim.leaseToken}
+				AND ${liveLease(this.db, "reconciliation.lease_expires_at")}
+				AND EXISTS (
+					SELECT 1 FROM _emdash_media_usage_activation AS activation
+					WHERE activation.task_key = ${ACTIVATION_KEY}
+						AND activation.state = 'active'
+				)
+				AND NOT EXISTS (
+					SELECT 1 FROM _emdash_media_usage_collection_deletions AS deletion
+					WHERE deletion.collection_id = reconciliation.collection_id
+				)
+		)`;
+	}
+	statusOwnsRun(claim, targetEpoch) {
+		return sql`EXISTS (
+			SELECT 1 FROM _emdash_media_usage_index_status AS status
+			WHERE status.adapter_id = ${CONTENT_ADAPTER_ID}
+				AND status.scope_type = ${COLLECTION_SCOPE}
+				AND status.collection_id = ${claim.collectionId}
+				AND status.scope_key = ${claim.collectionSlug}
+				AND status.capture_state = 'active'
+				AND status.reconciliation_required = 1
+				AND status.status = 'running'
+				AND status.cursor = ${claim.runToken}
+				AND status.change_epoch = ${targetEpoch}
+		)`;
+	}
+	async seedNextCandidate() {
+		const runToken = ulid();
+		const now = timestampOffset(this.db, 0);
+		return (await sql`
+			INSERT INTO _emdash_media_usage_reconciliations (
+				collection_id,
+				collection_slug,
+				run_token,
+				next_attempt_at,
+				updated_at
+			)
+			SELECT status.collection_id, status.scope_key, ${runToken}, ${now}, ${now}
+			FROM _emdash_media_usage_index_status AS status
+			INNER JOIN _emdash_collections AS collection
+				ON collection.id = status.collection_id
+				AND collection.slug = status.scope_key
+			WHERE status.adapter_id = ${CONTENT_ADAPTER_ID}
+				AND status.scope_type = ${COLLECTION_SCOPE}
+				AND status.capture_state = 'active'
+				AND status.reconciliation_required = 1
+				AND status.collection_id IS NOT NULL
+				AND EXISTS (
+					SELECT 1 FROM _emdash_media_usage_activation AS activation
+					WHERE activation.task_key = ${ACTIVATION_KEY}
+						AND activation.state = 'active'
+				)
+				AND NOT EXISTS (
+					SELECT 1 FROM _emdash_media_usage_reconciliations AS existing
+					WHERE existing.collection_id = status.collection_id
+				)
+				AND NOT EXISTS (
+					SELECT 1 FROM _emdash_media_usage_collection_deletions AS deletion
+					WHERE deletion.collection_id = status.collection_id
+				)
+			ORDER BY status.collection_id
+			LIMIT 1
+			ON CONFLICT (collection_id) DO NOTHING
+			RETURNING collection_id
+		`.execute(this.db)).rows.length === 1;
+	}
+	async findDue(limit) {
+		assertLimit(limit);
+		const nextAttemptIsDue = timestampIsDue(this.db, "next_attempt_at");
+		return (await sql`
+			WITH pending_candidates AS (
+				SELECT * FROM _emdash_media_usage_reconciliations
+				WHERE state = 'pending' AND ${nextAttemptIsDue}
+				ORDER BY next_attempt_at, updated_at, collection_id
+				LIMIT ${limit}
+			), retry_candidates AS (
+				SELECT * FROM _emdash_media_usage_reconciliations
+				WHERE state = 'retry' AND ${nextAttemptIsDue}
+				ORDER BY next_attempt_at, updated_at, collection_id
+				LIMIT ${limit}
+			), leased_candidates AS (
+				SELECT * FROM _emdash_media_usage_reconciliations
+				WHERE state = 'leased' AND ${timestampIsDue(this.db, "lease_expires_at")}
+				ORDER BY lease_expires_at, updated_at, collection_id
+				LIMIT ${limit}
+			), candidates AS (
+				SELECT * FROM pending_candidates
+				UNION ALL SELECT * FROM retry_candidates
+				UNION ALL SELECT * FROM leased_candidates
+			)
+			SELECT * FROM candidates
+			ORDER BY CASE WHEN state = 'leased' THEN lease_expires_at ELSE next_attempt_at END,
+				updated_at,
+				collection_id
+			LIMIT ${limit}
+		`.execute(this.db)).rows.map(rowToRecord);
+	}
+	async hasDeferredCandidate() {
+		return await this.db.selectFrom("_emdash_media_usage_reconciliations").select("collection_id").where("state", "in", [
+			"pending",
+			"retry",
+			"leased"
+		]).limit(1).executeTakeFirst() !== void 0;
+	}
+	async wakeDrainedBarrierCandidate() {
+		const now = timestampOffset(this.db, 0);
+		return (await sql`
+			UPDATE _emdash_media_usage_reconciliations
+			SET next_attempt_at = ${now}, updated_at = ${now}
+			WHERE collection_id = (
+				SELECT reconciliation.collection_id
+				FROM _emdash_media_usage_reconciliations AS reconciliation
+				INNER JOIN _emdash_media_usage_index_status AS status
+					ON status.collection_id = reconciliation.collection_id
+					AND status.scope_key = reconciliation.collection_slug
+				WHERE reconciliation.state = 'pending'
+					AND reconciliation.target_epoch IS NOT NULL
+					AND NOT ${timestampIsDue(this.db, "reconciliation.next_attempt_at")}
+					AND status.adapter_id = ${CONTENT_ADAPTER_ID}
+					AND status.scope_type = ${COLLECTION_SCOPE}
+					AND status.capture_state = 'active'
+					AND status.reconciliation_required = 1
+					AND status.status = 'running'
+					AND status.cursor = reconciliation.run_token
+					AND status.change_epoch = reconciliation.target_epoch
+					AND NOT EXISTS (
+						SELECT 1 FROM _emdash_media_usage_work AS work
+						WHERE work.collection_id = reconciliation.collection_id
+					)
+					AND NOT EXISTS (
+						SELECT 1 FROM _emdash_media_usage_collection_deletions AS deletion
+						WHERE deletion.collection_id = reconciliation.collection_id
+					)
+				ORDER BY reconciliation.next_attempt_at, reconciliation.updated_at,
+					reconciliation.collection_id
+				LIMIT 1
+			)
+			AND state = 'pending'
+			AND NOT ${timestampIsDue(this.db, "_emdash_media_usage_reconciliations.next_attempt_at")}
+			AND EXISTS (
+				SELECT 1 FROM _emdash_media_usage_activation AS activation
+				WHERE activation.task_key = ${ACTIVATION_KEY}
+					AND activation.state = 'active'
+			)
+			AND NOT EXISTS (
+				SELECT 1 FROM _emdash_media_usage_work AS work
+				WHERE work.collection_id = _emdash_media_usage_reconciliations.collection_id
+			)
+			RETURNING collection_id
+		`.execute(this.db)).rows.length === 1;
+	}
+	async findFailed(limit) {
+		assertLimit(limit);
+		return (await this.db.selectFrom("_emdash_media_usage_reconciliations as reconciliation").innerJoin("_emdash_media_usage_index_status as status", (join) => join.onRef("status.collection_id", "=", "reconciliation.collection_id").onRef("status.scope_key", "=", "reconciliation.collection_slug")).selectAll("reconciliation").where("reconciliation.state", "=", "failed").where("status.adapter_id", "=", CONTENT_ADAPTER_ID).where("status.scope_type", "=", COLLECTION_SCOPE).where((eb) => eb.or([
+			eb("status.reconciliation_required", "=", 0),
+			eb.and([eb("status.status", "=", "running"), eb("status.cursor", "=", eb.ref("reconciliation.run_token"))]),
+			eb.and([eb("status.cursor", "is", null), eb("status.change_epoch", ">", eb.ref("reconciliation.target_epoch"))])
+		])).orderBy("reconciliation.updated_at").orderBy("reconciliation.collection_id").limit(limit).execute()).map(rowToRecord);
+	}
+	async claim(input) {
+		assertIdentity(input);
+		assertDuration(input.leaseDurationSeconds, "lease duration");
+		const leaseToken = ulid();
+		const row = await this.db.updateTable("_emdash_media_usage_reconciliations as reconciliation").set({
+			state: "leased",
+			lease_token: leaseToken,
+			lease_expires_at: timestampOffset(this.db, input.leaseDurationSeconds),
+			updated_at: timestampOffset(this.db, 0)
+		}).where("reconciliation.collection_id", "=", input.collectionId).where("reconciliation.run_token", "=", input.runToken).where((eb) => eb.or([eb.and([eb("reconciliation.state", "in", ["pending", "retry"]), timestampIsDue(this.db, "reconciliation.next_attempt_at")]), eb.and([eb("reconciliation.state", "=", "leased"), timestampIsDue(this.db, "reconciliation.lease_expires_at")])])).where((eb) => eb.exists(eb.selectFrom("_emdash_media_usage_activation as activation").select("activation.task_key").where("activation.task_key", "=", ACTIVATION_KEY).where("activation.state", "=", "active"))).where((eb) => eb.exists(eb.selectFrom("_emdash_media_usage_index_status as status").innerJoin("_emdash_collections as collection", (join) => join.onRef("collection.id", "=", "status.collection_id").onRef("collection.slug", "=", "status.scope_key")).select("status.collection_id").whereRef("status.collection_id", "=", "reconciliation.collection_id").whereRef("status.scope_key", "=", "reconciliation.collection_slug").where("status.adapter_id", "=", CONTENT_ADAPTER_ID).where("status.scope_type", "=", COLLECTION_SCOPE).where("status.capture_state", "=", "active").where("status.reconciliation_required", "=", 1))).where((eb) => eb.not(eb.exists(eb.selectFrom("_emdash_media_usage_collection_deletions as deletion").select("deletion.collection_id").whereRef("deletion.collection_id", "=", "reconciliation.collection_id")))).returningAll().executeTakeFirst();
+		return row ? {
+			...rowToRecord(row),
+			leaseToken
+		} : null;
+	}
+	async release(input) {
+		assertLeaseIdentity(input);
+		assertDuration(input.delaySeconds, "release delay", true);
+		const result = await this.db.updateTable("_emdash_media_usage_reconciliations").set({
+			state: "pending",
+			next_attempt_at: timestampOffset(this.db, input.delaySeconds),
+			lease_token: null,
+			lease_expires_at: null,
+			updated_at: timestampOffset(this.db, 0)
+		}).where("collection_id", "=", input.collectionId).where("run_token", "=", input.runToken).where("state", "=", "leased").where("lease_token", "=", input.leaseToken).where(liveLease(this.db)).executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) === 1;
+	}
+	async recordFailure(input) {
+		assertLeaseIdentity(input);
+		if (!STABLE_ERROR_CODE_PATTERN.test(input.errorCode)) throw new Error("Reconciliation failure requires a stable error code");
+		assertDuration(input.retryDelaySeconds, "retry delay", true);
+		const result = await this.db.updateTable("_emdash_media_usage_reconciliations").set({
+			state: input.terminal ? "failed" : sql`CASE WHEN attempt_count >= 4 THEN 'failed' ELSE 'retry' END`,
+			...input.terminal ? { target_epoch: sql`COALESCE(
+								target_epoch,
+								(SELECT status.change_epoch
+								 FROM _emdash_media_usage_index_status AS status
+								 WHERE status.adapter_id = ${CONTENT_ADAPTER_ID}
+									AND status.scope_type = ${COLLECTION_SCOPE}
+									AND status.collection_id = ${input.collectionId}
+									AND status.status = 'running'
+									AND status.cursor = ${input.runToken})
+							)` } : {},
+			attempt_count: sql`attempt_count + 1`,
+			next_attempt_at: timestampOffset(this.db, input.retryDelaySeconds),
+			lease_token: null,
+			lease_expires_at: null,
+			last_error_code: input.errorCode,
+			updated_at: timestampOffset(this.db, 0)
+		}).where("collection_id", "=", input.collectionId).where("run_token", "=", input.runToken).where("state", "=", "leased").where("lease_token", "=", input.leaseToken).where(liveLease(this.db)).executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) === 1;
+	}
+	async recordEntryFailure(claim) {
+		const result = await this.db.updateTable("_emdash_media_usage_reconciliations as reconciliation").set({
+			state: "failed",
+			attempt_count: sql`attempt_count + 1`,
+			next_attempt_at: timestampOffset(this.db, 0),
+			lease_token: null,
+			lease_expires_at: null,
+			last_error_code: "MEDIA_USAGE_RECONCILIATION_ENTRY_FAILED",
+			updated_at: timestampOffset(this.db, 0)
+		}).where("reconciliation.collection_id", "=", claim.collectionId).where("reconciliation.run_token", "=", claim.runToken).where("reconciliation.state", "=", "leased").where("reconciliation.lease_token", "=", claim.leaseToken).where(liveLease(this.db)).where((eb) => eb.exists(eb.selectFrom("_emdash_media_usage_work as work").select("work.content_id").where("work.collection_id", "=", claim.collectionId).where("work.state", "=", "failed"))).executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) === 1;
+	}
+	async resetFailedForNewEpoch(observed) {
+		const collectionId = "collection_id" in observed ? observed.collection_id : observed.collectionId;
+		const runToken = "run_token" in observed ? observed.run_token : observed.runToken;
+		const targetEpoch = "target_epoch" in observed ? observed.target_epoch : observed.targetEpoch;
+		if (targetEpoch === null) return false;
+		const now = timestampOffset(this.db, 0);
+		const result = await this.db.updateTable("_emdash_media_usage_reconciliations as reconciliation").set({
+			state: "pending",
+			phase: "scan",
+			target_epoch: null,
+			field_fingerprint: null,
+			scan_cursor: null,
+			scan_upper_id: null,
+			source_cursor: null,
+			source_upper_key: null,
+			attempt_count: 0,
+			next_attempt_at: now,
+			lease_token: null,
+			lease_expires_at: null,
+			last_error_code: null,
+			updated_at: now
+		}).where("reconciliation.collection_id", "=", collectionId).where("reconciliation.run_token", "=", runToken).where("reconciliation.state", "=", "failed").where("reconciliation.target_epoch", "=", targetEpoch).where((eb) => eb.exists(eb.selectFrom("_emdash_media_usage_index_status as status").select("status.collection_id").whereRef("status.collection_id", "=", "reconciliation.collection_id").whereRef("status.scope_key", "=", "reconciliation.collection_slug").where("status.adapter_id", "=", CONTENT_ADAPTER_ID).where("status.scope_type", "=", COLLECTION_SCOPE).where("status.capture_state", "=", "active").where("status.reconciliation_required", "=", 1).where((status) => status.or([status("status.cursor", "is", null), status.and([status("status.status", "=", "running"), status("status.cursor", "=", runToken)])])).where("status.change_epoch", ">", targetEpoch))).executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) === 1;
+	}
+};
+function rowToRecord(row) {
+	if (!isState(row.state) || !isPhase(row.phase) || !Number.isSafeInteger(row.attempt_count)) throw new Error("Invalid media usage reconciliation lifecycle");
+	return {
+		collectionId: row.collection_id,
+		collectionSlug: row.collection_slug,
+		runToken: row.run_token,
+		targetEpoch: row.target_epoch,
+		fieldFingerprint: row.field_fingerprint,
+		state: row.state,
+		phase: row.phase,
+		scanCursor: row.scan_cursor,
+		scanUpperId: row.scan_upper_id,
+		sourceCursor: row.source_cursor,
+		sourceUpperKey: row.source_upper_key,
+		attemptCount: row.attempt_count,
+		nextAttemptAt: row.next_attempt_at,
+		leaseToken: row.lease_token,
+		leaseExpiresAt: row.lease_expires_at,
+		lastErrorCode: row.last_error_code,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function isState(state) {
+	return state === "pending" || state === "retry" || state === "leased" || state === "failed";
+}
+function isPhase(phase) {
+	return phase === "scan" || phase === "sources";
+}
+function assertLimit(limit) {
+	if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_CANDIDATES) throw new Error("Reconciliation candidate limit must be from 1 to 100");
+}
+function assertIdentity(input) {
+	if (!input.collectionId || !input.runToken) throw new Error("Reconciliation requires an exact collection and run token");
+}
+function assertLeaseIdentity(input) {
+	assertIdentity(input);
+	if (!input.leaseToken) throw new Error("Reconciliation requires a lease token");
+}
+function assertDuration(value, label, allowZero = false) {
+	if (!Number.isSafeInteger(value) || value < (allowZero ? 0 : 1) || value > MAX_PORTABLE_DURATION_SECONDS) throw new Error(`Reconciliation ${label} is outside the portable range`);
+}
+function liveLease(db, column = "lease_expires_at") {
+	const expiry = sql.ref(column);
+	return isPostgres(db) ? sql`${expiry} > to_char(statement_timestamp() AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')` : sql`${expiry} > strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
+}
+function timestampIsDue(db, column) {
+	const value = sql.ref(column);
+	return isPostgres(db) ? sql`${value} <= to_char(statement_timestamp() AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')` : sql`${value} <= strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
+}
+function timestampOffset(db, offsetSeconds) {
+	if (isPostgres(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`}
+	)`;
+}
+function contentTableName(collectionSlug) {
+	validateIdentifier(collectionSlug, "collection slug");
+	const tableName = `ec_${collectionSlug}`;
+	validateIdentifier(tableName, "content table");
+	return tableName;
+}
+
+//#endregion
+//#region src/media/usage/reconciliation-processor.ts
+const MEDIA_USAGE_RECONCILIATION_LIMITS = Object.freeze({
+	candidatesPerTick: 4,
+	scanPageSize: 1e3,
+	sourcePageSize: 1e3,
+	leaseDurationSeconds: 60,
+	maxAttempts: 5,
+	retryBaseSeconds: 30,
+	retryMaxSeconds: 900,
+	retryJitterRatio: .25
+});
+async function processDueMediaUsageReconciliationDetailed(db, options = {}) {
+	if (!options.activationKnownActive) {
+		if ((await db.selectFrom("_emdash_media_usage_activation").select("state").where("task_key", "=", "incremental_capture").executeTakeFirst())?.state !== "active") return {
+			outcome: "inactive",
+			consumedUnit: false,
+			hasDeferredCandidate: false
+		};
+	}
+	const reconciliation = new MediaUsageReconciliationRepository(db);
+	if (await reconciliation.deleteOneObsolete()) return {
+		outcome: "completed",
+		consumedUnit: true,
+		hasDeferredCandidate: false
+	};
+	const [failed] = await reconciliation.findFailed(1);
+	if (failed) {
+		if (await reconciliation.finishFailedCoverage(failed.collectionId, failed.runToken)) return {
+			outcome: "failed",
+			consumedUnit: true,
+			hasDeferredCandidate: false
+		};
+		if (await reconciliation.resetFailedForNewEpoch(failed)) return {
+			outcome: "advanced",
+			consumedUnit: true,
+			hasDeferredCandidate: false
+		};
+	}
+	const seeded = await reconciliation.seedNextCandidate();
+	const candidates = await reconciliation.findDue(MEDIA_USAGE_RECONCILIATION_LIMITS.candidatesPerTick);
+	let claim = null;
+	for (const candidate of candidates) {
+		claim = await reconciliation.claim({
+			collectionId: candidate.collectionId,
+			runToken: candidate.runToken,
+			leaseDurationSeconds: MEDIA_USAGE_RECONCILIATION_LIMITS.leaseDurationSeconds
+		});
+		if (claim) break;
+	}
+	if (!claim) return {
+		outcome: candidates.length === 0 ? "not_due" : "claim_lost",
+		consumedUnit: seeded,
+		hasDeferredCandidate: candidates.length === 0 && await reconciliation.hasDeferredCandidate()
+	};
+	try {
+		return {
+			outcome: await processClaimedReconciliation(db, claim),
+			consumedUnit: true,
+			hasDeferredCandidate: false
+		};
+	} catch (error) {
+		const terminal = claim.attemptCount + 1 >= MEDIA_USAGE_RECONCILIATION_LIMITS.maxAttempts;
+		if (!await reconciliation.recordFailure({
+			collectionId: claim.collectionId,
+			runToken: claim.runToken,
+			leaseToken: claim.leaseToken,
+			errorCode: "MEDIA_USAGE_RECONCILIATION_FAILED",
+			retryDelaySeconds: retryDelaySeconds$1(claim.attemptCount),
+			terminal
+		})) return {
+			outcome: "claim_lost",
+			consumedUnit: true,
+			hasDeferredCandidate: false
+		};
+		if (terminal) await reconciliation.finishFailedCoverage(claim.collectionId, claim.runToken);
+		console.error("[media-usage:reconciliation] Processing failed:", error);
+		return {
+			outcome: terminal ? "failed" : "retry",
+			consumedUnit: true,
+			hasDeferredCandidate: false
+		};
+	}
+}
+async function processClaimedMediaUsageReconciliationScan(db, claim, options = {}, knownCurrent) {
+	const reconciliation = new MediaUsageReconciliationRepository(db);
+	let current = knownCurrent ?? await reconciliation.findByIdentity(claim.collectionId, claim.runToken);
+	if (!current || current.leaseToken !== claim.leaseToken || current.phase !== "scan") return "deferred";
+	let fields;
+	let fieldFingerprint;
+	if (current.targetEpoch === null) {
+		const targetEpoch = await reconciliation.beginRun(claim);
+		if (targetEpoch === null) {
+			await reconciliation.release({
+				...claim,
+				delaySeconds: 30
+			});
+			return "deferred";
+		}
+		fields = await loadContentMediaUsageFields(db, claim.collectionSlug, claim.collectionId);
+		fieldFingerprint = await buildContentMediaUsageFieldFingerprint(fields);
+		const scanUpperId = fields.extractionFields.length === 0 ? null : await reconciliation.findScanUpperId(claim);
+		if (!await reconciliation.initializeScan({
+			claim,
+			targetEpoch,
+			fieldFingerprint,
+			scanUpperId
+		})) return "deferred";
+		current = {
+			...current,
+			targetEpoch,
+			fieldFingerprint,
+			scanCursor: null,
+			scanUpperId,
+			sourceCursor: null,
+			sourceUpperKey: null
+		};
+	} else {
+		fields = await loadContentMediaUsageFields(db, claim.collectionSlug, claim.collectionId);
+		fieldFingerprint = await buildContentMediaUsageFieldFingerprint(fields);
+	}
+	if (current.fieldFingerprint !== fieldFingerprint || current.targetEpoch === null) return "restart_required";
+	const contentIds = await reconciliation.findScanPage(current, MEDIA_USAGE_RECONCILIATION_LIMITS.scanPageSize);
+	if (contentIds.length === 0) {
+		if (options.releaseOnExhausted ?? true) await reconciliation.release({
+			...claim,
+			delaySeconds: 30
+		});
+		return "exhausted";
+	}
+	await new MediaUsageWorkRepository(db).enqueueReconciliationPage({
+		collectionId: claim.collectionId,
+		collectionSlug: claim.collectionSlug,
+		runToken: claim.runToken,
+		leaseToken: claim.leaseToken,
+		changeEpoch: current.targetEpoch,
+		phase: "scan",
+		contentIds
+	});
+	const nextCursor = contentIds.at(-1);
+	if (!await reconciliation.checkpointScan({
+		claim,
+		targetEpoch: current.targetEpoch,
+		previousCursor: current.scanCursor,
+		nextCursor
+	})) return "deferred";
+	if (!await reconciliation.release({
+		...claim,
+		delaySeconds: 0
+	})) return "deferred";
+	return "advanced";
+}
+async function processClaimedReconciliation(db, claim) {
+	const reconciliation = new MediaUsageReconciliationRepository(db);
+	let current = claim;
+	if (current.targetEpoch !== null && !await reconciliation.ownsRun(claim, current.targetEpoch)) return restartReconciliation(db, reconciliation, claim, current);
+	if (current.targetEpoch !== null) await new MediaUsageWorkRepository(db).deleteObsoleteReconciliationWork({
+		collectionId: claim.collectionId,
+		collectionSlug: claim.collectionSlug,
+		runToken: claim.runToken,
+		leaseToken: claim.leaseToken,
+		targetEpoch: current.targetEpoch
+	});
+	if (current.phase === "scan") {
+		const outcome = await processClaimedMediaUsageReconciliationScan(db, claim, { releaseOnExhausted: false }, current);
+		if (outcome === "restart_required") {
+			current = await reconciliation.findByIdentity(claim.collectionId, claim.runToken) ?? current;
+			return restartReconciliation(db, reconciliation, claim, current);
+		}
+		if (outcome !== "exhausted") return outcome;
+		if (current.targetEpoch === null || current.fieldFingerprint === null) current = await reconciliation.findByIdentity(claim.collectionId, claim.runToken) ?? current;
+		const barrier = await reconciliation.findWorkBarrier(claim.collectionId);
+		if (barrier.state === "failed") return failReconciliation(reconciliation, claim, barrier.errorCode, true);
+		if (barrier.state === "pending") {
+			await reconciliation.release({
+				...claim,
+				delaySeconds: 30
+			});
+			return "deferred";
+		}
+		if (current.targetEpoch === null || current.fieldFingerprint === null) return "claim_lost";
+		const sourceUpperKey = await reconciliation.findSourceUpperKey(claim, current.targetEpoch);
+		if (!await reconciliation.transitionToSources({
+			claim,
+			targetEpoch: current.targetEpoch,
+			fieldFingerprint: current.fieldFingerprint,
+			sourceUpperKey
+		})) return "claim_lost";
+		if (!await reconciliation.release({
+			...claim,
+			delaySeconds: 0
+		})) return "claim_lost";
+		return "advanced";
+	}
+	return processSourcePhase(db, reconciliation, claim, current);
+}
+async function processSourcePhase(db, reconciliation, claim, current) {
+	if (current.targetEpoch === null || current.fieldFingerprint === null) return "claim_lost";
+	const fields = await loadContentMediaUsageFields(db, claim.collectionSlug, claim.collectionId);
+	const fieldFingerprint = await buildContentMediaUsageFieldFingerprint(fields);
+	if (fieldFingerprint !== current.fieldFingerprint) return restartReconciliation(db, reconciliation, claim, current, fields, fieldFingerprint);
+	const page = await reconciliation.findSourcePage(current, MEDIA_USAGE_RECONCILIATION_LIMITS.sourcePageSize);
+	if (page.length > 0) {
+		let enqueuedMissingContent = false;
+		if (page.some((source) => !source.contentId || source.sourceVariant !== "columns" && source.sourceVariant !== "draft_overlay")) return failReconciliation(reconciliation, claim, "MEDIA_USAGE_RECONCILIATION_INVALID_SOURCE", false);
+		const contentIds = [...new Set(page.map((source) => source.contentId))];
+		const enqueueIds = fields.extractionFields.length === 0 ? contentIds : await reconciliation.findMissingContentIds(claim.collectionSlug, contentIds);
+		if (enqueueIds.length > 0) {
+			await new MediaUsageWorkRepository(db).enqueueReconciliationPage({
+				collectionId: claim.collectionId,
+				collectionSlug: claim.collectionSlug,
+				runToken: claim.runToken,
+				leaseToken: claim.leaseToken,
+				changeEpoch: current.targetEpoch,
+				phase: "sources",
+				contentIds: enqueueIds
+			});
+			enqueuedMissingContent = true;
+		}
+		if (!await reconciliation.checkpointSources({
+			claim,
+			targetEpoch: current.targetEpoch,
+			previousCursor: current.sourceCursor,
+			nextCursor: page.at(-1).sourceKey
+		})) return "claim_lost";
+		if (enqueuedMissingContent || page.length === MEDIA_USAGE_RECONCILIATION_LIMITS.sourcePageSize) {
+			if (!await reconciliation.release({
+				...claim,
+				delaySeconds: 0
+			})) return "claim_lost";
+			return "advanced";
+		}
+	}
+	const barrier = await reconciliation.findWorkBarrier(claim.collectionId);
+	if (barrier.state === "failed") return failReconciliation(reconciliation, claim, barrier.errorCode, true);
+	if (barrier.state === "pending") {
+		await reconciliation.release({
+			...claim,
+			delaySeconds: 30
+		});
+		return "deferred";
+	}
+	if (!await reconciliation.finalizeCoverage({
+		claim,
+		targetEpoch: current.targetEpoch,
+		fieldFingerprint,
+		schemaVersion: CONTENT_SOURCE_SCHEMA_VERSION
+	})) return "claim_lost";
+	if (!await reconciliation.deleteFinalized(claim)) return "claim_lost";
+	return "completed";
+}
+async function restartReconciliation(db, reconciliation, claim, current, fields, fieldFingerprint) {
+	if (current.targetEpoch === null) return "claim_lost";
+	const discoveredFields = fields ?? await loadContentMediaUsageFields(db, claim.collectionSlug, claim.collectionId);
+	const fingerprint = fieldFingerprint ?? await buildContentMediaUsageFieldFingerprint(discoveredFields);
+	const targetEpoch = await reconciliation.restartRun(claim, current.targetEpoch);
+	if (targetEpoch === null) {
+		await reconciliation.release({
+			...claim,
+			delaySeconds: 30
+		});
+		return "deferred";
+	}
+	const scanUpperId = discoveredFields.extractionFields.length === 0 ? null : await reconciliation.findScanUpperId(claim);
+	if (!await reconciliation.restartScan({
+		claim,
+		previousEpoch: current.targetEpoch,
+		targetEpoch,
+		fieldFingerprint: fingerprint,
+		scanUpperId
+	})) return "claim_lost";
+	if (!await reconciliation.release({
+		...claim,
+		delaySeconds: 0
+	})) return "claim_lost";
+	return "advanced";
+}
+async function failReconciliation(reconciliation, claim, errorCode, entryFailure) {
+	if (!(entryFailure ? await reconciliation.recordEntryFailure(claim) : await reconciliation.recordFailure({
+		collectionId: claim.collectionId,
+		runToken: claim.runToken,
+		leaseToken: claim.leaseToken,
+		errorCode,
+		retryDelaySeconds: 0,
+		terminal: true
+	}))) return "claim_lost";
+	await reconciliation.finishFailedCoverage(claim.collectionId, claim.runToken);
+	return "failed";
+}
+function retryDelaySeconds$1(attemptCount) {
+	const exponential = Math.min(MEDIA_USAGE_RECONCILIATION_LIMITS.retryMaxSeconds, MEDIA_USAGE_RECONCILIATION_LIMITS.retryBaseSeconds * 2 ** attemptCount);
+	const jitter = Math.floor(exponential * MEDIA_USAGE_RECONCILIATION_LIMITS.retryJitterRatio * Math.random());
+	return Math.min(MEDIA_USAGE_RECONCILIATION_LIMITS.retryMaxSeconds, exponential + jitter);
+}
+
+//#endregion
+//#region src/media/usage/work-processor.ts
+const MEDIA_USAGE_WORK_PROCESSING_LIMITS = Object.freeze({
+	candidatesPerTick: 1e3,
+	leaseDurationSeconds: 1200,
+	maxAttempts: 5,
+	retryBaseSeconds: 30,
+	retryMaxSeconds: 900,
+	retryJitterRatio: .25
+});
+async function processMediaUsageWorkAfterWrite(db, collectionSlug, contentId) {
+	if (!await isIncrementalCaptureActive(db)) return {
+		outcome: "inactive",
+		claimed: false
+	};
+	await new MediaUsageRepository(db).recoverIncrementalFinalizations();
+	const repo = new MediaUsageWorkRepository(db);
+	const work = await repo.findWorkForContent(collectionSlug, contentId);
+	if (!work) return {
+		outcome: "not_due",
+		claimed: false
+	};
+	const claimed = await repo.claimWork({
+		collectionId: work.collectionId,
+		contentId: work.contentId,
+		workVersion: work.workVersion,
+		leaseDurationSeconds: MEDIA_USAGE_WORK_PROCESSING_LIMITS.leaseDurationSeconds
+	});
+	if (!claimed) return {
+		outcome: "claim_lost",
+		claimed: false
+	};
+	try {
+		return (await runClaimedBatch(db, [claimed])).get(workResultKey(claimed)) ?? {
+			outcome: "claim_lost",
+			claimed: false
+		};
+	} catch (error) {
+		const outcome = (await repo.retryClaimedWorkBatch({
+			work: [workLease(claimed)],
+			errorCode: "MEDIA_USAGE_PROCESSING_FAILED",
+			retryDelaySeconds: MEDIA_USAGE_WORK_PROCESSING_LIMITS.retryBaseSeconds,
+			maxAttempts: MEDIA_USAGE_WORK_PROCESSING_LIMITS.maxAttempts
+		})).get(workIdentityKey(claimed)) ?? "superseded";
+		if (outcome === "failed") await new MediaUsageRepository(db).recordIncrementalFailure({
+			collectionId: claimed.collectionId,
+			collectionSlug: claimed.collectionSlug,
+			contentId: claimed.contentId,
+			workVersion: claimed.workVersion,
+			errorCode: "MEDIA_USAGE_PROCESSING_FAILED"
+		});
+		console.error("[media-usage:work] Immediate processing failed:", error);
+		return {
+			outcome,
+			claimed: true
+		};
+	}
+}
+async function processDueMediaUsageWork(db, options = {}) {
+	const startedAt = Date.now();
+	const result = {
+		candidateCount: 0,
+		claimedCount: 0,
+		completedCount: 0,
+		retryCount: 0,
+		failedCount: 0,
+		supersededCount: 0,
+		obsoleteCount: 0,
+		durationMs: 0
+	};
+	if (!options.activationKnownActive && !await isIncrementalCaptureActive(db)) {
+		result.durationMs = Date.now() - startedAt;
+		return result;
+	}
+	await new MediaUsageRepository(db).recoverIncrementalFinalizations();
+	const repo = new MediaUsageWorkRepository(db);
+	const candidates = await repo.claimDueWorkBatch({
+		limit: MEDIA_USAGE_WORK_PROCESSING_LIMITS.candidatesPerTick,
+		leaseDurationSeconds: MEDIA_USAGE_WORK_PROCESSING_LIMITS.leaseDurationSeconds
+	});
+	result.candidateCount = candidates.length > 0 || !await repo.hasNonterminalWork() ? candidates.length : 1;
+	const processedBatch = await processClaimedCollections(db, candidates);
+	for (const candidate of candidates) {
+		const processed = processedBatch.get(workResultKey(candidate)) ?? {
+			outcome: "claim_lost",
+			claimed: false
+		};
+		if (processed.claimed) result.claimedCount++;
+		if (processed.outcome === "completed") result.completedCount++;
+		if (processed.outcome === "retry") result.retryCount++;
+		if (processed.outcome === "failed") result.failedCount++;
+		if (processed.outcome === "superseded") result.supersededCount++;
+		if (processed.outcome === "obsolete") result.obsoleteCount++;
+	}
+	result.durationMs = Date.now() - startedAt;
+	return result;
+}
+async function processClaimedCollections(db, candidates) {
+	const processed = /* @__PURE__ */ new Map();
+	const byCollection = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) {
+		const key = collectionResultKey(candidate);
+		const collection = byCollection.get(key) ?? [];
+		collection.push(candidate);
+		byCollection.set(key, collection);
+	}
+	for (const collection of byCollection.values()) try {
+		for (const [key, result] of await runClaimedBatch(db, collection)) processed.set(key, result);
+	} catch (error) {
+		for (const [key, result] of await retryFailedClaimedCollection(db, collection)) processed.set(key, result);
+		console.error("[media-usage:work] Collection processing failed:", error);
+	}
+	return processed;
+}
+async function retryFailedClaimedCollection(db, candidates) {
+	const transitioned = await new MediaUsageWorkRepository(db).retryClaimedWorkBatch({
+		work: candidates.map(workLease),
+		errorCode: "MEDIA_USAGE_PROCESSING_FAILED",
+		retryDelaySeconds: MEDIA_USAGE_WORK_PROCESSING_LIMITS.retryBaseSeconds,
+		maxAttempts: MEDIA_USAGE_WORK_PROCESSING_LIMITS.maxAttempts
+	});
+	const processed = /* @__PURE__ */ new Map();
+	const failedCollectionIds = /* @__PURE__ */ new Set();
+	for (const candidate of candidates) {
+		const state = transitioned.get(workIdentityKey(candidate));
+		if (state === "failed") failedCollectionIds.add(candidate.collectionId);
+		processed.set(workResultKey(candidate), {
+			outcome: state ?? "superseded",
+			claimed: true
+		});
+	}
+	await new MediaUsageRepository(db).recordIncrementalFailuresByCollection({
+		collectionIds: [...failedCollectionIds],
+		errorCode: "MEDIA_USAGE_PROCESSING_FAILED"
+	});
+	return processed;
+}
+async function runClaimedBatch(db, candidates) {
+	return isPostgres(db) ? withTransaction(db, (trx) => processClaimedBatch(trx, new MediaUsageWorkRepository(trx), candidates)) : processClaimedBatch(db, new MediaUsageWorkRepository(db), candidates);
+}
+async function processClaimedBatch(db, repo, candidates) {
+	const results = /* @__PURE__ */ new Map();
+	const locked = await repo.lockClaimedWorkBatch(candidates.map(workLease));
+	const owned = [];
+	for (const candidate of candidates) if (locked.has(workIdentityKey(candidate))) owned.push(candidate);
+	else results.set(workResultKey(candidate), {
+		outcome: "superseded",
+		claimed: true
+	});
+	const currentCollections = await findCurrentCollectionIdentities(db, owned);
+	const current = [];
+	const obsolete = [];
+	for (const candidate of owned) if (currentCollections.has(collectionResultKey(candidate))) current.push(candidate);
+	else obsolete.push(candidate);
+	const obsoleteCompleted = await repo.completeWorkBatch(obsolete.map(workLease));
+	for (const candidate of obsolete) results.set(workResultKey(candidate), {
+		outcome: obsoleteCompleted.has(workIdentityKey(candidate)) ? "obsolete" : "superseded",
+		claimed: true
+	});
+	if (current.length === 0) return results;
+	const refreshes = await refreshContentMediaUsageForWorkBatch(db, current, { shouldContinue: canContinueBulkWork });
+	const successful = [];
+	const unstarted = [];
+	const failedRefreshes = [];
+	for (const candidate of current) {
+		const refresh = refreshes.get(contentRefreshKey(candidate.collectionId, candidate.contentId));
+		if (refresh?.success) successful.push(candidate);
+		else if (!refresh) unstarted.push(candidate);
+		else failedRefreshes.push({
+			candidate,
+			refresh
+		});
+	}
+	const terminalFailureCollections = /* @__PURE__ */ new Map();
+	const failureGroups = /* @__PURE__ */ new Map();
+	for (const failure of failedRefreshes) {
+		const errorCode = processingErrorCode(failure.refresh.errorCode);
+		const terminal = errorCode === "MEDIA_USAGE_RESOURCE_LIMIT" || failure.candidate.attemptCount + 1 >= MEDIA_USAGE_WORK_PROCESSING_LIMITS.maxAttempts;
+		const delay = retryDelaySeconds(failure.candidate.attemptCount);
+		const key = `${errorCode}\u0000${terminal ? "terminal" : String(delay)}`;
+		const group = failureGroups.get(key) ?? {
+			errorCode,
+			retryDelaySeconds: delay,
+			terminal,
+			candidates: []
+		};
+		group.candidates.push(failure.candidate);
+		failureGroups.set(key, group);
+	}
+	for (const group of failureGroups.values()) {
+		const transitioned = await repo.retryClaimedWorkBatch({
+			work: group.candidates.map(workLease),
+			errorCode: group.errorCode,
+			retryDelaySeconds: group.retryDelaySeconds,
+			maxAttempts: group.terminal ? 1 : MEDIA_USAGE_WORK_PROCESSING_LIMITS.maxAttempts
+		});
+		for (const candidate of group.candidates) {
+			const state = transitioned.get(workIdentityKey(candidate));
+			if (state === "failed") {
+				const collections = terminalFailureCollections.get(group.errorCode) ?? /* @__PURE__ */ new Set();
+				collections.add(candidate.collectionId);
+				terminalFailureCollections.set(group.errorCode, collections);
+			}
+			results.set(workResultKey(candidate), {
+				outcome: state ?? "superseded",
+				claimed: true
+			});
+		}
+	}
+	for (const [errorCode, collectionIds] of terminalFailureCollections) await new MediaUsageRepository(db).recordIncrementalFailuresByCollection({
+		collectionIds: [...collectionIds],
+		errorCode
+	});
+	const released = await repo.releaseClaimedWorkBatch(unstarted.map(workLease));
+	for (const candidate of unstarted) results.set(workResultKey(candidate), {
+		outcome: released.has(workIdentityKey(candidate)) ? "not_due" : "superseded",
+		claimed: true
+	});
+	const usage = new MediaUsageRepository(db);
+	const successfulByCollection = /* @__PURE__ */ new Map();
+	for (const candidate of successful) {
+		const key = collectionResultKey(candidate);
+		const collection = successfulByCollection.get(key) ?? [];
+		collection.push(candidate);
+		successfulByCollection.set(key, collection);
+	}
+	const readyToComplete = [];
+	const deferredCompletion = [];
+	const lostFinalization = [];
+	let pendingFinalizationQueries = 2;
+	for (const collection of successfulByCollection.values()) {
+		const first = collection[0];
+		if (!first) continue;
+		const metrics = getRequestContext()?.metrics;
+		if (metrics && metrics.dbCount + pendingFinalizationQueries + 4 > 900) {
+			deferredCompletion.push(...collection);
+			continue;
+		}
+		if ((await usage.prepareIncrementalFinalization({
+			collectionId: first.collectionId,
+			collectionSlug: first.collectionSlug
+		})).outcome !== "lost") {
+			readyToComplete.push(...collection);
+			pendingFinalizationQueries += 2;
+			continue;
+		}
+		lostFinalization.push(...collection);
+		pendingFinalizationQueries += 2;
+	}
+	const lostTransitions = await repo.retryClaimedWorkBatch({
+		work: lostFinalization.map(workLease),
+		errorCode: "MEDIA_USAGE_GENERATION_CONFLICT",
+		retryDelaySeconds: MEDIA_USAGE_WORK_PROCESSING_LIMITS.retryBaseSeconds,
+		maxAttempts: MEDIA_USAGE_WORK_PROCESSING_LIMITS.maxAttempts
+	});
+	const lostFailedCollections = /* @__PURE__ */ new Set();
+	for (const candidate of lostFinalization) {
+		const state = lostTransitions.get(workIdentityKey(candidate));
+		if (state === "failed") lostFailedCollections.add(candidate.collectionId);
+		results.set(workResultKey(candidate), {
+			outcome: state ?? "superseded",
+			claimed: true
+		});
+	}
+	await usage.recordIncrementalFailuresByCollection({
+		collectionIds: [...lostFailedCollections],
+		errorCode: "MEDIA_USAGE_GENERATION_CONFLICT"
+	});
+	const deferred = await repo.releaseClaimedWorkBatch(deferredCompletion.map(workLease));
+	for (const candidate of deferredCompletion) results.set(workResultKey(candidate), {
+		outcome: deferred.has(workIdentityKey(candidate)) ? "not_due" : "superseded",
+		claimed: true
+	});
+	const completed = await repo.completeWorkBatch(readyToComplete.map(workLease));
+	const completedCollections = /* @__PURE__ */ new Map();
+	for (const candidate of readyToComplete) {
+		const didComplete = completed.has(workIdentityKey(candidate));
+		results.set(workResultKey(candidate), {
+			outcome: didComplete ? "completed" : "superseded",
+			claimed: true
+		});
+		if (didComplete) completedCollections.set(collectionResultKey(candidate), candidate);
+	}
+	for (const collection of completedCollections.values()) await usage.recordIncrementalSuccess({
+		collectionId: collection.collectionId,
+		collectionSlug: collection.collectionSlug
+	});
+	return results;
+}
+async function findCurrentCollectionIdentities(db, candidates) {
+	const identities = new Map(candidates.map((candidate) => [collectionResultKey(candidate), candidate]));
+	const current = /* @__PURE__ */ new Set();
+	for (const batch of chunkCollectionIds(Array.from(identities.values(), (item) => item.collectionId))) {
+		const rows = await db.selectFrom("_emdash_collections").select(["id", "slug"]).where("id", "in", batch).execute();
+		for (const row of rows) current.add(`${row.id}\u0000${row.slug}`);
+	}
+	return current;
+}
+function workLease(work) {
+	if (!work.leaseToken) throw new Error("Claimed media usage work requires a lease token");
+	return {
+		collectionId: work.collectionId,
+		contentId: work.contentId,
+		workVersion: work.workVersion,
+		leaseToken: work.leaseToken
+	};
+}
+function workIdentityKey(work) {
+	return `${work.collectionId}\u0000${work.contentId}\u0000${String(work.workVersion)}`;
+}
+function workResultKey(work) {
+	return workIdentityKey(work);
+}
+function collectionResultKey(work) {
+	return `${work.collectionId}\u0000${work.collectionSlug}`;
+}
+function chunkCollectionIds(ids) {
+	const unique = [...new Set(ids)];
+	const batches = [];
+	for (let index = 0; index < unique.length; index += 50) batches.push(unique.slice(index, index + 50));
+	return batches;
+}
+function canContinueBulkWork() {
+	const metrics = getRequestContext()?.metrics;
+	return !metrics || metrics.dbCount + 150 <= 900;
+}
+async function isIncrementalCaptureActive(db) {
+	return (await db.selectFrom("_emdash_media_usage_activation").select("state").where("task_key", "=", "incremental_capture").executeTakeFirst())?.state === "active";
+}
+function retryDelaySeconds(attemptCount) {
+	const exponential = Math.min(MEDIA_USAGE_WORK_PROCESSING_LIMITS.retryMaxSeconds, MEDIA_USAGE_WORK_PROCESSING_LIMITS.retryBaseSeconds * 2 ** attemptCount);
+	const jitter = Math.floor(exponential * MEDIA_USAGE_WORK_PROCESSING_LIMITS.retryJitterRatio * Math.random());
+	return Math.min(MEDIA_USAGE_WORK_PROCESSING_LIMITS.retryMaxSeconds, exponential + jitter);
+}
+function processingErrorCode(errorCode) {
+	if (errorCode === "DRAFT_REVISION_NOT_FOUND" || errorCode === "DRAFT_REVISION_MISMATCH" || errorCode === "DRAFT_REVISION_INVALID") return "MEDIA_USAGE_SNAPSHOT_FAILED";
+	if (errorCode === "CONTENT_USAGE_GENERATION_CONFLICT") return "MEDIA_USAGE_GENERATION_CONFLICT";
+	if (errorCode === "CONTENT_USAGE_RESOURCE_LIMIT") return "MEDIA_USAGE_RESOURCE_LIMIT";
+	return "MEDIA_USAGE_PROCESSING_FAILED";
+}
+
+//#endregion
+//#region src/media/usage/maintenance-engine.ts
+const MEDIA_USAGE_MAINTENANCE_LIMITS = Object.freeze({
+	eventQueryCeiling: 900,
+	maxStepQueries: 150
+});
+const TASK_CLASSES = [
+	"collection_deletion",
+	"entry_work",
+	"reconciliation"
+];
+async function runMediaUsageMaintenanceStep(db) {
+	const activation = await db.selectFrom("_emdash_media_usage_activation").select(["state", "runtime_generation"]).where("task_key", "=", "incremental_capture").executeTakeFirst();
+	if (activation?.state !== "active" || activation.runtime_generation !== MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION) return runActivationStep(db);
+	let blocked = false;
+	let blockedReconciliation = false;
+	let madeProgress = false;
+	for (const taskClass of TASK_CLASSES) {
+		const metrics = getRequestContext()?.metrics;
+		if (metrics && !canStartMediaUsageMaintenanceStep(metrics)) return madeProgress ? {
+			state: "progress",
+			continuation: { kind: "immediate" }
+		} : {
+			state: "blocked",
+			continuation: { kind: "immediate" }
+		};
+		const outcome = await runTaskClass(db, taskClass);
+		if (outcome === "inactive") return inactiveResult();
+		if (outcome === "progress") madeProgress = true;
+		if (outcome === "blocked") {
+			blocked = true;
+			if (taskClass === "reconciliation") blockedReconciliation = true;
+		}
+	}
+	if (madeProgress) return {
+		state: "progress",
+		continuation: { kind: "immediate" }
+	};
+	if (blockedReconciliation && await new MediaUsageReconciliationRepository(db).wakeDrainedBarrierCandidate()) return {
+		state: "progress",
+		continuation: { kind: "immediate" }
+	};
+	if (blocked) return {
+		state: "blocked",
+		continuation: {
+			kind: "delayed",
+			delaySeconds: 30
+		}
+	};
+	return {
+		state: "idle",
+		continuation: { kind: "none" }
+	};
+}
+async function runActivationStep(db) {
+	try {
+		const result = await continueMediaUsageActivation(db);
+		if (result.outcome === "activating" || result.outcome === "active") return {
+			state: "progress",
+			continuation: { kind: "immediate" }
+		};
+		if (result.outcome === "lease_active" || result.outcome === "conflict") return {
+			state: "blocked",
+			continuation: {
+				kind: "delayed",
+				delaySeconds: 30
+			}
+		};
+		return inactiveResult();
+	} catch (error) {
+		if (error instanceof MediaUsageActivationVersionMismatchError) return inactiveResult();
+		throw error;
+	}
+}
+async function runTaskClass(db, taskClass) {
+	if (taskClass === "entry_work") {
+		const result = await processDueMediaUsageWork(db, { activationKnownActive: true });
+		if (result.claimedCount > 0) return "progress";
+		return result.candidateCount > 0 ? "blocked" : "idle";
+	}
+	if (taskClass === "collection_deletion") {
+		const result = await processDueMediaUsageCollectionDeletions(db);
+		if (result.claimedCount > 0) return "progress";
+		return result.candidateCount > 0 ? "blocked" : "idle";
+	}
+	const result = await processDueMediaUsageReconciliationDetailed(db, { activationKnownActive: true });
+	if (result.outcome === "inactive") return "inactive";
+	if (result.consumedUnit) return "progress";
+	return result.outcome === "claim_lost" || result.hasDeferredCandidate ? "blocked" : "idle";
+}
+function inactiveResult() {
+	return {
+		state: "inactive",
+		continuation: { kind: "none" }
+	};
+}
+function canStartMediaUsageMaintenanceStep(metrics) {
+	return metrics.dbCount + MEDIA_USAGE_MAINTENANCE_LIMITS.maxStepQueries <= MEDIA_USAGE_MAINTENANCE_LIMITS.eventQueryCeiling;
+}
+
+//#endregion
+//#region src/api/handlers/media-usage.ts
+var media_usage_exports = /* @__PURE__ */ __exportAll({
+	aggregateMediaUsageCoverageStatus: () => aggregateMediaUsageCoverageStatus,
+	handleMediaUsageDetails: () => handleMediaUsageDetails,
+	handleMediaUsageProgress: () => handleMediaUsageProgress,
+	handleMediaUsageProgressAdvance: () => handleMediaUsageProgressAdvance,
+	handleMediaUsageRepair: () => handleMediaUsageRepair,
+	handleMediaUsageSummaries: () => handleMediaUsageSummaries,
+	toMediaUsageRepairResponse: () => toMediaUsageRepairResponse
+});
+async function handleMediaUsageProgress(db) {
+	try {
+		const progress = await new MediaUsageRepository(db).findCollectionProgress();
+		if (!progress) return {
+			success: false,
+			error: {
+				code: ErrorCode.MEDIA_USAGE_PROGRESS_NOT_ACTIVE,
+				message: "Media Usage is not active"
+			}
+		};
+		return {
+			success: true,
+			data: progress
+		};
+	} catch (error) {
+		if (error instanceof MediaUsageActivationVersionMismatchError) return {
+			success: false,
+			error: {
+				code: ErrorCode.MEDIA_USAGE_ACTIVATION_VERSION_MISMATCH,
+				message: "Media Usage activation version does not match this runtime"
+			}
+		};
+		console.error("[media-usage] progress read failed:", error);
+		return {
+			success: false,
+			error: {
+				code: ErrorCode.MEDIA_USAGE_PROGRESS_READ_ERROR,
+				message: "Failed to read media usage progress"
+			}
+		};
+	}
+}
+async function handleMediaUsageProgressAdvance(db) {
+	try {
+		const step = await runMediaUsageMaintenanceStep(db);
+		const activation = await getMediaUsageActivationStatus(db);
+		if (activation.state === "expanded") return {
+			success: false,
+			error: {
+				code: ErrorCode.MEDIA_USAGE_PROGRESS_NOT_ACTIVE,
+				message: "Media Usage activation has not started"
+			}
+		};
+		const progress = activation.state === "active" ? await new MediaUsageRepository(db).findCollectionProgress() : null;
+		return {
+			success: true,
+			data: {
+				activation,
+				progress,
+				nextRequestInMs: continuationDelayMs(step.continuation, progress)
+			}
+		};
+	} catch (error) {
+		if (error instanceof MediaUsageActivationVersionMismatchError) return {
+			success: false,
+			error: {
+				code: ErrorCode.MEDIA_USAGE_ACTIVATION_VERSION_MISMATCH,
+				message: "Media Usage activation version does not match this runtime"
+			}
+		};
+		console.error("[media-usage] progress advance failed:", error);
+		return {
+			success: false,
+			error: {
+				code: ErrorCode.MEDIA_USAGE_PROGRESS_ADVANCE_ERROR,
+				message: "Failed to advance media usage progress"
+			}
+		};
+	}
+}
+function continuationDelayMs(continuation, progress) {
+	if (progress?.status === "needs_attention") return null;
+	if (continuation.kind === "immediate") return 0;
+	if (continuation.kind === "delayed") return 3e4;
+	if (progress?.status === "indexing") return 0;
+	return null;
+}
+function aggregateMediaUsageCoverageStatus(scopes) {
+	const statuses = scopes.map(normalizeMediaUsageCoverageStatus);
+	if (statuses.every((status) => status === "complete")) return "complete";
+	if (statuses.includes("unknown")) return "unknown";
+	if (statuses.includes("running")) return "running";
+	if (statuses.includes("stale")) return "stale";
+	if (statuses.includes("partial")) return "partial";
+	if (statuses.every((status) => status === "never")) return "never";
+	if (statuses.every((status) => status === "failed")) return "failed";
+	return "partial";
+}
+async function handleMediaUsageSummaries(db, mediaIds, options) {
+	if (mediaIds.length === 0) return {
+		success: true,
+		data: {}
+	};
+	try {
+		const repository = new MediaUsageRepository(db);
+		const { coverage, siteSettings } = await loadMediaUsageCoverage(repository);
+		const counts = options.includeCount && coverage.status === "complete" ? await repository.findActiveEntryCountsByMediaIds(mediaIds) : null;
+		const summaries = {};
+		for (const mediaId of new Set(mediaIds)) summaries[mediaId] = {
+			count: counts ? (counts.get(mediaId) ?? 0) + (siteSettings.get(mediaId)?.length ?? 0) : null,
+			coverage
+		};
+		return {
+			success: true,
+			data: summaries
+		};
+	} catch (error) {
+		console.error("[media-usage] summary read failed:", error);
+		return {
+			success: false,
+			error: {
+				code: ErrorCode.MEDIA_USAGE_READ_ERROR,
+				message: "Failed to read media usage"
+			}
+		};
+	}
+}
+async function handleMediaUsageDetails(db, mediaId, options) {
+	try {
+		if (!await new MediaRepository(db).findById(mediaId)) return {
+			success: false,
+			error: {
+				code: ErrorCode.NOT_FOUND,
+				message: `Media item not found: ${mediaId}`
+			}
+		};
+		const repository = new MediaUsageRepository(db);
+		const { coverage, siteSettings } = await loadMediaUsageCoverage(repository);
+		const page = await repository.findCurrentEntryUsagePageByMediaId(mediaId, options);
+		return {
+			success: true,
+			data: {
+				items: page.items.map(toMediaUsageEntryDetail),
+				...page.nextCursor ? { nextCursor: page.nextCursor } : {},
+				siteSettings: (siteSettings.get(mediaId) ?? []).map((setting) => ({ setting })),
+				coverage
+			}
+		};
+	} catch (error) {
+		if (error instanceof InvalidCursorError) return {
+			success: false,
+			error: {
+				code: ErrorCode.INVALID_CURSOR,
+				message: error.message
+			}
+		};
+		console.error("[media-usage] detail read failed:", error);
+		return {
+			success: false,
+			error: {
+				code: ErrorCode.MEDIA_USAGE_READ_ERROR,
+				message: "Failed to read media usage"
+			}
+		};
+	}
+}
+async function handleMediaUsageRepair(db, input) {
+	try {
+		let result;
+		if (input.scope === "collection") result = await repairContentMediaUsageCollection(db, { collectionSlug: input.collection });
+		else if (input.scope === "all") result = await repairContentMediaUsageAll(db);
+		else return {
+			success: false,
+			error: {
+				code: ErrorCode.VALIDATION_ERROR,
+				message: "Invalid media usage repair request"
+			}
+		};
+		return {
+			success: true,
+			data: toMediaUsageRepairResponse(result)
+		};
+	} catch (error) {
+		console.error("[media-usage] repair failed:", error);
+		return {
+			success: false,
+			error: {
+				code: ErrorCode.MEDIA_USAGE_REPAIR_ERROR,
+				message: "Failed to repair media usage"
+			}
+		};
+	}
+}
+function toMediaUsageRepairResponse(result) {
+	const collections = "collections" in result ? result.collections : [result];
+	return {
+		status: result.status,
+		indexedSourceCount: result.indexedSourceCount,
+		failedSourceCount: result.failedSourceCount,
+		skippedSourceCount: result.skippedSourceCount,
+		deletedSourceCount: result.deletedSourceCount,
+		collections: collections.map(toMediaUsageRepairCollectionSummary)
+	};
+}
+function toMediaUsageRepairCollectionSummary(result) {
+	return {
+		collection: result.scope.scopeKey,
+		status: result.status,
+		indexedSourceCount: result.indexedSourceCount,
+		failedSourceCount: result.failedSourceCount,
+		skippedSourceCount: result.skippedSourceCount,
+		deletedSourceCount: result.deletedSourceCount,
+		lastErrorCode: result.lastErrorCode,
+		startedAt: result.startedAt,
+		completedAt: result.completedAt
+	};
+}
+function normalizeMediaUsageCoverageStatus(scope) {
+	if (scope.status === null) return "never";
+	if (scope.status === "complete") {
+		if (scope.reconciliationRequired) return "stale";
+		return scope.schemaVersion === CONTENT_SOURCE_SCHEMA_VERSION ? "complete" : "stale";
+	}
+	if (scope.status === "never" || scope.status === "running" || scope.status === "partial" || scope.status === "failed" || scope.status === "stale") return scope.status;
+	return "unknown";
+}
+async function loadMediaUsageCoverage(repository) {
+	const { scopes, options } = await repository.findCoverageWithOptions({
+		adapterId: CONTENT_MEDIA_USAGE_ADAPTER_ID,
+		scopeType: CONTENT_MEDIA_USAGE_COLLECTION_SCOPE
+	}, MEDIA_USAGE_SITE_SETTING_OPTIONS);
+	return {
+		coverage: {
+			scope: "all_content_collections",
+			status: aggregateMediaUsageCoverageStatus(scopes)
+		},
+		siteSettings: groupSiteSettingMediaUsage(options)
+	};
+}
+function toMediaUsageEntryDetail(group) {
+	const preferred = group.sources.find(({ source }) => source.sourceVariant === "draft_overlay") ?? group.sources.find(({ source }) => source.sourceVariant === "columns");
+	if (!preferred) throw new Error("Media usage entry has no supported source");
+	return {
+		collection: group.collectionSlug,
+		contentId: group.contentId,
+		title: preferred.source.contentTitle,
+		slug: preferred.source.contentSlug,
+		locale: preferred.source.locale,
+		status: preferred.source.contentStatus,
+		scheduledAt: preferred.source.contentScheduledAt,
+		deletedAt: group.contentDeletedAt,
+		sources: group.sources.flatMap(({ source, occurrences }) => {
+			if (source.sourceVariant !== "columns" && source.sourceVariant !== "draft_overlay") return [];
+			return [{
+				variant: source.sourceVariant,
+				occurrences: occurrences.map((occurrence) => ({
+					fieldSlug: occurrence.fieldSlug,
+					fieldPath: occurrence.fieldPath,
+					occurrenceIndex: occurrence.occurrenceIndex,
+					referenceType: normalizeMediaUsageReferenceType(occurrence.referenceType)
+				}))
+			}];
+		})
+	};
+}
+function normalizeMediaUsageReferenceType(referenceType) {
+	if (referenceType === "image_field" || referenceType === "file_field" || referenceType === "portable_text_image") return referenceType;
+	return "unknown";
+}
+
+//#endregion
+export { handleMediaUsageSummaries as a, handleMediaUsageRepair as i, handleMediaUsageProgress as n, media_usage_exports as o, handleMediaUsageProgressAdvance as r, processMediaUsageWorkAfterWrite as s, handleMediaUsageDetails as t };
+//# sourceMappingURL=media-usage-De-zeR9E.mjs.map