emdash 0.41.0 → 0.42.0

package/src/transfer/analyze/values.ts

@@ -4,6 +4,7 @@
  * values (column types, NOT NULL, Postgres int4 / float4).
  */
 
+import { isSafeUrlFieldWriteValue } from "../../utils/url.js";
 import { isTransferError } from "../errors.js";
 import { measureJsonDepth } from "../format/canonical.js";
 import { encodeColumn } from "../format/column-codec.js";
@@ -21,6 +22,19 @@ export interface FieldInfo {
 	required: boolean;
 	/** Values live as content references; the target has no column for them. */
 	storageless?: boolean;
+	type?: "url" | "repeater" | "blocks";
+	urlSubFields?: string[];
+}
+
+export interface BlockTypeInfo {
+	id: string;
+	currentVersion: number;
+}
+
+export interface UrlValueField {
+	slug: string;
+	type: "url" | "repeater";
+	urlSubFields?: string[];
 }
 
 const PROVIDER_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
@@ -166,6 +180,90 @@ function mismatch(field: string, message: string): ValueIssue {
 	return { code: "value_constraint_violation", message, property: "fields", field };
 }
 
+function urlMismatch(property: string, field: string): ValueIssue {
+	return {
+		code: "value_constraint_violation",
+		message: "URL field value is not safe to store",
+		property,
+		field,
+	};
+}
+
+function arrayValue(value: unknown): unknown[] | undefined {
+	if (Array.isArray(value)) return value;
+	if (typeof value !== "string") return undefined;
+	const parsed = parseEmbeddedJson(value);
+	return Array.isArray(parsed) ? parsed : undefined;
+}
+
+function unsafeUrlFields(value: unknown, fields: readonly UrlValueField[], path: string): string[] {
+	const issues: string[] = [];
+	if (!isPlainObject(value)) return issues;
+	for (const field of fields) {
+		const fieldPath = `${path}.${field.slug}`;
+		const fieldValue = value[field.slug];
+		if (field.type === "url") {
+			if (typeof fieldValue === "string" && !isSafeUrlFieldWriteValue(fieldValue)) {
+				issues.push(fieldPath);
+			}
+			continue;
+		}
+		for (const [index, row] of (arrayValue(fieldValue) ?? []).entries()) {
+			if (!isPlainObject(row)) continue;
+			for (const slug of field.urlSubFields ?? []) {
+				const nested = row[slug];
+				if (typeof nested === "string" && !isSafeUrlFieldWriteValue(nested)) {
+					issues.push(`${fieldPath}.${index}.${slug}`);
+				}
+			}
+		}
+	}
+	return issues;
+}
+
+export function checkContentUrlFields(
+	values: Record<string, unknown>,
+	fields: ReadonlyMap<string, FieldInfo>,
+	blockTypes: ReadonlyMap<string, BlockTypeInfo>,
+	blockVersions: ReadonlyMap<string, readonly UrlValueField[]>,
+	property: "fields" | "data",
+): ValueIssue[] {
+	const issues: ValueIssue[] = [];
+	for (const [slug, info] of fields) {
+		const value = values[slug];
+		if (info.type === "url") {
+			if (typeof value === "string" && !isSafeUrlFieldWriteValue(value)) {
+				issues.push(urlMismatch(property, slug));
+			}
+			continue;
+		}
+		if (info.type === "repeater") {
+			const descriptors: UrlValueField[] = [
+				{ slug, type: "repeater", urlSubFields: info.urlSubFields },
+			];
+			for (const path of unsafeUrlFields(values, descriptors, property)) {
+				issues.push(urlMismatch(property, path.slice(property.length + 1)));
+			}
+			continue;
+		}
+		if (info.type !== "blocks") continue;
+		for (const [index, block] of (arrayValue(value) ?? []).entries()) {
+			if (!isPlainObject(block) || typeof block._type !== "string") continue;
+			const type = blockTypes.get(block._type);
+			if (!type) continue;
+			const version =
+				typeof block._version === "number" && Number.isInteger(block._version)
+					? block._version
+					: type.currentVersion;
+			const descriptors = blockVersions.get(`${type.id}:${version}`) ?? [];
+			for (const path of unsafeUrlFields(block, descriptors, `${slug}.${index}`)) {
+				issues.push(urlMismatch(property, path));
+			}
+		}
+	}
+	return issues;
+}
+
 /**
  * Entry field values against the target column each field is stored in,
  * through the shared column codec: a value the codec cannot encode for the
@@ -178,8 +276,13 @@ export function checkEntryFields(
 	entry: EntryRecord,
 	fields: ReadonlyMap<string, FieldInfo>,
 	dialect: TargetDialect,
+	blockTypes: ReadonlyMap<string, BlockTypeInfo> = new Map(),
+	blockVersions: ReadonlyMap<string, readonly UrlValueField[]> = new Map(),
 ): ValueCheckResult {
-	const result: ValueCheckResult = { issues: [], float4Rounded: 0 };
+	const result: ValueCheckResult = {
+		issues: checkContentUrlFields(entry.fields, fields, blockTypes, blockVersions, "fields"),
+		float4Rounded: 0,
+	};
 	for (const [slug, value] of Object.entries(entry.fields)) {
 		const info = fields.get(slug);
 		if (!info) {

package/src/transfer/analyze/write-rules.ts

@@ -9,6 +9,7 @@ import { safeHref } from "../../api/schemas/menus.js";
 import { createRedirectBody } from "../../api/schemas/redirects.js";
 import { coerceFieldValue } from "../../database/repositories/byline.js";
 import { EmDashValidationError } from "../../database/repositories/types.js";
+import { isSiteRelativeDestination } from "../../redirects/destination.js";
 import { isPattern, validateDestinationParams, validatePattern } from "../../redirects/patterns.js";
 import { isTerminalStatus } from "../../redirects/status.js";
 import { validateBlockFields } from "../../schema/block-type-contract.js";
@@ -60,6 +61,13 @@ function redirectIssues(record: RedirectRecord): ValueIssue[] {
 			if (properties.has(property)) issues.push(rejected(property, message));
 		}
 	}
+	if (
+		!isTerminalStatus(record.type) &&
+		!isSiteRelativeDestination(record.destination) &&
+		!issues.some((issue) => issue.property === "destination")
+	) {
+		issues.push(rejected("destination", REDIRECT_BODY_MESSAGES.destination));
+	}
 	const pattern = isPattern(record.source);
 	if (record.isPattern !== pattern) {
 		issues.push(rejected("isPattern", "Redirect pattern flag does not match its source"));

package/src/utils/url.ts

@@ -16,7 +16,26 @@
  * - Protocol-relative URLs are NOT allowed (starting with //) as they can
  *   redirect to attacker-controlled hosts.
  */
-const SAFE_URL_SCHEME_RE = /^(https?:|mailto:|tel:|\/(?!\/)|#)/i;
+const SAFE_ABSOLUTE_URL_RE = /^(https?:|mailto:|tel:)/i;
+const SITE_RELATIVE_HREF_RE = /^(\/(?![/\\])|#)/;
+const URL_SCHEME_RE = /^([a-z][a-z0-9+.-]*):/i;
+const URL_BASE = new URL("https://emdash.invalid/");
+
+function containsHrefControl(value: string): boolean {
+	for (const character of value) {
+		const codePoint = character.codePointAt(0);
+		if (codePoint !== undefined && (codePoint <= 0x1f || codePoint === 0x7f)) return true;
+	}
+	return false;
+}
+
+function resolvesOnSite(value: string): boolean {
+	try {
+		return new URL(value, URL_BASE).origin === URL_BASE.origin;
+	} catch {
+		return false;
+	}
+}
 
 /**
  * Returns the URL unchanged if it uses a safe scheme, otherwise returns "#".
@@ -37,12 +56,48 @@ const SAFE_URL_SCHEME_RE = /^(https?:|mailto:|tel:|\/(?!\/)|#)/i;
  */
 export function sanitizeHref(url: string | undefined | null): string {
 	if (!url) return "#";
-	return SAFE_URL_SCHEME_RE.test(url) ? url : "#";
+	return isSafeHref(url) ? url : "#";
 }
 
 /**
  * Returns true if the URL uses a safe scheme for rendering in href attributes.
  */
 export function isSafeHref(url: string): boolean {
-	return SAFE_URL_SCHEME_RE.test(url);
+	if (containsHrefControl(url)) return false;
+	if (SAFE_ABSOLUTE_URL_RE.test(url)) return URL.canParse(url);
+	return SITE_RELATIVE_HREF_RE.test(url) && resolvesOnSite(url);
+}
+
+const ALLOWED_URL_SCHEMES = new Set(["http", "https", "mailto", "tel"]);
+
+/**
+ * Returns true if the value names a URL scheme other than http, https,
+ * mailto, or tel, as a browser would resolve it in an href.
+ */
+export function hasUnsafeUrlScheme(value: string): boolean {
+	const stripped = value.replace(/[\t\n\r]/g, "").trimStart();
+	const scheme = URL_SCHEME_RE.exec(stripped)?.[1];
+	return scheme !== undefined && !ALLOWED_URL_SCHEMES.has(scheme.toLowerCase());
+}
+
+/**
+ * Returns true when a repository write may keep the value. Repository callers
+ * preserve legacy scheme-less values, but reject anything a browser resolves
+ * off-site or to a script-capable scheme.
+ */
+export function isSafeUrlFieldWriteValue(value: string): boolean {
+	if (containsHrefControl(value) || hasUnsafeUrlScheme(value)) return false;
+	const candidate = value.trimStart();
+	const scheme = URL_SCHEME_RE.exec(candidate)?.[1];
+	if (scheme !== undefined) return ALLOWED_URL_SCHEMES.has(scheme.toLowerCase());
+	return resolvesOnSite(candidate);
+}
+
+/**
+ * Returns true if the value may be stored in a `url` content field: a safe
+ * href per {@link isSafeHref} that is either site-relative or a parseable
+ * absolute URL.
+ */
+export function isSafeUrlFieldValue(value: string): boolean {
+	return isSafeHref(value);
 }

package/src/virtual-modules.d.ts

@@ -22,6 +22,9 @@ declare module "virtual:emdash/config" {
 		authProviders?: AuthProviderDescriptor[];
 		i18n?: I18nConfig | null;
 		toolbar?: "server" | "client" | false;
+		/** Whether an object-cache adapter was configured at build time. */
+		objectCacheEnabled?: boolean;
+		updateCheck?: boolean | { minimumReleaseAge?: string | number };
 		/** Public origin from astro.config.mjs, origin-normalized at startup. */
 		siteUrl?: string;
 		astroCspEnabled?: boolean;

package/dist/action-token-CbKDcPJi.mjs

@@ -1,26 +0,0 @@
-import { r as verifyPreviewToken, t as generatePreviewToken } from "./tokens-BojXlk49.mjs";
-
-//#region src/visual-editing/action-token.ts
-const VISUAL_ACTION_SECRET_DOMAIN = "emdash:visual-editing-action:v1:";
-const VISUAL_ACTION_TOKEN_INVALID = "VISUAL_ACTION_TOKEN_INVALID";
-function visualActionSecret(previewSecret) {
-	return `${VISUAL_ACTION_SECRET_DOMAIN}${previewSecret}`;
-}
-function generateVisualEditingActionToken(previewSecret, userId) {
-	return generatePreviewToken({
-		contentId: `visual-editing:${userId}`,
-		expiresIn: "5m",
-		secret: visualActionSecret(previewSecret)
-	});
-}
-async function verifyVisualEditingActionToken(token, previewSecret, userId) {
-	const verification = await verifyPreviewToken({
-		token,
-		secret: visualActionSecret(previewSecret)
-	});
-	return verification.valid && verification.payload.cid === `visual-editing:${userId}`;
-}
-
-//#endregion
-export { generateVisualEditingActionToken as n, verifyVisualEditingActionToken as r, VISUAL_ACTION_TOKEN_INVALID as t };
-//# sourceMappingURL=action-token-CbKDcPJi.mjs.map

package/dist/action-token-CbKDcPJi.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"action-token-CbKDcPJi.mjs","names":[],"sources":["../src/visual-editing/action-token.ts"],"sourcesContent":["import { generatePreviewToken, verifyPreviewToken } from \"../preview/tokens.js\";\n\nconst VISUAL_ACTION_SECRET_DOMAIN = \"emdash:visual-editing-action:v1:\";\nexport const VISUAL_ACTION_TOKEN_INVALID = \"VISUAL_ACTION_TOKEN_INVALID\";\n\nfunction visualActionSecret(previewSecret: string): string {\n\treturn `${VISUAL_ACTION_SECRET_DOMAIN}${previewSecret}`;\n}\n\nexport function generateVisualEditingActionToken(\n\tpreviewSecret: string,\n\tuserId: string,\n): Promise<string> {\n\treturn generatePreviewToken({\n\t\tcontentId: `visual-editing:${userId}`,\n\t\texpiresIn: \"5m\",\n\t\tsecret: visualActionSecret(previewSecret),\n\t});\n}\n\nexport async function verifyVisualEditingActionToken(\n\ttoken: string,\n\tpreviewSecret: string,\n\tuserId: string,\n): Promise<boolean> {\n\tconst verification = await verifyPreviewToken({\n\t\ttoken,\n\t\tsecret: visualActionSecret(previewSecret),\n\t});\n\treturn verification.valid && verification.payload.cid === `visual-editing:${userId}`;\n}\n"],"mappings":";;;AAEA,MAAM,8BAA8B;AACpC,MAAa,8BAA8B;AAE3C,SAAS,mBAAmB,eAA+B;AAC1D,QAAO,GAAG,8BAA8B;;AAGzC,SAAgB,iCACf,eACA,QACkB;AAClB,QAAO,qBAAqB;EAC3B,WAAW,kBAAkB;EAC7B,WAAW;EACX,QAAQ,mBAAmB,cAAc;EACzC,CAAC;;AAGH,eAAsB,+BACrB,OACA,eACA,QACmB;CACnB,MAAM,eAAe,MAAM,mBAAmB;EAC7C;EACA,QAAQ,mBAAmB,cAAc;EACzC,CAAC;AACF,QAAO,aAAa,SAAS,aAAa,QAAQ,QAAQ,kBAAkB"}

package/dist/activation-PtniBLt9.mjs

@@ -1,382 +0,0 @@
-import { u as isPostgres, y as tableExists } from "./dialect-helpers-7_IqPdh9.mjs";
-import { n as verifyMediaUsageCaptureTriggers, t as installMediaUsageCaptureTriggers } from "./capture-triggers-DJEoOTOq.mjs";
-import { sql } from "kysely";
-import { ulid } from "ulidx";
-
-//#region src/media/usage/activation.ts
-const ACTIVATION_KEY = "incremental_capture";
-const ACTIVATION_ERROR_CODE = "MEDIA_USAGE_ACTIVATION_FAILED";
-const MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION = 1;
-var MediaUsageActivationVersionMismatchError = class extends Error {};
-const MEDIA_USAGE_ACTIVATION_LIMITS = Object.freeze({
-	collectionsPerCall: 1,
-	leaseDurationSeconds: 300
-});
-async function getMediaUsageActivationStatus(db) {
-	const activation = await db.selectFrom("_emdash_media_usage_activation").select([
-		"state",
-		"runtime_generation",
-		"collection_cursor",
-		"drain_confirmed_at",
-		"lease_expires_at",
-		"attempt_count",
-		"last_attempted_at",
-		"last_error_code",
-		"activated_at",
-		"updated_at"
-	]).where("task_key", "=", ACTIVATION_KEY).executeTakeFirstOrThrow();
-	assertRuntimeGeneration(activation);
-	if (activation.state !== "expanded" && activation.state !== "activating" && activation.state !== "active") throw new Error("Invalid media usage activation state");
-	if (!Number.isInteger(activation.attempt_count) || activation.attempt_count < 0) throw new Error("Invalid media usage activation attempt count");
-	return {
-		state: activation.state,
-		collectionCursor: activation.collection_cursor,
-		attemptCount: activation.attempt_count,
-		drainConfirmedAt: activation.drain_confirmed_at,
-		lastAttemptedAt: activation.last_attempted_at,
-		lastErrorCode: activation.last_error_code === null ? null : ACTIVATION_ERROR_CODE,
-		leaseExpiresAt: activation.lease_expires_at,
-		activatedAt: activation.activated_at,
-		updatedAt: activation.updated_at
-	};
-}
-async function canResumeMediaUsageCollectionCapture(db, identity) {
-	const activation = await findActivationIfAvailable(db);
-	if (!activation) return false;
-	assertRuntimeGeneration(activation);
-	if (activation.state !== "active") return false;
-	const lifecycle = await db.selectFrom("_emdash_media_usage_index_status").select(["collection_id", "cursor"]).where("adapter_id", "=", "content-media").where("scope_type", "=", "collection").where("scope_key", "=", identity.collectionSlug).where("collection_id", "=", identity.collectionId).where("capture_state", "in", ["installing", "ready"]).executeTakeFirst();
-	return lifecycle?.collection_id === identity.collectionId && (identity.creationFingerprint ? lifecycle.cursor === identity.creationFingerprint : lifecycle.cursor === null);
-}
-async function prepareMediaUsageCollectionCapture(db, input) {
-	const activation = await findActivationIfAvailable(db);
-	if (!activation) return {
-		captureRequired: false,
-		collectionId: input.collectionId,
-		registrationExists: input.registeredCollectionId !== void 0,
-		resuming: false
-	};
-	assertRuntimeGeneration(activation);
-	if (activation.state !== "active") return {
-		captureRequired: false,
-		collectionId: input.collectionId,
-		registrationExists: input.registeredCollectionId !== void 0,
-		resuming: false
-	};
-	const existing = await db.selectFrom("_emdash_media_usage_index_status").select([
-		"collection_id",
-		"capture_state",
-		"cursor"
-	]).where("adapter_id", "=", "content-media").where("scope_type", "=", "collection").where("scope_key", "=", input.collectionSlug).executeTakeFirst();
-	if (existing) {
-		if (existing.collection_id && (existing.capture_state === "installing" || existing.capture_state === "ready") && (input.creationFingerprint ? existing.cursor === input.creationFingerprint : existing.cursor === null) && (input.registeredCollectionId === void 0 || input.registeredCollectionId === existing.collection_id)) return {
-			captureRequired: true,
-			collectionId: existing.collection_id,
-			registrationExists: input.registeredCollectionId !== void 0,
-			resuming: true
-		};
-		throw new Error("Media usage collection lifecycle identity conflict");
-	}
-	if (input.registeredCollectionId !== void 0) throw new Error("Media usage collection lifecycle is missing");
-	await db.insertInto("_emdash_media_usage_index_status").values({
-		adapter_id: "content-media",
-		scope_type: "collection",
-		scope_key: input.collectionSlug,
-		status: "never",
-		collection_id: input.collectionId,
-		reconciliation_required: 1,
-		capture_state: "installing",
-		cursor: input.creationFingerprint ?? null,
-		updated_at: timestampOffset(db, 0)
-	}).execute();
-	return {
-		captureRequired: true,
-		collectionId: input.collectionId,
-		registrationExists: false,
-		resuming: false
-	};
-}
-async function installPreparedMediaUsageCollectionCapture(db, identity) {
-	await installMediaUsageCaptureTriggers(db, identity, { replaceExisting: false });
-	if (!await verifyMediaUsageCaptureTriggers(db, identity)) throw new Error("Media usage capture trigger verification failed");
-}
-async function markMediaUsageCollectionCaptureReady(db, identity) {
-	const result = await db.updateTable("_emdash_media_usage_index_status").set({
-		capture_state: "ready",
-		updated_at: timestampOffset(db, 0)
-	}).where("adapter_id", "=", "content-media").where("scope_type", "=", "collection").where("scope_key", "=", identity.collectionSlug).where("collection_id", "=", identity.collectionId).where("capture_state", "in", ["installing", "ready"]).where(sql`EXISTS (
-				SELECT 1 FROM _emdash_media_usage_activation AS activation
-				WHERE activation.task_key = ${ACTIVATION_KEY}
-					AND activation.state = 'active'
-					AND activation.runtime_generation = ${MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION}
-			)`).executeTakeFirst();
-	if (Number(result.numUpdatedRows ?? 0) === 0) throw new Error("Media usage collection readiness lost its fence");
-}
-async function finalizeMediaUsageCollectionCapture(db, identity) {
-	const result = await db.updateTable("_emdash_media_usage_index_status").set({
-		capture_state: "active",
-		cursor: null,
-		updated_at: timestampOffset(db, 0)
-	}).where("adapter_id", "=", "content-media").where("scope_type", "=", "collection").where("scope_key", "=", identity.collectionSlug).where("collection_id", "=", identity.collectionId).where("capture_state", "=", "ready").where(sql`EXISTS (
-				SELECT 1 FROM _emdash_collections AS collection
-				WHERE collection.id = ${identity.collectionId}
-					AND collection.slug = ${identity.collectionSlug}
-			)`).where(sql`EXISTS (
-				SELECT 1 FROM _emdash_media_usage_activation AS activation
-				WHERE activation.task_key = ${ACTIVATION_KEY}
-					AND activation.state = 'active'
-					AND activation.runtime_generation = ${MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION}
-			)`).executeTakeFirst();
-	if (Number(result.numUpdatedRows ?? 0) === 0) throw new Error("Media usage collection activation lost its fence");
-}
-async function activateMediaUsageCapture(db, input) {
-	if (input.writersDrained !== true) throw new Error("Media usage activation requires confirmation that writers are drained");
-	return advanceMediaUsageActivation(db, "confirmed");
-}
-async function continueMediaUsageActivation(db) {
-	return advanceMediaUsageActivation(db, "background");
-}
-async function advanceMediaUsageActivation(db, mode) {
-	const before = await findActivation(db);
-	assertRuntimeGeneration(before);
-	if (before.state === "active") return {
-		outcome: "active",
-		processedCollections: 0
-	};
-	if (mode === "background") {
-		if (before.state === "expanded" || before.drain_confirmed_at === null) return { outcome: "inactive" };
-		if (before.state !== "activating") throw new Error("Invalid media usage activation state");
-		if (before.last_error_code !== null) return { outcome: "failed" };
-	}
-	const leaseToken = ulid();
-	const lease = await claimActivation(db, leaseToken, mode);
-	if (!lease) return activationClaimLoss(db, mode);
-	let processedCollections = 0;
-	try {
-		const candidates = await findActivationCandidates(db, lease.collection_cursor);
-		for (const collection of candidates.slice(0, MEDIA_USAGE_ACTIVATION_LIMITS.collectionsPerCall)) {
-			await requireActivationLease(db, leaseToken);
-			await prepareCollectionForActivation(db, collection, leaseToken);
-			await requireActivationLease(db, leaseToken);
-			await installMediaUsageCaptureTriggers(db, {
-				collectionId: collection.id,
-				collectionSlug: collection.slug
-			}, { replaceExisting: false });
-			await requireActivationLease(db, leaseToken);
-			if (!await verifyMediaUsageCaptureTriggers(db, {
-				collectionId: collection.id,
-				collectionSlug: collection.slug
-			})) throw new Error("Media usage capture trigger verification failed");
-			if (!await activateCollectionLifecycle(db, collection, leaseToken)) throw new Error("Media usage collection activation lost its fence");
-			processedCollections++;
-		}
-		const collectionCursor = candidates[Math.min(processedCollections, candidates.length) - 1]?.slug ?? lease.collection_cursor;
-		if (candidates.length > MEDIA_USAGE_ACTIVATION_LIMITS.collectionsPerCall) {
-			if (!await releaseActivationBatch(db, leaseToken, collectionCursor)) throw new Error("Media usage activation cursor lost its fence");
-			return {
-				outcome: "activating",
-				processedCollections,
-				collectionCursor
-			};
-		}
-		if (await findIncompleteCollection(db)) {
-			if (!await releaseActivationBatch(db, leaseToken, null)) throw new Error("Media usage activation restart lost its fence");
-			return {
-				outcome: "activating",
-				processedCollections,
-				collectionCursor: null
-			};
-		}
-		if (!await finalizeActivation(db, leaseToken, collectionCursor)) throw new Error("Media usage activation finalization lost its fence");
-		return {
-			outcome: "active",
-			processedCollections
-		};
-	} catch (error) {
-		if (!await activationLeaseIsLive(db, leaseToken)) return {
-			outcome: "conflict",
-			processedCollections
-		};
-		await recordActivationFailure(db, leaseToken);
-		throw new Error("Media usage activation failed", { cause: error });
-	}
-}
-async function findActivation(db) {
-	return db.selectFrom("_emdash_media_usage_activation").selectAll().where("task_key", "=", ACTIVATION_KEY).executeTakeFirstOrThrow();
-}
-async function findActivationIfAvailable(db) {
-	if (!await tableExists(db, "_emdash_media_usage_activation")) return null;
-	return findActivation(db);
-}
-function assertRuntimeGeneration(activation) {
-	if (activation.runtime_generation !== MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION) throw new MediaUsageActivationVersionMismatchError("Media usage activation runtime generation mismatch");
-}
-async function claimActivation(db, leaseToken, mode) {
-	const now = timestampOffset(db, 0);
-	const claimValues = {
-		lease_token: leaseToken,
-		lease_expires_at: timestampOffset(db, MEDIA_USAGE_ACTIVATION_LIMITS.leaseDurationSeconds),
-		attempt_count: sql`attempt_count + 1`,
-		last_attempted_at: now,
-		updated_at: now
-	};
-	let claim = db.updateTable("_emdash_media_usage_activation").set(mode === "confirmed" ? {
-		...claimValues,
-		state: "activating",
-		drain_confirmed_at: now,
-		last_error_code: null
-	} : claimValues).where("task_key", "=", ACTIVATION_KEY).where("runtime_generation", "=", MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION);
-	if (mode === "confirmed") claim = claim.where((eb) => eb.or([eb("state", "=", "expanded"), eb.and([eb("state", "=", "activating"), eb.or([eb("lease_token", "is", null), eb.and([eb("lease_expires_at", "is not", null), timestampIsDue(db, "lease_expires_at")])])])]));
-	else claim = claim.where("state", "=", "activating").where("drain_confirmed_at", "is not", null).where("last_error_code", "is", null).where((eb) => eb.or([eb("lease_token", "is", null), eb.and([eb("lease_expires_at", "is not", null), timestampIsDue(db, "lease_expires_at")])]));
-	return await claim.returningAll().executeTakeFirst() ?? null;
-}
-async function activationClaimLoss(db, mode) {
-	const current = await findActivation(db);
-	assertRuntimeGeneration(current);
-	if (current.state === "active") return {
-		outcome: "active",
-		processedCollections: 0
-	};
-	if (mode === "background") {
-		if (current.state === "expanded" || current.drain_confirmed_at === null) return { outcome: "inactive" };
-		if (current.state === "activating" && current.last_error_code !== null) return { outcome: "failed" };
-	}
-	if (current.state === "activating" && current.lease_token && current.lease_expires_at && await activationLeaseIsLive(db, current.lease_token)) return {
-		outcome: "lease_active",
-		leaseExpiresAt: current.lease_expires_at
-	};
-	if (mode === "background" && current.state === "activating") return {
-		outcome: "conflict",
-		processedCollections: 0
-	};
-	throw new Error("Media usage activation state is not claimable");
-}
-async function activationLeaseIsLive(db, leaseToken) {
-	return await db.selectFrom("_emdash_media_usage_activation").select("task_key").where("task_key", "=", ACTIVATION_KEY).where("state", "=", "activating").where("runtime_generation", "=", MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION).where("lease_token", "=", leaseToken).where("lease_expires_at", "is not", null).where(timestampIsLive(db, "lease_expires_at")).executeTakeFirst() !== void 0;
-}
-async function findActivationCandidates(db, collectionCursor) {
-	let query = db.selectFrom("_emdash_collections").select(["id", "slug"]);
-	if (collectionCursor) query = query.where("slug", ">", collectionCursor);
-	return query.orderBy("slug", "asc").limit(MEDIA_USAGE_ACTIVATION_LIMITS.collectionsPerCall + 1).execute();
-}
-async function prepareCollectionForActivation(db, collection, leaseToken) {
-	const now = timestampOffset(db, 0);
-	const existingStatus = sql.ref("_emdash_media_usage_index_status.status");
-	const existingCompletedAt = sql.ref("_emdash_media_usage_index_status.completed_at");
-	const existingCollectionId = sql.ref("_emdash_media_usage_index_status.collection_id");
-	const existingCaptureState = sql.ref("_emdash_media_usage_index_status.capture_state");
-	if ((await db.insertInto("_emdash_media_usage_index_status").values({
-		adapter_id: "content-media",
-		scope_type: "collection",
-		scope_key: collection.slug,
-		status: "never",
-		collection_id: collection.id,
-		reconciliation_required: 1,
-		capture_state: "installing",
-		updated_at: now
-	}).onConflict((conflict) => conflict.columns([
-		"adapter_id",
-		"scope_type",
-		"scope_key"
-	]).doUpdateSet({
-		status: sql`CASE WHEN ${existingStatus} IN ('complete', 'running') THEN 'stale' ELSE ${existingStatus} END`,
-		completed_at: sql`CASE WHEN ${existingStatus} IN ('complete', 'running') THEN NULL ELSE ${existingCompletedAt} END`,
-		cursor: null,
-		collection_id: collection.id,
-		reconciliation_required: 1,
-		capture_state: "installing",
-		updated_at: now
-	}).where((eb) => eb.and([
-		eb.or([eb(existingCollectionId, "is", null), eb(existingCollectionId, "=", collection.id)]),
-		eb.or([eb(existingCaptureState, "is", null), eb(existingCaptureState, "!=", "deleting")]),
-		activeActivationLease(db, leaseToken)
-	]))).returning("collection_id").executeTakeFirst())?.collection_id !== collection.id) throw new Error("Media usage collection lifecycle identity conflict");
-}
-async function requireActivationLease(db, leaseToken) {
-	if (!await activationLeaseIsLive(db, leaseToken)) throw new Error("Media usage activation lease is no longer live");
-}
-async function activateCollectionLifecycle(db, collection, leaseToken) {
-	const result = await db.updateTable("_emdash_media_usage_index_status").set({
-		capture_state: "active",
-		updated_at: timestampOffset(db, 0)
-	}).where("adapter_id", "=", "content-media").where("scope_type", "=", "collection").where("scope_key", "=", collection.slug).where("collection_id", "=", collection.id).where("capture_state", "=", "installing").where(sql`EXISTS (
-				SELECT 1 FROM _emdash_collections AS collection
-				WHERE collection.id = ${collection.id}
-					AND collection.slug = ${collection.slug}
-			)`).where(activeActivationLease(db, leaseToken)).executeTakeFirst();
-	return Number(result.numUpdatedRows ?? 0) > 0;
-}
-async function releaseActivationBatch(db, leaseToken, collectionCursor) {
-	const result = await db.updateTable("_emdash_media_usage_activation").set({
-		collection_cursor: collectionCursor,
-		lease_token: null,
-		lease_expires_at: null,
-		updated_at: timestampOffset(db, 0)
-	}).where("task_key", "=", ACTIVATION_KEY).where("state", "=", "activating").where("runtime_generation", "=", MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION).where("lease_token", "=", leaseToken).where("lease_expires_at", "is not", null).where(timestampIsLive(db, "lease_expires_at")).executeTakeFirst();
-	return Number(result.numUpdatedRows ?? 0) > 0;
-}
-async function findIncompleteCollection(db) {
-	return await db.selectFrom("_emdash_collections as collection").select(["collection.id", "collection.slug"]).where((eb) => eb.not(eb.exists(eb.selectFrom("_emdash_media_usage_index_status as status").select("status.scope_key").where("status.adapter_id", "=", "content-media").where("status.scope_type", "=", "collection").whereRef("status.scope_key", "=", "collection.slug").whereRef("status.collection_id", "=", "collection.id").where("status.capture_state", "=", "active")))).orderBy("collection.slug", "asc").limit(1).executeTakeFirst() ?? null;
-}
-async function finalizeActivation(db, leaseToken, collectionCursor) {
-	const now = timestampOffset(db, 0);
-	const result = await db.updateTable("_emdash_media_usage_activation").set({
-		state: "active",
-		collection_cursor: collectionCursor,
-		lease_token: null,
-		lease_expires_at: null,
-		last_error_code: null,
-		activated_at: now,
-		updated_at: now
-	}).where("task_key", "=", ACTIVATION_KEY).where("state", "=", "activating").where("runtime_generation", "=", MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION).where("lease_token", "=", leaseToken).where("lease_expires_at", "is not", null).where(timestampIsLive(db, "lease_expires_at")).where(sql`NOT EXISTS (
-				SELECT 1
-				FROM _emdash_collections AS collection
-				WHERE NOT EXISTS (
-					SELECT 1
-					FROM _emdash_media_usage_index_status AS status
-					WHERE status.adapter_id = 'content-media'
-						AND status.scope_type = 'collection'
-						AND status.scope_key = collection.slug
-						AND status.collection_id = collection.id
-						AND status.capture_state = 'active'
-				)
-			)`).executeTakeFirst();
-	return Number(result.numUpdatedRows ?? 0) > 0;
-}
-async function recordActivationFailure(db, leaseToken) {
-	await db.updateTable("_emdash_media_usage_activation").set({
-		lease_token: null,
-		lease_expires_at: null,
-		last_error_code: ACTIVATION_ERROR_CODE,
-		updated_at: timestampOffset(db, 0)
-	}).where("task_key", "=", ACTIVATION_KEY).where("state", "=", "activating").where("runtime_generation", "=", MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION).where("lease_token", "=", leaseToken).execute();
-}
-function activeActivationLease(db, leaseToken) {
-	return sql`EXISTS (
-		SELECT 1
-		FROM _emdash_media_usage_activation AS activation
-		WHERE activation.task_key = ${ACTIVATION_KEY}
-			AND activation.state = 'activating'
-			AND activation.runtime_generation = ${MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION}
-			AND activation.lease_token = ${leaseToken}
-			AND activation.lease_expires_at IS NOT NULL
-			AND ${timestampIsLive(db, "activation.lease_expires_at")}
-	)`;
-}
-function timestampIsDue(db, column) {
-	return isPostgres(db) ? sql`${sql.ref(column)}::timestamptz <= clock_timestamp()` : sql`${sql.ref(column)} <= strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
-}
-function timestampIsLive(db, column) {
-	return isPostgres(db) ? sql`${sql.ref(column)}::timestamptz > clock_timestamp()` : sql`${sql.ref(column)} > strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
-}
-function timestampOffset(db, seconds) {
-	if (isPostgres(db)) return sql`to_char(
-			clock_timestamp() AT TIME ZONE 'UTC' + (${seconds} * interval '1 second'),
-			'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"'
-		)`;
-	return sql`strftime('%Y-%m-%dT%H:%M:%fZ', 'now', ${`+${seconds} seconds`})`;
-}
-
-//#endregion
-export { continueMediaUsageActivation as a, installPreparedMediaUsageCollectionCapture as c, canResumeMediaUsageCollectionCapture as i, markMediaUsageCollectionCaptureReady as l, MediaUsageActivationVersionMismatchError as n, finalizeMediaUsageCollectionCapture as o, activateMediaUsageCapture as r, getMediaUsageActivationStatus as s, MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION as t, prepareMediaUsageCollectionCapture as u };
-//# sourceMappingURL=activation-PtniBLt9.mjs.map