emdash 0.33.0 → 0.34.0

package/dist/collection-deletion-C8BugSGz.mjs

@@ -0,0 +1,779 @@
+import { t as validateIdentifier } from "./validate-BpwoDOgt.mjs";
+import { p as tableExists, s as isPostgres } from "./dialect-helpers-BSbfaO3F.mjs";
+import { n as isMissingTableError } from "./db-errors-Cl-sKYTm.mjs";
+import { o as decodeCursor, s as encodeCursor } from "./types-CQPWhPxE.mjs";
+import { t as withTransaction } from "./transaction-NQj4VJ7Z.mjs";
+import { t as FTSManager } from "./fts-manager-CZ-5dVwJ.mjs";
+import { sql } from "kysely";
+import { ulid } from "ulidx";
+
+//#region src/media/usage/capture-triggers.ts
+const POSTGRES_TRIGGER_FUNCTION = "emdash_media_usage_capture_work";
+const POSTGRES_IDENTIFIER_LIMIT = 63;
+const CAPTURE_TRIGGER_VERSION = 1;
+const OWNED_TRIGGER_PREFIX = "emdash_mu_";
+const WHITESPACE_PATTERN = /\s+/g;
+const TRAILING_SEMICOLON_PATTERN = /;$/;
+async function installMediaUsageCaptureTriggers(db, identity, options = {}) {
+	const identifiers = await captureIdentifiers(identity);
+	if (isPostgres(db)) await installPostgresFunction(db);
+	const installedNames = await listOwnedCaptureTriggers(db, identifiers.tableName);
+	if (await hasExactCaptureTriggers(db, identifiers, identity, installedNames)) return;
+	await assertCaptureLifecycle(db, identity, ["installing"]);
+	const expectedNames = new Set(Object.values(identifiers.triggerNames));
+	const retainedNames = new Set(options.replaceExisting === false ? installedNames.filter((name) => expectedNames.has(name)) : []);
+	await removeCaptureTriggers(db, identifiers.tableName, installedNames.filter((name) => !retainedNames.has(name)));
+	for (const operation of captureOperations) {
+		if (retainedNames.has(identifiers.triggerNames[operation])) continue;
+		if (isPostgres(db)) await postgresCreateTrigger(db, identifiers.tableName, identifiers.triggerNames[operation], operation, identity);
+		else await sqliteCreateTrigger(db, identifiers.tableName, identifiers.triggerNames[operation], operation, identity);
+	}
+	await assertExpectedTriggerSet(db, identifiers, identity);
+}
+async function verifyMediaUsageCaptureTriggers(db, identity) {
+	const identifiers = await captureIdentifiers(identity);
+	if (!await tableExists(db, identifiers.tableName)) return false;
+	return hasExactCaptureTriggers(db, identifiers, identity, await listOwnedCaptureTriggers(db, identifiers.tableName));
+}
+const captureOperations = [
+	"insert",
+	"update",
+	"delete"
+];
+async function captureIdentifiers(identity) {
+	validateIdentifier(identity.collectionSlug, "collection slug");
+	const tableName = `ec_${identity.collectionSlug}`;
+	validateIdentifier(tableName, "content table");
+	const digest = await identityDigest(`${CAPTURE_TRIGGER_VERSION}:${identity.collectionId}:${identity.collectionSlug}`);
+	const triggerNames = {
+		insert: `emdash_mu_${digest}_ai`,
+		update: `emdash_mu_${digest}_au`,
+		delete: `emdash_mu_${digest}_ad`
+	};
+	for (const triggerName of Object.values(triggerNames)) {
+		validateIdentifier(triggerName, "media usage trigger");
+		if (triggerName.length > POSTGRES_IDENTIFIER_LIMIT) throw new Error(`Media usage trigger name exceeds ${POSTGRES_IDENTIFIER_LIMIT} bytes`);
+	}
+	return {
+		tableName,
+		triggerNames
+	};
+}
+async function identityDigest(value) {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
+	return Array.from(new Uint8Array(digest).slice(0, 16), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function removeCaptureTriggers(db, tableName, triggerNames) {
+	for (const triggerName of triggerNames) {
+		validateIdentifier(triggerName, "media usage trigger");
+		if (isPostgres(db)) await sql`
+				DROP TRIGGER IF EXISTS ${sql.ref(triggerName)} ON ${sql.ref(tableName)}
+			`.execute(db);
+		else await sql`DROP TRIGGER IF EXISTS ${sql.ref(triggerName)}`.execute(db);
+	}
+}
+async function listOwnedCaptureTriggers(db, tableName) {
+	if (isPostgres(db)) return (await sql`
+			SELECT trigger.tgname AS name
+			FROM pg_trigger AS trigger
+			INNER JOIN pg_class AS relation ON relation.oid = trigger.tgrelid
+			INNER JOIN pg_namespace AS namespace ON namespace.oid = relation.relnamespace
+			WHERE namespace.nspname = current_schema()
+				AND relation.relname = ${tableName}
+				AND NOT trigger.tgisinternal
+				AND left(trigger.tgname, 10) = ${OWNED_TRIGGER_PREFIX}
+		`.execute(db)).rows.map((row) => row.name);
+	return (await sql`
+		SELECT name
+		FROM sqlite_master
+		WHERE type = 'trigger'
+			AND tbl_name = ${tableName}
+			AND substr(name, 1, 10) = ${OWNED_TRIGGER_PREFIX}
+	`.execute(db)).rows.map((row) => row.name);
+}
+async function hasExactCaptureTriggers(db, identifiers, identity, installedNames) {
+	const expectedNames = new Set(Object.values(identifiers.triggerNames));
+	if (installedNames.length !== expectedNames.size || installedNames.some((name) => !expectedNames.has(name))) return false;
+	if (isPostgres(db)) {
+		const result = await sql`
+			SELECT
+				trigger.tgname AS name,
+				trigger.tgtype AS trigger_type,
+				procedure.proname AS function_name,
+				encode(trigger.tgargs, 'hex') AS arguments_hex,
+				trigger.tgenabled AS enabled,
+				trigger.tgqual IS NOT NULL AS has_when
+			FROM pg_trigger AS trigger
+			INNER JOIN pg_class AS relation ON relation.oid = trigger.tgrelid
+			INNER JOIN pg_namespace AS namespace ON namespace.oid = relation.relnamespace
+			INNER JOIN pg_proc AS procedure ON procedure.oid = trigger.tgfoid
+			INNER JOIN pg_namespace AS function_namespace ON function_namespace.oid = procedure.pronamespace
+			WHERE namespace.nspname = current_schema()
+				AND function_namespace.nspname = current_schema()
+				AND relation.relname = ${identifiers.tableName}
+				AND NOT trigger.tgisinternal
+				AND trigger.tgconstraint = 0
+				AND NOT trigger.tgdeferrable
+				AND NOT trigger.tginitdeferred
+				AND trigger.tgattr = ''::int2vector
+				AND left(trigger.tgname, 10) = ${OWNED_TRIGGER_PREFIX}
+		`.execute(db);
+		const expectedArguments = triggerArgumentsHex(identity);
+		return captureOperations.every((operation) => {
+			const row = result.rows.find((candidate) => candidate.name === identifiers.triggerNames[operation]);
+			return row?.function_name === POSTGRES_TRIGGER_FUNCTION && Number(row.trigger_type) === postgresTriggerType(operation) && row.arguments_hex === expectedArguments && row.enabled === "O" && row.has_when === false;
+		});
+	}
+	const result = await sql`
+		SELECT name, sql AS definition
+		FROM sqlite_master
+		WHERE type = 'trigger'
+			AND tbl_name = ${identifiers.tableName}
+			AND substr(name, 1, 10) = ${OWNED_TRIGGER_PREFIX}
+	`.execute(db);
+	return captureOperations.every((operation) => {
+		const row = result.rows.find((candidate) => candidate.name === identifiers.triggerNames[operation]);
+		const contentId = operation === "delete" ? sql`OLD.id` : sql`NEW.id`;
+		const expected = sqliteTriggerSql(identifiers.tableName, identifiers.triggerNames[operation], operationSql(operation), contentId, identity).compile(db).sql;
+		return row ? normalizeDdl(row.definition) === normalizeDdl(expected) : false;
+	});
+}
+function triggerArgumentsHex(identity) {
+	const bytes = new TextEncoder().encode(`${identity.collectionId}\0${identity.collectionSlug}\0`);
+	return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function postgresTriggerType(operation) {
+	switch (operation) {
+		case "insert": return 5;
+		case "update": return 17;
+		case "delete": return 9;
+	}
+}
+function normalizeDdl(definition) {
+	return definition.replace(WHITESPACE_PATTERN, " ").trim().replace(TRAILING_SEMICOLON_PATTERN, "");
+}
+async function assertCaptureLifecycle(db, identity, allowedStates) {
+	const lifecycle = await db.selectFrom("_emdash_media_usage_index_status").select("capture_state").where("adapter_id", "=", "content-media").where("scope_type", "=", "collection").where("scope_key", "=", identity.collectionSlug).where("collection_id", "=", identity.collectionId).executeTakeFirst();
+	if (!lifecycle?.capture_state || !allowedStates.includes(lifecycle.capture_state)) throw new Error("Media usage capture trigger changes require a fenced collection lifecycle");
+}
+async function assertExpectedTriggerSet(db, identifiers, identity) {
+	if (!await hasExactCaptureTriggers(db, identifiers, identity, await listOwnedCaptureTriggers(db, identifiers.tableName))) throw new Error("Media usage capture trigger installation is incomplete");
+}
+async function installPostgresFunction(db) {
+	await sql`
+		CREATE OR REPLACE FUNCTION ${sql.ref(POSTGRES_TRIGGER_FUNCTION)}()
+		RETURNS trigger
+		LANGUAGE plpgsql
+		AS $function$
+		DECLARE
+			v_collection_id text := TG_ARGV[0];
+			v_collection_slug text := TG_ARGV[1];
+			v_content_id text;
+			v_epoch bigint;
+			v_now text := to_char(
+				clock_timestamp() AT TIME ZONE 'UTC',
+				'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"'
+			);
+		BEGIN
+			IF TG_OP = 'DELETE' THEN
+				v_content_id := OLD.id;
+			ELSE
+				v_content_id := NEW.id;
+			END IF;
+
+			UPDATE _emdash_media_usage_index_status
+			SET change_epoch = change_epoch + 1,
+				status = CASE WHEN status = 'complete' THEN 'stale' ELSE status END,
+				completed_at = CASE WHEN status = 'complete' THEN NULL ELSE completed_at END,
+				updated_at = v_now
+			WHERE adapter_id = 'content-media'
+				AND scope_type = 'collection'
+				AND scope_key = v_collection_slug
+				AND collection_id = v_collection_id
+				AND capture_state = 'active'
+				AND EXISTS (
+					SELECT 1
+					FROM _emdash_collections AS collection
+					WHERE collection.id = v_collection_id
+						AND collection.slug = v_collection_slug
+				)
+			RETURNING change_epoch INTO v_epoch;
+
+			IF NOT FOUND THEN
+				RAISE EXCEPTION USING
+					ERRCODE = 'P0001',
+					MESSAGE = 'media usage capture inactive';
+			END IF;
+
+			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
+			)
+			VALUES (
+				v_collection_id,
+				v_collection_slug,
+				v_content_id,
+				v_epoch,
+				1,
+				'pending',
+				0,
+				v_now,
+				NULL,
+				NULL,
+				NULL,
+				NULL,
+				v_now,
+				v_now
+			)
+			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;
+
+			RETURN NULL;
+		END;
+		$function$
+	`.execute(db);
+}
+async function postgresCreateTrigger(db, tableName, triggerName, operation, identity) {
+	await sql`
+		CREATE TRIGGER ${sql.ref(triggerName)}
+		AFTER ${operationSql(operation)} ON ${sql.ref(tableName)}
+		FOR EACH ROW
+		EXECUTE FUNCTION ${sql.ref(POSTGRES_TRIGGER_FUNCTION)}(
+			${sql.lit(identity.collectionId)},
+			${sql.lit(identity.collectionSlug)}
+		)
+	`.execute(db);
+}
+async function sqliteCreateTrigger(db, tableName, triggerName, operation, identity) {
+	const contentId = operation === "delete" ? sql`OLD.id` : sql`NEW.id`;
+	await sqliteTriggerSql(tableName, triggerName, operationSql(operation), contentId, identity).execute(db);
+}
+function sqliteTriggerSql(tableName, triggerName, operation, contentId, identity) {
+	return sql`
+		CREATE TRIGGER ${sql.ref(triggerName)}
+		AFTER ${operation} ON ${sql.ref(tableName)}
+		FOR EACH ROW
+		BEGIN
+			UPDATE _emdash_media_usage_index_status
+			SET change_epoch = change_epoch + 1,
+				status = CASE WHEN status = 'complete' THEN 'stale' ELSE status END,
+				completed_at = CASE WHEN status = 'complete' THEN NULL ELSE completed_at END,
+				updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+			WHERE adapter_id = 'content-media'
+				AND scope_type = 'collection'
+				AND scope_key = ${sql.lit(identity.collectionSlug)}
+				AND collection_id = ${sql.lit(identity.collectionId)}
+				AND capture_state = 'active'
+				AND EXISTS (
+					SELECT 1
+					FROM _emdash_collections AS collection
+					WHERE collection.id = ${sql.lit(identity.collectionId)}
+						AND collection.slug = ${sql.lit(identity.collectionSlug)}
+				);
+
+			SELECT CASE
+				WHEN changes() <> 1 THEN RAISE(ABORT, 'media usage capture inactive')
+			END;
+
+			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
+				${sql.lit(identity.collectionId)},
+				${sql.lit(identity.collectionSlug)},
+				${contentId},
+				change_epoch,
+				1,
+				'pending',
+				0,
+				strftime('%Y-%m-%dT%H:%M:%fZ', 'now'),
+				NULL,
+				NULL,
+				NULL,
+				NULL,
+				strftime('%Y-%m-%dT%H:%M:%fZ', 'now'),
+				strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+			FROM _emdash_media_usage_index_status
+			WHERE adapter_id = 'content-media'
+				AND scope_type = 'collection'
+				AND scope_key = ${sql.lit(identity.collectionSlug)}
+				AND collection_id = ${sql.lit(identity.collectionId)}
+				AND capture_state = 'active'
+			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;
+		END
+	`;
+}
+function operationSql(operation) {
+	switch (operation) {
+		case "insert": return sql`INSERT`;
+		case "update": return sql`UPDATE`;
+		case "delete": return sql`DELETE`;
+	}
+}
+
+//#endregion
+//#region src/media/usage/collection-deletion.ts
+const ACTIVATION_KEY = "incremental_capture";
+const VIRTUAL_DIALECT_ID = "virtual:emdash/dialect";
+var MediaUsageCollectionDeletionRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async createTombstone(input) {
+		assertIdentity(input);
+		const now = timestampOffset(this.db, 0);
+		await this.db.insertInto("_emdash_media_usage_collection_deletions").values({
+			collection_id: input.collectionId,
+			collection_slug: input.collectionSlug,
+			force_delete: input.forceDelete ? 1 : 0,
+			state: "pending",
+			phase: "fence",
+			next_attempt_at: now,
+			updated_at: now
+		}).onConflict((conflict) => conflict.column("collection_id").doNothing()).execute();
+		const row = await this.db.selectFrom("_emdash_media_usage_collection_deletions").selectAll().where("collection_id", "=", input.collectionId).executeTakeFirstOrThrow();
+		if (row.collection_slug !== input.collectionSlug || Boolean(row.force_delete) !== input.forceDelete) throw new Error("Collection deletion tombstone identity conflicts with existing work");
+		return rowToRecord(row);
+	}
+	async claim(input) {
+		if (!input.collectionId || !isPhase(input.phase)) throw new Error("Collection deletion claim requires an exact identity and phase");
+		if (!Number.isSafeInteger(input.leaseDurationSeconds) || input.leaseDurationSeconds < 1) throw new Error("Collection deletion lease duration must be a positive whole number");
+		const leaseToken = ulid();
+		const row = await this.db.updateTable("_emdash_media_usage_collection_deletions").set({
+			state: "leased",
+			lease_token: leaseToken,
+			lease_expires_at: timestampOffset(this.db, input.leaseDurationSeconds),
+			updated_at: timestampOffset(this.db, 0)
+		}).where("collection_id", "=", input.collectionId).where("phase", "=", input.phase).where((eb) => eb.or([eb.and([eb("state", "in", ["pending", "retry"]), timestampIsDue(this.db, "next_attempt_at")]), eb.and([eb("state", "=", "leased"), timestampIsDue(this.db, "lease_expires_at")])])).returningAll().executeTakeFirst();
+		if (!row) return null;
+		return {
+			...rowToRecord(row),
+			leaseToken
+		};
+	}
+	async findBySlug(collectionSlug) {
+		validateIdentifier(collectionSlug, "collection slug");
+		try {
+			const row = await this.db.selectFrom("_emdash_media_usage_collection_deletions").selectAll().where("collection_slug", "=", collectionSlug).executeTakeFirst();
+			return row ? rowToRecord(row) : null;
+		} catch (error) {
+			if (isMissingTableError(error)) return null;
+			throw error;
+		}
+	}
+	async findDue(limit) {
+		if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100) throw new Error("Collection deletion candidate limit must be from 1 to 100");
+		const nextAttemptIsDue = timestampIsDue(this.db, "next_attempt_at");
+		return (await sql`
+			WITH pending_candidates AS (
+				SELECT * FROM _emdash_media_usage_collection_deletions
+				WHERE state = 'pending' AND ${nextAttemptIsDue}
+				ORDER BY next_attempt_at, updated_at, collection_id
+				LIMIT ${limit}
+			), retry_candidates AS (
+				SELECT * FROM _emdash_media_usage_collection_deletions
+				WHERE state = 'retry' AND ${nextAttemptIsDue}
+				ORDER BY next_attempt_at, updated_at, collection_id
+				LIMIT ${limit}
+			), leased_candidates AS (
+				SELECT * FROM _emdash_media_usage_collection_deletions
+				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 findOperatorPage(options) {
+		const state = options.state ?? "failed";
+		if (!isState(state)) throw new Error("Invalid collection deletion state");
+		const limit = options.limit ?? 50;
+		if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100) throw new Error("Collection deletion operator limit must be from 1 to 100");
+		const cursor = options.cursor ? decodeCursor(options.cursor) : null;
+		let query = this.db.selectFrom("_emdash_media_usage_collection_deletions").selectAll().where("state", "=", state);
+		if (cursor) query = query.where((eb) => eb.or([eb("updated_at", "<", cursor.orderValue), eb.and([eb("updated_at", "=", cursor.orderValue), eb("collection_id", "<", cursor.id)])]));
+		const rows = await query.orderBy("updated_at", "desc").orderBy("collection_id", "desc").limit(limit + 1).execute();
+		const items = rows.slice(0, limit).map(rowToOperatorItem);
+		const result = { items };
+		if (rows.length > limit && items.length > 0) {
+			const last = items.at(-1);
+			result.nextCursor = encodeCursor(last.updatedAt, last.collectionId);
+		}
+		return result;
+	}
+	async retryOperatorDeletion(input) {
+		if (!input.collectionId) throw new Error("Collection deletion retry requires an ID");
+		const observed = await this.db.selectFrom("_emdash_media_usage_collection_deletions").selectAll().where("collection_id", "=", input.collectionId).executeTakeFirst();
+		if (!observed) return { outcome: "not_found" };
+		if (observed.state === "leased" && observed.lease_expires_at) {
+			const live = await this.db.selectFrom("_emdash_media_usage_collection_deletions").select("lease_expires_at").where("collection_id", "=", input.collectionId).where("state", "=", "leased").where(liveLease(this.db)).executeTakeFirst();
+			if (live?.lease_expires_at) return {
+				outcome: "lease_active",
+				leaseExpiresAt: live.lease_expires_at
+			};
+		}
+		const now = timestampOffset(this.db, 0);
+		const reopened = await this.db.updateTable("_emdash_media_usage_collection_deletions").set({
+			state: "pending",
+			attempt_count: 0,
+			next_attempt_at: now,
+			lease_token: null,
+			lease_expires_at: null,
+			last_error_code: null,
+			updated_at: now
+		}).where("collection_id", "=", input.collectionId).where((eb) => eb.or([eb("state", "in", ["failed", "retry"]), eb.and([eb("state", "=", "leased"), timestampIsDue(this.db, "lease_expires_at")])])).returningAll().executeTakeFirst();
+		if (reopened) return {
+			outcome: "pending",
+			changed: true,
+			item: rowToOperatorItem(reopened)
+		};
+		return { outcome: "conflict" };
+	}
+	async checkpoint(input) {
+		const result = await this.db.updateTable("_emdash_media_usage_collection_deletions").set({
+			phase: input.toPhase,
+			attempt_count: 0,
+			last_error_code: null,
+			updated_at: timestampOffset(this.db, 0)
+		}).where("collection_id", "=", input.collectionId).where("state", "=", "leased").where("phase", "=", input.fromPhase).where("lease_token", "=", input.leaseToken).where(liveLease(this.db)).executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) === 1;
+	}
+	async release(input) {
+		const now = timestampOffset(this.db, 0);
+		const result = await this.db.updateTable("_emdash_media_usage_collection_deletions").set({
+			state: "pending",
+			next_attempt_at: now,
+			lease_token: null,
+			lease_expires_at: null,
+			attempt_count: 0,
+			last_error_code: null,
+			updated_at: now
+		}).where("collection_id", "=", input.collectionId).where("state", "=", "leased").where("lease_token", "=", input.leaseToken).where(liveLease(this.db)).executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) === 1;
+	}
+	async cancelFence(input) {
+		const result = await this.db.deleteFrom("_emdash_media_usage_collection_deletions").where("collection_id", "=", input.collectionId).where("state", "=", "leased").where("phase", "=", "fence").where("lease_token", "=", input.leaseToken).where(liveLease(this.db)).executeTakeFirst();
+		return Number(result.numDeletedRows ?? 0) === 1;
+	}
+	async recordFailure(input) {
+		const result = await this.db.updateTable("_emdash_media_usage_collection_deletions").set({
+			state: input.terminal ? "failed" : "retry",
+			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("state", "=", "leased").where("lease_token", "=", input.leaseToken).where(liveLease(this.db)).executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) === 1;
+	}
+	async deleteRegistryAndCheckpoint(input) {
+		return withTransaction(this.db, async (trx) => {
+			await trx.deleteFrom("_emdash_collections").where("id", "=", input.collectionId).where("slug", "=", input.collectionSlug).where((eb) => eb.exists(eb.selectFrom("_emdash_media_usage_collection_deletions as deletion").select("deletion.collection_id").where("deletion.collection_id", "=", input.collectionId).where("deletion.collection_slug", "=", input.collectionSlug).where("deletion.state", "=", "leased").where("deletion.phase", "=", "registry").where("deletion.lease_token", "=", input.leaseToken).where(liveLease(trx, "deletion.lease_expires_at")))).execute();
+			const checkpoint = await trx.updateTable("_emdash_media_usage_collection_deletions").set({
+				phase: "table",
+				updated_at: timestampOffset(trx, 0)
+			}).where("collection_id", "=", input.collectionId).where("collection_slug", "=", input.collectionSlug).where("state", "=", "leased").where("phase", "=", "registry").where("lease_token", "=", input.leaseToken).where(liveLease(trx)).executeTakeFirst();
+			return Number(checkpoint.numUpdatedRows ?? 0) === 1;
+		});
+	}
+};
+async function deleteActivatedMediaUsageCollection(db, input, options = {}) {
+	const frontPhaseLimit = options.frontPhaseLimit ?? 3;
+	if (!Number.isSafeInteger(frontPhaseLimit) || frontPhaseLimit < 1 || frontPhaseLimit > 3) throw new Error("Collection deletion front-phase limit must be from 1 to 3");
+	validateIdentifier(input.collectionSlug, "collection slug");
+	const repository = new MediaUsageCollectionDeletionRepository(db);
+	let deletion = await repository.findBySlug(input.collectionSlug);
+	if (deletion && input.collectionId && deletion.collectionId !== input.collectionId) throw new Error("Collection deletion tombstone identity conflict");
+	if (!deletion) {
+		let activation;
+		try {
+			activation = await db.selectFrom("_emdash_media_usage_activation").select("state").where("task_key", "=", ACTIVATION_KEY).executeTakeFirst();
+		} catch (error) {
+			if (!isMissingTableError(error)) throw error;
+		}
+		if (!activation || activation.state === "expanded") return "inactive";
+		if (activation.state !== "active") throw new Error("Media usage activation must be active before collection deletion");
+		if (!input.collectionId) return "not_found";
+		await assertActivatedCollectionDeletionReady(db, {
+			collectionId: input.collectionId,
+			collectionSlug: input.collectionSlug
+		});
+		deletion = await repository.createTombstone({
+			collectionId: input.collectionId,
+			collectionSlug: input.collectionSlug,
+			forceDelete: input.forceDelete
+		});
+	}
+	if (deletion.phase !== "fence" && deletion.phase !== "registry" && deletion.phase !== "table") return "deleted";
+	const claim = options.claimed ?? await repository.claim({
+		collectionId: deletion.collectionId,
+		phase: deletion.phase,
+		leaseDurationSeconds: 300
+	});
+	if (!claim) return "in_progress";
+	if (claim.collectionId !== deletion.collectionId || claim.phase !== deletion.phase) throw new Error("Collection deletion claim identity conflict");
+	let phase = claim.phase;
+	let processedFrontPhases = 0;
+	const lease = {
+		collectionId: claim.collectionId,
+		leaseToken: claim.leaseToken
+	};
+	if (phase === "fence") {
+		const captureState = await findCollectionCaptureState(db, claim);
+		if (captureState !== "active" && captureState !== "deleting") throw new Error("Activated collection deletion requires a fenced capture lifecycle");
+		if (!await verifyMediaUsageCaptureTriggers(db, claim)) throw new Error("Activated collection deletion requires the exact capture trigger set");
+		if (captureState === "active") {
+			const result = await executeCollectionDeletionGuard(db, {
+				action: "fence",
+				collectionId: claim.collectionId,
+				collectionSlug: claim.collectionSlug,
+				leaseToken: claim.leaseToken,
+				forceDelete: claim.forceDelete
+			});
+			if (result.outcome === "has_content") {
+				if (!await repository.cancelFence(lease)) throw new Error("Collection deletion lost its fence while preserving content");
+				return "has_content";
+			}
+			if (result.outcome !== "fenced") throw new Error("Collection deletion lost its fence");
+		}
+		if (!await repository.checkpoint({
+			...lease,
+			fromPhase: "fence",
+			toPhase: "registry"
+		})) throw new Error("Collection deletion lost its fence checkpoint");
+		phase = "registry";
+		processedFrontPhases++;
+		if (processedFrontPhases >= frontPhaseLimit) {
+			if (!await repository.release(lease)) throw new Error("Collection deletion lost its handoff");
+			return "advanced";
+		}
+	}
+	if (phase === "registry") {
+		if (!await repository.deleteRegistryAndCheckpoint({
+			...lease,
+			collectionSlug: claim.collectionSlug
+		})) throw new Error("Collection deletion lost its registry checkpoint");
+		phase = "table";
+		processedFrontPhases++;
+		if (processedFrontPhases >= frontPhaseLimit) {
+			if (!await repository.release(lease)) throw new Error("Collection deletion lost its handoff");
+			return "advanced";
+		}
+	}
+	if (phase === "table") {
+		if ((await executeCollectionDeletionGuard(db, {
+			action: "drop",
+			collectionId: claim.collectionId,
+			collectionSlug: claim.collectionSlug,
+			leaseToken: claim.leaseToken
+		})).outcome !== "dropped") throw new Error("Collection deletion lost its table fence");
+		if (!await repository.checkpoint({
+			...lease,
+			fromPhase: "table",
+			toPhase: "work"
+		})) throw new Error("Collection deletion lost its table checkpoint");
+	}
+	if (!await repository.release(lease)) throw new Error("Collection deletion lost its cleanup handoff");
+	return "deleted";
+}
+async function isMediaUsageCollectionSlugDeleting(db, collectionSlug) {
+	validateIdentifier(collectionSlug, "collection slug");
+	try {
+		return await db.selectFrom("_emdash_media_usage_collection_deletions").select("collection_id").where("collection_slug", "=", collectionSlug).executeTakeFirst() !== void 0;
+	} catch (error) {
+		if (isMissingTableError(error)) return false;
+		throw error;
+	}
+}
+async function assertActivatedCollectionDeletionReady(db, identity) {
+	if (await findCollectionCaptureState(db, identity) !== "active") throw new Error("Activated collection deletion requires an active capture lifecycle");
+	if (!await verifyMediaUsageCaptureTriggers(db, identity)) throw new Error("Activated collection deletion requires the exact capture trigger set");
+}
+async function findCollectionCaptureState(db, identity) {
+	return (await db.selectFrom("_emdash_media_usage_index_status").select("capture_state").where("adapter_id", "=", "content-media").where("scope_type", "=", "collection").where("scope_key", "=", identity.collectionSlug).where("collection_id", "=", identity.collectionId).executeTakeFirst())?.capture_state ?? null;
+}
+async function executeCollectionDeletionGuard(db, input) {
+	const executeAdapterGuard = await loadAdapterCollectionDeletionGuard();
+	if (executeAdapterGuard) {
+		const { default: config } = await import("virtual:emdash/config");
+		return executeAdapterGuard(config.database?.config, input);
+	}
+	return executeLocalCollectionDeletionGuard(db, input);
+}
+async function loadAdapterCollectionDeletionGuard() {
+	try {
+		return (await import("virtual:emdash/dialect")).executeCollectionDeletionGuard;
+	} catch (error) {
+		if (isVirtualDialectUnavailableError(error)) return void 0;
+		throw error;
+	}
+}
+function isVirtualDialectUnavailableError(error) {
+	if (!(error instanceof Error) || !("code" in error)) return false;
+	if (error.code === "ERR_MODULE_NOT_FOUND") return error.message.includes(VIRTUAL_DIALECT_ID);
+	return error.code === "ERR_UNSUPPORTED_ESM_URL_SCHEME" && error.message.includes("Received protocol 'virtual:'");
+}
+async function executeLocalCollectionDeletionGuard(db, input) {
+	assertGuardInput(input);
+	return db.transaction().execute(async (trx) => {
+		if (!await lockLiveTombstone(trx, input)) return { outcome: "stale" };
+		if (input.action === "fence") return fenceCollection(trx, input);
+		await new FTSManager(trx).dropFtsTable(input.collectionSlug);
+		await sql`DROP TABLE IF EXISTS ${sql.ref(`ec_${input.collectionSlug}`)}`.execute(trx);
+		return { outcome: "dropped" };
+	});
+}
+async function fenceCollection(trx, input) {
+	const tableName = `ec_${input.collectionSlug}`;
+	validateIdentifier(tableName, "content table");
+	if (isPostgres(trx)) await sql`LOCK TABLE ${sql.ref(tableName)} IN SHARE ROW EXCLUSIVE MODE`.execute(trx);
+	if (!input.forceDelete) {
+		if ((await sql`
+			SELECT 1 AS present FROM ${sql.ref(tableName)}
+			WHERE deleted_at IS NULL
+			LIMIT 1
+		`.execute(trx)).rows.length > 0) return { outcome: "has_content" };
+	}
+	const result = await trx.updateTable("_emdash_media_usage_index_status as status").set({
+		capture_state: "deleting",
+		updated_at: timestampOffset(trx, 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").where("collection.id", "=", input.collectionId).where("collection.slug", "=", input.collectionSlug))).executeTakeFirst();
+	return Number(result.numUpdatedRows ?? 0) === 1 ? { outcome: "fenced" } : { outcome: "stale" };
+}
+async function lockLiveTombstone(trx, input) {
+	const phase = input.action === "fence" ? "fence" : "table";
+	if (isPostgres(trx)) return await trx.selectFrom("_emdash_media_usage_collection_deletions").select("collection_id").where("collection_id", "=", input.collectionId).where("collection_slug", "=", input.collectionSlug).where("state", "=", "leased").where("phase", "=", phase).where("lease_token", "=", input.leaseToken).where(liveLease(trx)).forUpdate().executeTakeFirst() !== void 0;
+	const locked = await trx.updateTable("_emdash_media_usage_collection_deletions").set({ updated_at: sql`updated_at` }).where("collection_id", "=", input.collectionId).where("collection_slug", "=", input.collectionSlug).where("state", "=", "leased").where("phase", "=", phase).where("lease_token", "=", input.leaseToken).where(liveLease(trx)).executeTakeFirst();
+	return Number(locked.numUpdatedRows ?? 0) === 1;
+}
+function assertIdentity(input) {
+	if (!input.collectionId) throw new Error("Collection deletion requires a collection ID");
+	validateIdentifier(input.collectionSlug, "collection slug");
+}
+function assertGuardInput(input) {
+	assertIdentity(input);
+	if (!input.leaseToken) throw new Error("Collection deletion requires a lease token");
+}
+function liveLease(db, column = "lease_expires_at") {
+	const leaseExpiresAt = sql.ref(column);
+	return isPostgres(db) ? sql`${leaseExpiresAt}::timestamptz > clock_timestamp()` : sql`${leaseExpiresAt} > strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
+}
+function timestampIsDue(db, column) {
+	return isPostgres(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')`;
+}
+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 collectionDeletionCurrentTimestamp(db) {
+	return timestampOffset(db, 0);
+}
+function rowToRecord(row) {
+	if (!isState(row.state) || !isPhase(row.phase)) throw new Error("Invalid media usage collection deletion lifecycle");
+	return {
+		collectionId: row.collection_id,
+		collectionSlug: row.collection_slug,
+		forceDelete: Boolean(row.force_delete),
+		state: row.state,
+		phase: row.phase,
+		workCursor: row.work_cursor,
+		sourceKey: row.source_key,
+		occurrenceCursor: row.occurrence_cursor,
+		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 rowToOperatorItem(row) {
+	const deletion = rowToRecord(row);
+	return {
+		collectionId: deletion.collectionId,
+		collectionSlug: deletion.collectionSlug,
+		state: deletion.state,
+		phase: deletion.phase,
+		attemptCount: deletion.attemptCount,
+		nextAttemptAt: deletion.nextAttemptAt,
+		leaseExpiresAt: deletion.leaseExpiresAt,
+		lastErrorCode: deletion.lastErrorCode,
+		updatedAt: deletion.updatedAt
+	};
+}
+function isState(value) {
+	return value === "pending" || value === "retry" || value === "leased" || value === "failed";
+}
+function isPhase(value) {
+	return value === "fence" || value === "registry" || value === "table" || value === "work" || value === "sources" || value === "status" || value === "finalize";
+}
+
+//#endregion
+export { installMediaUsageCaptureTriggers as a, isMediaUsageCollectionSlugDeleting as i, collectionDeletionCurrentTimestamp as n, verifyMediaUsageCaptureTriggers as o, deleteActivatedMediaUsageCollection as r, MediaUsageCollectionDeletionRepository as t };
+//# sourceMappingURL=collection-deletion-C8BugSGz.mjs.map