emdash 0.37.0 → 0.39.0

package/dist/media-usage-work-Cu5DqewW.mjs

@@ -0,0 +1,586 @@
+import { l as isPostgres } from "./dialect-helpers-CtYdsX4W.mjs";
+import { o as decodeCursor, s as encodeCursor } from "./types-BkUg2yHx.mjs";
+import { sql } from "kysely";
+import { ulid } from "ulidx";
+
+//#region src/database/repositories/media-usage-work.ts
+const MAX_PORTABLE_DURATION_SECONDS = 365 * 24 * 60 * 60;
+const MAX_WORK_SELECTION_LIMIT = 1e3;
+const NON_NEGATIVE_DECIMAL_PATTERN = /^(?:0|[1-9][0-9]*)$/;
+const POSITIVE_DECIMAL_PATTERN = /^[1-9][0-9]*$/;
+const STABLE_ERROR_CODE_PATTERN = /^[A-Z][A-Z0-9_]{0,63}$/;
+const MEDIA_USAGE_WORK_OPERATOR_DEFAULT_LIMIT = 50;
+const MEDIA_USAGE_WORK_OPERATOR_MAX_LIMIT = 100;
+const MEDIA_USAGE_RECONCILIATION_PAGE_LIMIT = 1e3;
+const MEDIA_USAGE_WORK_STATES = [
+	"pending",
+	"retry",
+	"leased",
+	"failed"
+];
+var MediaUsageWorkRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async enqueueReconciliationPage(input) {
+		if (!input.collectionId || !input.collectionSlug || !input.runToken || !input.leaseToken) throw new Error("Reconciliation enqueue requires exact collection and lease identity");
+		assertNonNegativeDecimal(input.changeEpoch, "change epoch");
+		const contentIds = [...new Set(input.contentIds)];
+		if (contentIds.length < 1 || contentIds.length > MEDIA_USAGE_RECONCILIATION_PAGE_LIMIT) throw new Error("Reconciliation enqueue requires from 1 to 1000 content IDs");
+		if (contentIds.some((contentId) => !contentId)) throw new Error("Reconciliation enqueue content IDs must not be empty");
+		const now = this.timestampOffset(0);
+		const contentIdsJson = JSON.stringify(contentIds);
+		await sql`
+			WITH page(content_id) AS (${isPostgres(this.db) ? sql`SELECT value::text AS content_id FROM jsonb_array_elements_text(${contentIdsJson}::jsonb) AS value` : sql`SELECT value AS content_id FROM json_each(${contentIdsJson})`})
+			INSERT INTO _emdash_media_usage_work (
+				collection_id, collection_slug, content_id, change_epoch, work_version,
+				state, attempt_count, next_attempt_at, lease_token, lease_expires_at,
+				last_attempted_at, last_error_code, created_at, updated_at
+			)
+			SELECT
+				${input.collectionId}, ${input.collectionSlug}, page.content_id, ${input.changeEpoch}, 1,
+				'pending', 0, ${now}, NULL, NULL, NULL, NULL, ${now}, ${now}
+			FROM page
+			WHERE EXISTS (
+				SELECT 1
+				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
+				INNER JOIN _emdash_collections AS collection
+					ON collection.id = reconciliation.collection_id
+					AND collection.slug = reconciliation.collection_slug
+				WHERE reconciliation.collection_id = ${input.collectionId}
+					AND reconciliation.collection_slug = ${input.collectionSlug}
+					AND reconciliation.run_token = ${input.runToken}
+					AND reconciliation.target_epoch = ${input.changeEpoch}
+					AND reconciliation.state = 'leased'
+					AND reconciliation.phase = ${input.phase}
+					AND reconciliation.lease_token = ${input.leaseToken}
+					AND ${this.qualifiedLeaseIsLive("reconciliation.lease_expires_at")}
+					AND status.adapter_id = 'content-media'
+					AND status.scope_type = 'collection'
+					AND status.capture_state = 'active'
+					AND status.reconciliation_required = 1
+					AND status.status = 'running'
+					AND status.cursor = ${input.runToken}
+					AND status.change_epoch = ${input.changeEpoch}
+					AND EXISTS (
+						SELECT 1 FROM _emdash_media_usage_activation AS activation
+						WHERE activation.task_key = 'incremental_capture'
+							AND activation.state = 'active'
+					)
+					AND NOT EXISTS (
+						SELECT 1 FROM _emdash_media_usage_collection_deletions AS deletion
+						WHERE deletion.collection_id = reconciliation.collection_id
+					)
+			)
+			ON CONFLICT (collection_id, content_id) DO UPDATE SET
+				collection_slug = excluded.collection_slug,
+				change_epoch = excluded.change_epoch,
+				work_version = _emdash_media_usage_work.work_version + 1,
+				state = 'pending',
+				attempt_count = 0,
+				next_attempt_at = excluded.next_attempt_at,
+				lease_token = NULL,
+				lease_expires_at = NULL,
+				last_attempted_at = NULL,
+				last_error_code = NULL,
+				updated_at = excluded.updated_at
+			WHERE _emdash_media_usage_work.change_epoch < excluded.change_epoch
+		`.execute(this.db);
+	}
+	async findOperatorPage(options) {
+		if (!options.collectionSlug) throw new Error("Media usage work listing requires a collection slug");
+		if (options.state !== void 0 && !isMediaUsageWorkState(options.state)) throw new Error("Media usage work listing requires a valid state");
+		const limit = operatorLimit(options.limit);
+		const cursor = options.cursor ? decodeCursor(options.cursor) : null;
+		const collection = await this.db.selectFrom("_emdash_collections").select(["id", "slug"]).where("slug", "=", options.collectionSlug).executeTakeFirst();
+		if (!collection) return null;
+		const states = options.state ? [options.state] : MEDIA_USAGE_WORK_STATES;
+		const candidates = [];
+		for (const state of states) {
+			const rows = await this.findOperatorRows({
+				collectionId: collection.id,
+				collectionSlug: collection.slug,
+				state,
+				limit: limit + 1,
+				cursor
+			});
+			candidates.push(...rows.map(rowToOperatorWork));
+		}
+		const ordered = candidates.toSorted(compareOperatorWork);
+		const items = ordered.slice(0, limit);
+		const result = { items };
+		if (ordered.length > limit && items.length > 0) {
+			const last = items.at(-1);
+			result.nextCursor = encodeCursor(last.updatedAt, last.contentId);
+		}
+		return result;
+	}
+	async findOperatorRows(input) {
+		let query = this.db.selectFrom("_emdash_media_usage_work as work").innerJoin("_emdash_collections as current_collection", (join) => join.onRef("current_collection.id", "=", "work.collection_id").onRef("current_collection.slug", "=", "work.collection_slug")).selectAll("work").where("work.collection_id", "=", input.collectionId).where("work.collection_slug", "=", input.collectionSlug).where("work.state", "=", input.state);
+		if (input.cursor) query = query.where((eb) => eb.or([eb("work.updated_at", "<", input.cursor.orderValue), eb.and([eb("work.updated_at", "=", input.cursor.orderValue), eb("work.content_id", "<", input.cursor.id)])]));
+		return query.orderBy("work.updated_at", "desc").orderBy("work.content_id", "desc").limit(input.limit).execute();
+	}
+	async retryOperatorWork(input) {
+		if (!input.collectionId || !input.contentId) throw new Error("Media usage operator retry requires collection and content IDs");
+		const collection = await this.findActiveOperatorCollection(input.collectionId);
+		if (!collection) return { outcome: "collection_not_found" };
+		const observed = await this.findWorkByIdentity(input.collectionId, input.contentId);
+		if (observed?.state === "pending" && observed.collection_slug === collection.slug) return {
+			outcome: "pending",
+			changed: false,
+			work: rowToOperatorWork(observed)
+		};
+		const invalidated = await this.invalidateCoverageForOperatorRetry({
+			...input,
+			collectionSlug: collection.slug,
+			observed
+		});
+		if (!invalidated) return this.operatorRetryLost(input);
+		const reopened = observed ? await this.reopenObservedWork(observed, collection.slug, invalidated.change_epoch) : await this.createOperatorWork({
+			...input,
+			collectionSlug: collection.slug,
+			changeEpoch: invalidated.change_epoch
+		});
+		if (reopened) return {
+			outcome: "pending",
+			changed: true,
+			work: rowToOperatorWork(reopened)
+		};
+		return this.operatorRetryLost(input);
+	}
+	async findActiveOperatorCollection(collectionId) {
+		return await this.db.selectFrom("_emdash_collections as collection").innerJoin("_emdash_media_usage_index_status as status", (join) => join.onRef("status.collection_id", "=", "collection.id").onRef("status.scope_key", "=", "collection.slug")).select(["collection.id", "collection.slug"]).where("collection.id", "=", collectionId).where("status.adapter_id", "=", "content-media").where("status.scope_type", "=", "collection").where("status.capture_state", "=", "active").executeTakeFirst() ?? null;
+	}
+	async findWorkByIdentity(collectionId, contentId) {
+		return await this.db.selectFrom("_emdash_media_usage_work").selectAll().where("collection_id", "=", collectionId).where("content_id", "=", contentId).executeTakeFirst() ?? null;
+	}
+	async invalidateCoverageForOperatorRetry(input) {
+		let query = this.db.updateTable("_emdash_media_usage_index_status as status").set({
+			change_epoch: sql`change_epoch + 1`,
+			status: sql`CASE WHEN status IN ('complete', 'partial', 'failed') THEN 'stale' ELSE status END`,
+			completed_at: sql`CASE WHEN status IN ('complete', 'partial', 'failed') THEN NULL ELSE completed_at END`,
+			last_error_code: null,
+			updated_at: this.timestampOffset(0)
+		}).where("status.adapter_id", "=", "content-media").where("status.scope_type", "=", "collection").where("status.scope_key", "=", input.collectionSlug).where("status.collection_id", "=", input.collectionId).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")));
+		const observed = input.observed;
+		if (observed) query = query.where((eb) => {
+			let work = eb.selectFrom("_emdash_media_usage_work as work").select("work.content_id").whereRef("work.collection_id", "=", "status.collection_id").where("work.content_id", "=", input.contentId).where("work.work_version", "=", observed.work_version).where("work.state", "=", observed.state);
+			if (observed.state === "leased") work = work.where("work.lease_expires_at", "is not", null).where(this.timestampIsDue("work.lease_expires_at"));
+			return eb.exists(work);
+		});
+		else query = query.where((eb) => eb.not(eb.exists(eb.selectFrom("_emdash_media_usage_work as work").select("work.content_id").whereRef("work.collection_id", "=", "status.collection_id").where("work.content_id", "=", input.contentId))));
+		return await query.returning("change_epoch").executeTakeFirst() ?? null;
+	}
+	async reopenObservedWork(observed, collectionSlug, changeEpoch) {
+		let query = this.db.updateTable("_emdash_media_usage_work").set({
+			collection_slug: collectionSlug,
+			change_epoch: changeEpoch,
+			work_version: sql`work_version + 1`,
+			state: "pending",
+			attempt_count: 0,
+			next_attempt_at: this.timestampOffset(0),
+			lease_token: null,
+			lease_expires_at: null,
+			last_attempted_at: null,
+			last_error_code: null,
+			updated_at: this.timestampOffset(0)
+		}).where("collection_id", "=", observed.collection_id).where("content_id", "=", observed.content_id).where("work_version", "=", observed.work_version).where("state", "=", observed.state).where((eb) => eb.exists(eb.selectFrom("_emdash_collections as collection").innerJoin("_emdash_media_usage_index_status as status", (join) => join.onRef("status.collection_id", "=", "collection.id").onRef("status.scope_key", "=", "collection.slug")).select("collection.id").where("collection.id", "=", observed.collection_id).where("collection.slug", "=", collectionSlug).where("status.adapter_id", "=", "content-media").where("status.scope_type", "=", "collection").where("status.capture_state", "=", "active").where("status.change_epoch", "=", changeEpoch)));
+		if (observed.state === "leased") query = query.where("lease_expires_at", "is not", null).where(this.timestampIsDue("lease_expires_at"));
+		return await query.returningAll().executeTakeFirst() ?? null;
+	}
+	async createOperatorWork(input) {
+		const now = this.timestampOffset(0);
+		return await this.db.insertInto("_emdash_media_usage_work").columns([
+			"collection_id",
+			"collection_slug",
+			"content_id",
+			"change_epoch",
+			"work_version",
+			"state",
+			"attempt_count",
+			"next_attempt_at",
+			"lease_token",
+			"lease_expires_at",
+			"last_attempted_at",
+			"last_error_code",
+			"created_at",
+			"updated_at"
+		]).expression((insert) => insert.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((select) => [
+			select.val(input.collectionId).as("collection_id"),
+			"collection.slug as collection_slug",
+			select.val(input.contentId).as("content_id"),
+			"status.change_epoch as change_epoch",
+			select.val(1).as("work_version"),
+			select.val("pending").as("state"),
+			select.val(0).as("attempt_count"),
+			now.as("next_attempt_at"),
+			sql`NULL`.as("lease_token"),
+			sql`NULL`.as("lease_expires_at"),
+			sql`NULL`.as("last_attempted_at"),
+			sql`NULL`.as("last_error_code"),
+			now.as("created_at"),
+			now.as("updated_at")
+		]).where("status.adapter_id", "=", "content-media").where("status.scope_type", "=", "collection").where("status.scope_key", "=", input.collectionSlug).where("status.collection_id", "=", input.collectionId).where("status.capture_state", "=", "active").where("status.change_epoch", "=", input.changeEpoch)).onConflict((conflict) => conflict.columns(["collection_id", "content_id"]).doNothing()).returningAll().executeTakeFirst() ?? null;
+	}
+	async operatorRetryLost(input) {
+		if (!await this.findActiveOperatorCollection(input.collectionId)) return { outcome: "collection_not_found" };
+		const current = await this.findWorkByIdentity(input.collectionId, input.contentId);
+		if (current?.state === "pending") return {
+			outcome: "pending",
+			changed: false,
+			work: rowToOperatorWork(current)
+		};
+		const liveLease = await this.findLiveLeaseExpiry(input.collectionId, input.contentId);
+		if (liveLease) return {
+			outcome: "lease_active",
+			leaseExpiresAt: liveLease
+		};
+		return { outcome: "conflict" };
+	}
+	async findLiveLeaseExpiry(collectionId, contentId) {
+		return (await this.db.selectFrom("_emdash_media_usage_work").select("lease_expires_at").where("collection_id", "=", collectionId).where("content_id", "=", contentId).where("state", "=", "leased").where("lease_expires_at", "is not", null).where(this.leaseIsLive()).executeTakeFirst())?.lease_expires_at ?? null;
+	}
+	async claimDueWorkBatch(input) {
+		if (!Number.isSafeInteger(input.limit) || input.limit < 1 || input.limit > MAX_WORK_SELECTION_LIMIT) throw new Error(`Media usage due-work limit must be a whole number from 1 to ${MAX_WORK_SELECTION_LIMIT}`);
+		const leaseDurationSeconds = durationSeconds(input.leaseDurationSeconds, "lease duration", false);
+		const leaseToken = ulid();
+		const now = this.timestampOffset(0);
+		let candidates = this.db.selectFrom("_emdash_media_usage_work as due").select([
+			"due.collection_id",
+			"due.content_id",
+			"due.work_version"
+		]).where((eb) => eb.or([eb.and([eb("due.state", "in", ["pending", "retry"]), this.timestampIsDue("due.next_attempt_at")]), eb.and([
+			eb("due.state", "=", "leased"),
+			eb("due.lease_expires_at", "is not", null),
+			this.timestampIsDue("due.lease_expires_at")
+		])])).orderBy(sql`CASE
+					WHEN due.state = 'leased' THEN due.lease_expires_at
+					ELSE due.next_attempt_at
+				END`, "asc").orderBy("due.updated_at", "asc").orderBy("due.collection_id", "asc").orderBy("due.content_id", "asc").limit(input.limit);
+		if (isPostgres(this.db)) candidates = candidates.forUpdate().skipLocked();
+		return (await this.db.with("due_media_usage_work", () => candidates).updateTable("_emdash_media_usage_work").set({
+			state: "leased",
+			lease_token: leaseToken,
+			lease_expires_at: this.timestampOffset(leaseDurationSeconds),
+			last_attempted_at: now,
+			updated_at: now
+		}).where((eb) => eb.and([eb.exists(eb.selectFrom("due_media_usage_work as due").select("due.content_id").whereRef("due.collection_id", "=", "_emdash_media_usage_work.collection_id").whereRef("due.content_id", "=", "_emdash_media_usage_work.content_id").whereRef("due.work_version", "=", "_emdash_media_usage_work.work_version")), eb.or([eb.and([eb("state", "in", ["pending", "retry"]), this.timestampIsDue("next_attempt_at")]), eb.and([
+			eb("state", "=", "leased"),
+			eb("lease_expires_at", "is not", null),
+			this.timestampIsDue("lease_expires_at")
+		])])])).returningAll().execute()).map(rowToWork);
+	}
+	async hasNonterminalWork() {
+		return await this.db.selectFrom("_emdash_media_usage_work").select("content_id").where("state", "in", [
+			"pending",
+			"retry",
+			"leased"
+		]).limit(1).executeTakeFirst() !== void 0;
+	}
+	async findWorkForContent(collectionSlug, contentId) {
+		if (!collectionSlug || !contentId) throw new Error("Media usage work lookup requires collection and content identity");
+		const row = await this.db.selectFrom("_emdash_media_usage_work").innerJoin("_emdash_collections as current_collection", (join) => join.onRef("current_collection.id", "=", "_emdash_media_usage_work.collection_id").onRef("current_collection.slug", "=", "_emdash_media_usage_work.collection_slug")).selectAll("_emdash_media_usage_work").where("_emdash_media_usage_work.collection_slug", "=", collectionSlug).where("_emdash_media_usage_work.content_id", "=", contentId).executeTakeFirst();
+		return row ? rowToWork(row) : null;
+	}
+	async claimWork(input) {
+		assertIdentity(input);
+		const leaseDurationSeconds = durationSeconds(input.leaseDurationSeconds, "lease duration", false);
+		const leaseToken = ulid();
+		const now = this.timestampOffset(0);
+		const row = await this.db.updateTable("_emdash_media_usage_work").set({
+			state: "leased",
+			lease_token: leaseToken,
+			lease_expires_at: this.timestampOffset(leaseDurationSeconds),
+			last_attempted_at: now,
+			updated_at: now
+		}).where("collection_id", "=", input.collectionId).where("content_id", "=", input.contentId).where("work_version", "=", input.workVersion).where((eb) => eb.or([eb.and([eb("state", "in", ["pending", "retry"]), this.timestampIsDue("next_attempt_at")]), eb.and([
+			eb("state", "=", "leased"),
+			eb("lease_expires_at", "is not", null),
+			this.timestampIsDue("lease_expires_at")
+		])])).returningAll().executeTakeFirst();
+		return row ? rowToWork(row) : null;
+	}
+	async completeWorkBatch(inputs) {
+		const unique = [...new Map(inputs.map((input) => {
+			assertLease(input);
+			return [workIdentityKey(input), input];
+		})).values()];
+		const completed = /* @__PURE__ */ new Set();
+		if (unique.length === 0) return completed;
+		const payload = JSON.stringify(unique.map((input) => ({
+			collection_id: input.collectionId,
+			content_id: input.contentId,
+			work_version: String(input.workVersion),
+			lease_token: input.leaseToken
+		})));
+		const result = await sql`
+			WITH claimed AS (${this.claimedWorkBatchInput(payload)})
+			DELETE FROM _emdash_media_usage_work AS work
+			WHERE work.state = 'leased'
+				AND ${this.qualifiedLeaseIsLive("work.lease_expires_at")}
+				AND EXISTS (
+					SELECT 1
+					FROM claimed
+					WHERE claimed.collection_id = work.collection_id
+						AND claimed.content_id = work.content_id
+						AND claimed.work_version = work.work_version
+						AND claimed.lease_token = work.lease_token
+				)
+			RETURNING collection_id, content_id, work_version
+		`.execute(this.db);
+		for (const row of result.rows) completed.add(workIdentityKey({
+			collectionId: row.collection_id,
+			contentId: row.content_id,
+			workVersion: row.work_version
+		}));
+		return completed;
+	}
+	async lockClaimedWorkBatch(inputs) {
+		const unique = [...new Map(inputs.map((input) => {
+			assertLease(input);
+			return [workIdentityKey(input), input];
+		})).values()].toSorted((left, right) => workIdentityKey(left).localeCompare(workIdentityKey(right)));
+		if (!isPostgres(this.db)) return new Set(unique.map(workIdentityKey));
+		if (unique.length === 0) return /* @__PURE__ */ new Set();
+		const payload = JSON.stringify(unique.map((input) => ({
+			collection_id: input.collectionId,
+			content_id: input.contentId,
+			work_version: String(input.workVersion),
+			lease_token: input.leaseToken
+		})));
+		const result = await sql`
+			WITH claimed AS (${this.claimedWorkBatchInput(payload)})
+			SELECT work.collection_id, work.content_id, work.work_version
+			FROM _emdash_media_usage_work AS work
+			INNER JOIN claimed
+				ON claimed.collection_id = work.collection_id
+				AND claimed.content_id = work.content_id
+				AND claimed.work_version = work.work_version
+				AND claimed.lease_token = work.lease_token
+			WHERE work.state = 'leased'
+				AND ${this.qualifiedLeaseIsLive("work.lease_expires_at")}
+			ORDER BY work.collection_id, work.content_id
+			FOR UPDATE
+		`.execute(this.db);
+		return new Set(result.rows.map((row) => workIdentityKey({
+			collectionId: row.collection_id,
+			contentId: row.content_id,
+			workVersion: row.work_version
+		})));
+	}
+	async retryClaimedWorkBatch(input) {
+		assertErrorCode(input.errorCode);
+		const retryDelaySeconds = durationSeconds(input.retryDelaySeconds, "retry delay", true);
+		if (!Number.isSafeInteger(input.maxAttempts) || input.maxAttempts < 1) throw new Error("Media usage work max attempts must be a positive whole number");
+		const unique = [...new Map(input.work.map((work) => {
+			assertLease(work);
+			return [workIdentityKey(work), work];
+		})).values()];
+		const transitioned = /* @__PURE__ */ new Map();
+		if (unique.length === 0) return transitioned;
+		const payload = JSON.stringify(unique.map((work) => ({
+			collection_id: work.collectionId,
+			content_id: work.contentId,
+			work_version: String(work.workVersion),
+			lease_token: work.leaseToken
+		})));
+		const result = await sql`
+			WITH claimed AS (${this.claimedWorkBatchInput(payload)})
+			UPDATE _emdash_media_usage_work AS work
+			SET state = CASE WHEN work.attempt_count + 1 >= ${input.maxAttempts} THEN 'failed' ELSE 'retry' END,
+				attempt_count = work.attempt_count + 1,
+				next_attempt_at = ${this.timestampOffset(retryDelaySeconds)},
+				lease_token = NULL,
+				lease_expires_at = NULL,
+				last_error_code = ${input.errorCode},
+				updated_at = ${this.timestampOffset(0)}
+			WHERE work.state = 'leased'
+				AND ${this.qualifiedLeaseIsLive("work.lease_expires_at")}
+				AND EXISTS (
+					SELECT 1
+					FROM claimed
+					WHERE claimed.collection_id = work.collection_id
+						AND claimed.content_id = work.content_id
+						AND claimed.work_version = work.work_version
+						AND claimed.lease_token = work.lease_token
+				)
+			RETURNING collection_id, content_id, work_version, state
+		`.execute(this.db);
+		for (const row of result.rows) transitioned.set(workIdentityKey({
+			collectionId: row.collection_id,
+			contentId: row.content_id,
+			workVersion: row.work_version
+		}), row.state);
+		return transitioned;
+	}
+	async releaseClaimedWorkBatch(inputs) {
+		const unique = [...new Map(inputs.map((input) => {
+			assertLease(input);
+			return [workIdentityKey(input), input];
+		})).values()];
+		const released = /* @__PURE__ */ new Set();
+		if (unique.length === 0) return released;
+		const payload = JSON.stringify(unique.map((input) => ({
+			collection_id: input.collectionId,
+			content_id: input.contentId,
+			work_version: String(input.workVersion),
+			lease_token: input.leaseToken
+		})));
+		const result = await sql`
+			WITH claimed AS (${this.claimedWorkBatchInput(payload)})
+			UPDATE _emdash_media_usage_work AS work
+			SET state = 'pending',
+				next_attempt_at = ${this.timestampOffset(0)},
+				lease_token = NULL,
+				lease_expires_at = NULL,
+				updated_at = ${this.timestampOffset(0)}
+			WHERE work.state = 'leased'
+				AND ${this.qualifiedLeaseIsLive("work.lease_expires_at")}
+				AND EXISTS (
+					SELECT 1
+					FROM claimed
+					WHERE claimed.collection_id = work.collection_id
+						AND claimed.content_id = work.content_id
+						AND claimed.work_version = work.work_version
+						AND claimed.lease_token = work.lease_token
+				)
+			RETURNING collection_id, content_id, work_version
+		`.execute(this.db);
+		for (const row of result.rows) released.add(workIdentityKey({
+			collectionId: row.collection_id,
+			contentId: row.content_id,
+			workVersion: row.work_version
+		}));
+		return released;
+	}
+	async deleteWorkThroughEpoch(collectionId, maxChangeEpoch) {
+		if (!collectionId) throw new Error("Media usage work cleanup requires a collection ID");
+		assertNonNegativeDecimal(maxChangeEpoch, "change epoch");
+		const result = await this.db.deleteFrom("_emdash_media_usage_work").where("collection_id", "=", collectionId).where("change_epoch", "<=", maxChangeEpoch).executeTakeFirst();
+		return Number(result.numDeletedRows ?? 0);
+	}
+	async deleteObsoleteReconciliationWork(input) {
+		assertNonNegativeDecimal(input.targetEpoch, "target epoch");
+		const result = await this.db.deleteFrom("_emdash_media_usage_work as work").where("work.collection_id", "=", input.collectionId).where("work.change_epoch", "<", input.targetEpoch).where((eb) => eb.exists(eb.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")).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.collectionId).where("reconciliation.collection_slug", "=", input.collectionSlug).where("reconciliation.run_token", "=", input.runToken).where("reconciliation.target_epoch", "=", input.targetEpoch).where("reconciliation.state", "=", "leased").where("reconciliation.lease_token", "=", input.leaseToken).where(this.qualifiedLeaseIsLive("reconciliation.lease_expires_at")).where("status.capture_state", "=", "active").where("status.reconciliation_required", "=", 1).where("status.status", "=", "running").where("status.cursor", "=", input.runToken).where("status.change_epoch", "=", input.targetEpoch))).executeTakeFirst();
+		return Number(result.numDeletedRows ?? 0);
+	}
+	leaseIsLive() {
+		return isPostgres(this.db) ? sql`lease_expires_at::timestamptz > clock_timestamp()` : sql`lease_expires_at > strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
+	}
+	qualifiedLeaseIsLive(column) {
+		const expiry = sql.ref(column);
+		return isPostgres(this.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')`;
+	}
+	timestampIsDue(column) {
+		return isPostgres(this.db) ? sql`${sql.ref(column)} <= to_char(
+				statement_timestamp() AT TIME ZONE 'UTC',
+				'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"'
+			)` : sql`${sql.ref(column)} <= strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
+	}
+	timestampOffset(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`}
+		)`;
+	}
+	claimedWorkBatchInput(payload) {
+		if (isPostgres(this.db)) return sql`
+				SELECT
+					entry.value ->> 'collection_id' AS collection_id,
+					entry.value ->> 'content_id' AS content_id,
+					CAST(entry.value ->> 'work_version' AS bigint) AS work_version,
+					entry.value ->> 'lease_token' AS lease_token
+				FROM jsonb_array_elements(${payload}::jsonb) AS entry(value)
+			`;
+		return sql`
+			SELECT
+				json_extract(entry.value, '$.collection_id') AS collection_id,
+				json_extract(entry.value, '$.content_id') AS content_id,
+				CAST(json_extract(entry.value, '$.work_version') AS integer) AS work_version,
+				json_extract(entry.value, '$.lease_token') AS lease_token
+			FROM json_each(${payload}) AS entry
+		`;
+	}
+};
+function workIdentityKey(input) {
+	return `${input.collectionId}\u0000${input.contentId}\u0000${String(input.workVersion)}`;
+}
+function operatorLimit(value) {
+	if (value === void 0) return MEDIA_USAGE_WORK_OPERATOR_DEFAULT_LIMIT;
+	if (!Number.isSafeInteger(value) || value < 1 || value > MEDIA_USAGE_WORK_OPERATOR_MAX_LIMIT) throw new Error(`Media usage operator limit must be a whole number from 1 to ${MEDIA_USAGE_WORK_OPERATOR_MAX_LIMIT}`);
+	return value;
+}
+function durationSeconds(value, label, allowZero) {
+	if (!Number.isSafeInteger(value) || value < (allowZero ? 0 : 1) || value > MAX_PORTABLE_DURATION_SECONDS) throw new Error(`Media usage work ${label} must be ${allowZero ? "a non-negative" : "a positive"} whole number of seconds no greater than one year`);
+	return value;
+}
+function assertIdentity(input) {
+	if (!input.collectionId || !input.contentId) throw new Error("Media usage work identity must include collection and content IDs");
+	if (!(typeof input.workVersion === "number" && Number.isSafeInteger(input.workVersion) && input.workVersion > 0 || typeof input.workVersion === "string" && POSITIVE_DECIMAL_PATTERN.test(input.workVersion))) throw new Error("Media usage work identity must include a work version");
+}
+function assertNonNegativeDecimal(value, label) {
+	if (!(typeof value === "number" && Number.isSafeInteger(value) && value >= 0 || typeof value === "string" && NON_NEGATIVE_DECIMAL_PATTERN.test(value))) throw new Error(`Media usage work ${label} must be a non-negative whole number`);
+}
+function assertToken(value) {
+	if (!value) throw new Error("Media usage work lease token must not be empty");
+}
+function assertLease(input) {
+	assertIdentity(input);
+	assertToken(input.leaseToken);
+}
+function assertErrorCode(value) {
+	if (!STABLE_ERROR_CODE_PATTERN.test(value)) throw new Error("Media usage work error code must use a stable SCREAMING_SNAKE_CASE value");
+}
+function rowToWork(row) {
+	if (!isMediaUsageWorkState(row.state)) throw new Error(`Invalid media usage work state: ${row.state}`);
+	return {
+		collectionId: row.collection_id,
+		collectionSlug: row.collection_slug,
+		contentId: row.content_id,
+		changeEpoch: row.change_epoch,
+		workVersion: row.work_version,
+		state: row.state,
+		attemptCount: row.attempt_count,
+		nextAttemptAt: row.next_attempt_at,
+		leaseToken: row.lease_token,
+		leaseExpiresAt: row.lease_expires_at,
+		lastAttemptedAt: row.last_attempted_at,
+		lastErrorCode: row.last_error_code,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function rowToOperatorWork(row) {
+	const work = "collection_id" in row ? rowToWork(row) : row;
+	return {
+		collectionId: work.collectionId,
+		collectionSlug: work.collectionSlug,
+		contentId: work.contentId,
+		state: work.state,
+		attemptCount: work.attemptCount,
+		nextAttemptAt: work.nextAttemptAt,
+		leaseExpiresAt: work.leaseExpiresAt,
+		lastAttemptedAt: work.lastAttemptedAt,
+		lastErrorCode: work.lastErrorCode,
+		updatedAt: work.updatedAt
+	};
+}
+function isMediaUsageWorkState(value) {
+	return value === "pending" || value === "retry" || value === "leased" || value === "failed";
+}
+function compareOperatorWork(a, b) {
+	const updated = b.updatedAt.localeCompare(a.updatedAt);
+	return updated !== 0 ? updated : b.contentId.localeCompare(a.contentId);
+}
+
+//#endregion
+export { MediaUsageWorkRepository as t };
+//# sourceMappingURL=media-usage-work-Cu5DqewW.mjs.map