@fedify/fedify 2.4.0-dev.1668 → 2.4.0-dev.1740

package/dist/{middleware-DzIUFRO2.cjs → federation-BJBpt_Am.cjs}

@@ -1,11 +1,10 @@
 const { URLPattern } = require("urlpattern-polyfill");
-const require_chunk = require("./chunk-Czpeue4M.cjs");
-const require_transformers = require("./transformers-DGwl-hD1.cjs");
-const require_http = require("./http-BpT5cE6r.cjs");
-const require_temporal_polyfill = require("./temporal-polyfill-BCdTHexd.cjs");
-const require_proof = require("./proof-a60oVJ_4.cjs");
-const require_types = require("./types-CPym83zc.cjs");
-const require_kv_cache = require("./kv-cache-zmgG1HUp.cjs");
+const require_rolldown_runtime = require("./rolldown-runtime-Dmm3t92W.cjs");
+const require_transformers = require("./transformers-BalCrSsr.cjs");
+const require_http = require("./http-DggG1scN.cjs");
+const require_proof = require("./proof-Cqk2TcLX.cjs");
+const require_types = require("./types-RXm5YxpC.cjs");
+const require_kv_cache = require("./kv-cache-C4U_uBqD.cjs");
 let _logtape_logtape = require("@logtape/logtape");
 let _fedify_uri_template = require("@fedify/uri-template");
 let _fedify_vocab = require("@fedify/vocab");
@@ -15,7 +14,7 @@ let es_toolkit = require("es-toolkit");
 let _fedify_vocab_runtime = require("@fedify/vocab-runtime");
 let _opentelemetry_semantic_conventions = require("@opentelemetry/semantic-conventions");
 let _fedify_vocab_runtime_jsonld = require("@fedify/vocab-runtime/jsonld");
-_fedify_vocab_runtime_jsonld = require_chunk.__toESM(_fedify_vocab_runtime_jsonld, 1);
+_fedify_vocab_runtime_jsonld = require_rolldown_runtime.__toESM(_fedify_vocab_runtime_jsonld, 1);
 let _fedify_webfinger = require("@fedify/webfinger");
 let _opentelemetry_sdk_metrics = require("@opentelemetry/sdk-metrics");
 let devalue = require("devalue");
@@ -144,6 +143,8 @@ var FederationBuilderImpl = class {
 		f.webFingerLinksDispatcher = this.webFingerLinksDispatcher;
 		f.objectCallbacks = { ...this.objectCallbacks };
 		f.objectTypeIds = { ...this.objectTypeIds };
+		f.collectionCallbacks = { ...this.collectionCallbacks };
+		f.collectionTypeIds = { ...this.collectionTypeIds };
 		f.inboxPath = this.inboxPath;
 		f.outboxPath = this.outboxPath;
 		f.inboxCallbacks = this.inboxCallbacks == null ? void 0 : { ...this.inboxCallbacks };
@@ -723,8 +724,14 @@ function createFederationBuilder() {
 }
 //#endregion
 //#region src/federation/circuit-breaker.ts
-const Temporal$7 = require_temporal_polyfill.Temporal;
-const MAX_CUSTOM_FAILURE_HISTORY = 100;
+const Temporal$9 = require_http.Temporal;
+const LEGACY_SWEEP_MARKER = ["__fedify_meta", "circuit_breaker_state_ttl_sweep_v1"];
+const LEGACY_SWEEP_DELETING_MARKER = { __fedifyDeletingCircuitBreakerLegacyState: true };
+const CIRCUIT_BREAKER_STATE_VERSION = 1;
+const LEGACY_SWEEP_LOCK_TTL = Temporal$9.Duration.from({ minutes: 5 });
+const LEGACY_SWEEP_RETRY_WINDOW = Temporal$9.Duration.from({ hours: 168 });
+const LEGACY_SWEEP_WAIT_INTERVAL = 10;
+const LEGACY_SWEEP_CAS_ATTEMPTS = 3;
 /**
 * Tracks reachability state for remote outbox delivery hosts.
 * @since 2.3.0
@@ -734,12 +741,14 @@ var CircuitBreaker = class {
 	#prefix;
 	#options;
 	#now;
+	#legacySweep;
+	#legacySweepDone;
 	#stateChangeObserver;
 	constructor(options) {
 		this.#kv = options.kv;
 		this.#prefix = options.prefix;
 		this.#options = normalizeCircuitBreakerOptions(options.options ?? {});
-		this.#now = options.now ?? (() => Temporal$7.Now.instant());
+		this.#now = options.now ?? (() => Temporal$9.Now.instant());
 		this.#stateChangeObserver = options.stateChangeObserver;
 	}
 	get options() {
@@ -750,9 +759,10 @@ var CircuitBreaker = class {
 		return now.until(this.#capHeldRetryAt(now, heldSince, now.add(delay)));
 	}
 	async beforeSend(remoteHost, message) {
+		this.#sweepLegacyStates();
 		const heldSince = parseHeldSince(message.circuitHeldSince);
 		const now = this.#now();
-		if (heldSince != null && Temporal$7.Instant.compare(heldSince.add(this.#options.heldActivityTtl), now) <= 0) return {
+		if (heldSince != null && Temporal$9.Instant.compare(heldSince.add(this.#options.heldActivityTtl), now) <= 0) return {
 			type: "drop",
 			heldSince
 		};
@@ -764,12 +774,12 @@ var CircuitBreaker = class {
 				probe: false
 			};
 			if (oldState.state === "half-open") {
-				const halfOpened = oldState.halfOpened == null ? void 0 : Temporal$7.Instant.from(oldState.halfOpened);
+				const halfOpened = oldState.halfOpened == null ? void 0 : Temporal$9.Instant.from(oldState.halfOpened);
 				if (halfOpened != null) {
 					const staleAt = halfOpened.add(this.#options.recoveryDelay);
-					if (Temporal$7.Instant.compare(now, staleAt) < 0) {
+					if (Temporal$9.Instant.compare(now, staleAt) < 0) {
 						const releaseAt = now.add(this.#options.releaseInterval);
-						const retryAt = Temporal$7.Instant.compare(releaseAt, staleAt) < 0 ? releaseAt : staleAt;
+						const retryAt = Temporal$9.Instant.compare(releaseAt, staleAt) < 0 ? releaseAt : staleAt;
 						const cappedRetryAt = this.#capHeldRetryAt(now, heldSince, retryAt);
 						return {
 							type: "hold",
@@ -791,8 +801,8 @@ var CircuitBreaker = class {
 				lastConflictingState = "half-open";
 				continue;
 			}
-			const probeAt = (oldState.opened == null ? now : Temporal$7.Instant.from(oldState.opened)).add(this.#options.recoveryDelay);
-			if (Temporal$7.Instant.compare(now, probeAt) < 0) {
+			const probeAt = (oldState.opened == null ? now : Temporal$9.Instant.from(oldState.opened)).add(this.#options.recoveryDelay);
+			if (Temporal$9.Instant.compare(now, probeAt) < 0) {
 				const retryAt = this.#capHeldRetryAt(now, heldSince, probeAt);
 				return {
 					type: "hold",
@@ -831,6 +841,7 @@ var CircuitBreaker = class {
 		throw new Error(`Failed to update circuit breaker state for ${remoteHost}`);
 	}
 	async recordSuccess(remoteHost) {
+		this.#sweepLegacyStates();
 		for (let attempt = 0; attempt < 10; attempt++) {
 			const oldState = await this.#get(remoteHost);
 			if (oldState == null) return void 0;
@@ -851,11 +862,12 @@ var CircuitBreaker = class {
 		return await this.recordSuccess(remoteHost);
 	}
 	async recordFailure(remoteHost) {
+		this.#sweepLegacyStates();
 		const now = this.#now();
 		for (let attempt = 0; attempt < 10; attempt++) {
 			const oldState = await this.#get(remoteHost);
 			if (oldState?.state === "open") return void 0;
-			const oldFailures = oldState?.failures.map(Temporal$7.Instant.from) ?? [];
+			const oldFailures = oldState?.failures.map(Temporal$9.Instant.from) ?? [];
 			const failures = this.#options.pruneFailures([...oldFailures, now], now);
 			let newState;
 			let transition;
@@ -898,26 +910,122 @@ var CircuitBreaker = class {
 		}
 	}
 	async getState(remoteHost) {
-		return await this.#get(remoteHost);
+		this.#sweepLegacyStates();
+		return stripStoredCircuitBreakerState(await this.#get(remoteHost));
+	}
+	/**
+	* The currently running background legacy sweep, if any.
+	* @internal
+	*/
+	get pendingSweep() {
+		return this.#legacySweep;
 	}
 	#key(remoteHost) {
 		return [...this.#prefix, remoteHost];
 	}
+	#legacySweepMarkerKey() {
+		return [...this.#prefix, ...LEGACY_SWEEP_MARKER];
+	}
+	#sweepLegacyStates() {
+		if (this.#kv.cas == null) return;
+		if (this.#options.stateTtl == null) return;
+		if (this.#legacySweep != null) return;
+		if (this.#isLegacySweepDone()) return;
+		this.#legacySweep = this.#sweepLegacyStatesImpl().catch((error) => {
+			(0, _logtape_logtape.getLogger)([
+				"fedify",
+				"federation",
+				"circuit"
+			]).warn("Failed to sweep legacy circuit breaker state:\n{error}", { error });
+		}).finally(() => {
+			this.#legacySweep = void 0;
+		});
+	}
+	async #sweepLegacyStatesImpl() {
+		const markerKey = this.#legacySweepMarkerKey();
+		const marker = await this.#acquireLegacySweep(markerKey);
+		if (marker === "done") return;
+		try {
+			for await (const { key, value } of this.#kv.list(this.#prefix)) {
+				if (key.length !== this.#prefix.length + 1) continue;
+				await this.#migrateLegacyState(key, value);
+			}
+		} catch (error) {
+			await this.#deleteIfUnchanged(markerKey, marker);
+			throw error;
+		}
+		const finishedMarker = this.#finishLegacySweepMarker(marker);
+		if (await this.#kv.cas(markerKey, marker, finishedMarker)) this.#rememberLegacySweepMarker(finishedMarker);
+	}
+	#finishLegacySweepMarker(marker) {
+		const retryUntil = getLegacySweepRetryUntil(marker);
+		if (retryUntil != null && Temporal$9.Instant.compare(this.#now(), Temporal$9.Instant.from(retryUntil)) < 0) return {
+			state: "done",
+			retryUntil
+		};
+		return { state: "final" };
+	}
+	async #migrateLegacyState(key, value) {
+		if (isCurrentCircuitBreakerState(value)) return;
+		const state = parseCircuitBreakerKvState(value);
+		if (state != null) {
+			await this.#kv.cas(key, value, markCircuitBreakerState(state), this.#setOptions());
+			return;
+		}
+		await this.#deleteIfUnchanged(key, value);
+	}
+	async #deleteIfUnchanged(key, value) {
+		if (await this.#kv.cas(key, value, LEGACY_SWEEP_DELETING_MARKER, { ttl: LEGACY_SWEEP_LOCK_TTL })) await this.#kv.delete(key);
+	}
+	async #acquireLegacySweep(markerKey) {
+		for (let attempt = 0; attempt < LEGACY_SWEEP_CAS_ATTEMPTS; attempt++) {
+			const marker = await this.#kv.get(markerKey);
+			const now = this.#now();
+			if (isLegacySweepActive(marker, now)) {
+				this.#rememberLegacySweepMarker(marker);
+				return "done";
+			}
+			const retryUntil = isLegacySweepRetryDue(marker, now) ? marker.retryUntil : getLegacySweepRetryUntil(marker) ?? now.add(LEGACY_SWEEP_RETRY_WINDOW).toString();
+			const sweeping = {
+				state: "sweeping",
+				started: now.toString(),
+				retryUntil
+			};
+			if (await this.#kv.cas(markerKey, marker ?? void 0, sweeping, { ttl: LEGACY_SWEEP_LOCK_TTL })) return sweeping;
+			await delay(LEGACY_SWEEP_WAIT_INTERVAL);
+		}
+		return "done";
+	}
+	#isLegacySweepDone() {
+		if (this.#legacySweepDone === "final") return true;
+		if (this.#legacySweepDone == null) return false;
+		if (Temporal$9.Instant.compare(this.#now(), this.#legacySweepDone) < 0) return true;
+		this.#legacySweepDone = void 0;
+		return false;
+	}
+	#rememberLegacySweepMarker(marker) {
+		const doneUntil = getLegacySweepDoneUntil(marker, this.#now());
+		if (doneUntil != null) this.#legacySweepDone = doneUntil;
+	}
 	#capHeldRetryAt(now, heldSince, retryAt) {
 		const expiresAt = (heldSince ?? now).add(this.#options.heldActivityTtl);
-		return Temporal$7.Instant.compare(expiresAt, retryAt) < 0 ? expiresAt : retryAt;
+		return Temporal$9.Instant.compare(expiresAt, retryAt) < 0 ? expiresAt : retryAt;
 	}
 	async #get(remoteHost) {
-		return parseCircuitBreakerKvState(await this.#kv.get(this.#key(remoteHost)));
+		return parseStoredCircuitBreakerKvState(await this.#kv.get(this.#key(remoteHost)));
 	}
 	async #replace(remoteHost, oldState, newState) {
 		const key = this.#key(remoteHost);
+		const storedState = newState == null ? void 0 : markCircuitBreakerState(newState);
 		if (this.#kv.cas == null) {
-			if (newState == null) await this.#kv.delete(key);
-			else await this.#kv.set(key, newState);
+			if (storedState == null) await this.#kv.delete(key);
+			else await this.#kv.set(key, storedState, this.#setOptions());
 			return true;
 		}
-		return await this.#kv.cas(key, oldState, newState);
+		return await this.#kv.cas(key, oldState, storedState, storedState == null ? void 0 : this.#setOptions());
+	}
+	#setOptions() {
+		return this.#options.stateTtl == null ? void 0 : { ttl: this.#options.stateTtl };
 	}
 	async #notifyStateChange(remoteHost, previousState, newState) {
 		try {
@@ -957,18 +1065,25 @@ var CircuitBreaker = class {
 * @param options The public circuit breaker options supplied to Fedify.
 * @returns The normalized failure predicate, failure pruning function,
 * duration values, and optional callbacks with defaults applied.
-* @throws {RangeError} If any configured duration is not positive.
+* @throws {RangeError} If any configured duration is not positive, or if
+* `stateTtl` is shorter than `recoveryDelay`.
 * @throws {TypeError} If `failureThreshold` is not a positive integer.
 */
 function normalizeCircuitBreakerOptions(options) {
 	const recoveryDelay = toInstantDuration(options.recoveryDelay ?? { minutes: 30 });
 	const heldActivityTtl = toInstantDuration(options.heldActivityTtl ?? { hours: 168 });
 	const releaseInterval = toInstantDuration(options.releaseInterval ?? { seconds: 1 });
+	const configuredStateTtl = options.stateTtl == null ? void 0 : toInstantDuration(options.stateTtl);
 	assertPositiveDuration(recoveryDelay, "recoveryDelay");
 	assertPositiveDuration(heldActivityTtl, "heldActivityTtl");
 	assertPositiveDuration(releaseInterval, "releaseInterval");
+	if (configuredStateTtl != null) {
+		assertPositiveDuration(configuredStateTtl, "stateTtl");
+		if (Temporal$9.Duration.compare(configuredStateTtl, recoveryDelay) < 0) throw new RangeError("stateTtl must be at least recoveryDelay.");
+	}
 	let failure;
 	let pruneFailures;
+	let stateTtl;
 	if (options.failure == null) {
 		const failureThreshold = options.failureThreshold ?? 5;
 		if (!Number.isInteger(failureThreshold) || failureThreshold <= 0) throw new TypeError("failureThreshold must be a positive integer.");
@@ -976,17 +1091,19 @@ function normalizeCircuitBreakerOptions(options) {
 		assertPositiveDuration(failureWindow, "failureWindow");
 		pruneFailures = (timestamps, now) => {
 			const earliest = now.subtract(failureWindow);
-			return timestamps.filter((timestamp) => Temporal$7.Instant.compare(timestamp, earliest) >= 0).slice(-failureThreshold);
+			return timestamps.filter((timestamp) => Temporal$9.Instant.compare(timestamp, earliest) >= 0).slice(-failureThreshold);
 		};
 		failure = (timestamps) => {
 			if (timestamps.length < failureThreshold) return false;
 			const first = timestamps[timestamps.length - failureThreshold];
 			const last = timestamps[timestamps.length - 1];
-			return Temporal$7.Duration.compare(first.until(last), failureWindow) <= 0;
+			return Temporal$9.Duration.compare(first.until(last), failureWindow) <= 0;
 		};
+		stateTtl = configuredStateTtl ?? maxDuration(recoveryDelay.add(failureWindow), recoveryDelay.add(heldActivityTtl));
 	} else {
 		failure = options.failure;
-		pruneFailures = (timestamps) => timestamps.slice(-MAX_CUSTOM_FAILURE_HISTORY);
+		pruneFailures = (timestamps) => timestamps.slice(-100);
+		stateTtl = configuredStateTtl;
 	}
 	return {
 		failure,
@@ -994,24 +1111,86 @@ function normalizeCircuitBreakerOptions(options) {
 		recoveryDelay,
 		heldActivityTtl,
 		releaseInterval,
+		stateTtl,
 		onStateChange: options.onStateChange,
 		onActivityDrop: options.onActivityDrop
 	};
 }
+function maxDuration(duration, ...durations) {
+	return durations.reduce((max, candidate) => Temporal$9.Duration.compare(candidate, max) > 0 ? candidate : max, duration);
+}
+function isLegacySweepDone(value, now) {
+	return getLegacySweepDoneUntil(value, now) != null;
+}
+function getLegacySweepDoneUntil(value, now) {
+	if (typeof value !== "object" || value == null || !("state" in value)) return;
+	if (value.state === "final") return "final";
+	if (value.state === "done" && "retryUntil" in value && typeof value.retryUntil === "string") try {
+		const retryUntil = Temporal$9.Instant.from(value.retryUntil);
+		return Temporal$9.Instant.compare(now, retryUntil) < 0 ? retryUntil : void 0;
+	} catch {
+		return;
+	}
+}
+function isLegacySweepRetryDue(value, now) {
+	if (typeof value !== "object" || value == null || !("state" in value) || value.state !== "done" || !("retryUntil" in value) || typeof value.retryUntil !== "string") return false;
+	try {
+		return Temporal$9.Instant.compare(now, Temporal$9.Instant.from(value.retryUntil)) >= 0;
+	} catch {
+		return false;
+	}
+}
+function isLegacySweepActive(value, now) {
+	return isLegacySweepDone(value, now) || isLegacySweepInProgress(value, now);
+}
+function isLegacySweepInProgress(value, now) {
+	if (typeof value !== "object" || value == null || !("state" in value) || value.state !== "sweeping" || !("started" in value) || typeof value.started !== "string") return false;
+	try {
+		return Temporal$9.Instant.compare(now, Temporal$9.Instant.from(value.started).add(LEGACY_SWEEP_LOCK_TTL)) < 0;
+	} catch {
+		return false;
+	}
+}
+function getLegacySweepRetryUntil(value) {
+	if (typeof value !== "object" || value == null || !("retryUntil" in value) || typeof value.retryUntil !== "string") return;
+	try {
+		Temporal$9.Instant.from(value.retryUntil);
+		return value.retryUntil;
+	} catch {
+		return;
+	}
+}
+function isCurrentCircuitBreakerState(value) {
+	return typeof value === "object" && value != null && "__fedifyCircuitBreakerStateVersion" in value && value.__fedifyCircuitBreakerStateVersion === CIRCUIT_BREAKER_STATE_VERSION;
+}
+function markCircuitBreakerState(state) {
+	return {
+		...state,
+		__fedifyCircuitBreakerStateVersion: CIRCUIT_BREAKER_STATE_VERSION
+	};
+}
+function stripStoredCircuitBreakerState(state) {
+	if (state == null) return void 0;
+	const { __fedifyCircuitBreakerStateVersion: _, ...publicState } = state;
+	return publicState;
+}
+function delay(milliseconds) {
+	return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
 function toInstantDuration(duration) {
-	const parsed = Temporal$7.Duration.from(duration);
-	return Temporal$7.Duration.from({ milliseconds: Math.trunc(parsed.total({
+	const parsed = Temporal$9.Duration.from(duration);
+	return Temporal$9.Duration.from({ milliseconds: Math.trunc(parsed.total({
 		unit: "millisecond",
-		relativeTo: Temporal$7.PlainDateTime.from("2026-01-01T00:00:00")
+		relativeTo: Temporal$9.PlainDateTime.from("2026-01-01T00:00:00")
 	})) });
 }
 function assertPositiveDuration(duration, name) {
-	if (Temporal$7.Duration.compare(duration, { seconds: 0 }) <= 0) throw new RangeError(`${name} must be a positive duration.`);
+	if (Temporal$9.Duration.compare(duration, { seconds: 0 }) <= 0) throw new RangeError(`${name} must be a positive duration.`);
 }
 function parseHeldSince(value) {
 	if (value == null) return void 0;
 	try {
-		return Temporal$7.Instant.from(value);
+		return Temporal$9.Instant.from(value);
 	} catch (error) {
 		(0, _logtape_logtape.getLogger)([
 			"fedify",
@@ -1032,10 +1211,13 @@ function parseHeldSince(value) {
 * valid instant strings, or `undefined` when the stored value is malformed.
 */
 function parseCircuitBreakerKvState(value) {
+	return stripStoredCircuitBreakerState(parseStoredCircuitBreakerKvState(value));
+}
+function parseStoredCircuitBreakerKvState(value) {
 	const isInstantString = (v) => {
 		if (typeof v !== "string") return false;
 		try {
-			Temporal$7.Instant.from(v);
+			Temporal$9.Instant.from(v);
 			return true;
 		} catch {
 			return false;
@@ -1051,7 +1233,8 @@ function parseCircuitBreakerKvState(value) {
 		state: record.state,
 		failures: record.failures,
 		...record.opened == null ? {} : { opened: record.opened },
-		...record.halfOpened == null ? {} : { halfOpened: record.halfOpened }
+		...record.halfOpened == null ? {} : { halfOpened: record.halfOpened },
+		...record.__fedifyCircuitBreakerStateVersion === CIRCUIT_BREAKER_STATE_VERSION ? { __fedifyCircuitBreakerStateVersion: CIRCUIT_BREAKER_STATE_VERSION } : {}
 	};
 }
 //#endregion
@@ -1066,7 +1249,7 @@ function parseCircuitBreakerKvState(value) {
 async function digest(uris) {
 	const processed = /* @__PURE__ */ new Set();
 	const encoder = new TextEncoder();
-	const result = new Uint8Array(32);
+	const result = /* @__PURE__ */ new Uint8Array(32);
 	for (const uri of uris) {
 		const u = uri instanceof URL ? uri.href : uri;
 		if (processed.has(u)) continue;
@@ -1095,7 +1278,7 @@ async function buildCollectionSynchronizationHeader(collectionId, actorIds) {
 }
 //#endregion
 //#region src/federation/inbox.ts
-const Temporal$6 = require_temporal_polyfill.Temporal;
+const Temporal$8 = require_http.Temporal;
 async function routeActivity({ context: ctx, json, originalJson, normalizedActivity, ldSignatureVerified, activity, recipient, inboxListeners, inboxContextFactory, listenerInboxContextFactory, inboxErrorHandler, kv, kvPrefixes, queue, span, meterProvider, tracerProvider, idempotencyStrategy }) {
 	const logger = (0, _logtape_logtape.getLogger)([
 		"fedify",
@@ -1242,7 +1425,7 @@ async function routeActivity({ context: ctx, json, originalJson, normalizedActiv
 			return "error";
 		}
 		require_http.recordInboxActivity(meterProvider, "processed", (0, _fedify_vocab.getTypeId)(activity).href);
-		if (cacheKey != null) await kv.set(cacheKey, true, { ttl: Temporal$6.Duration.from({ days: 1 }) });
+		if (cacheKey != null) await kv.set(cacheKey, true, { ttl: Temporal$8.Duration.from({ days: 1 }) });
 		logger.info("Activity {activityId} has been processed.", {
 			activityId: activity.id?.href,
 			activity: json,
@@ -1254,7 +1437,7 @@ async function routeActivity({ context: ctx, json, originalJson, normalizedActiv
 }
 //#endregion
 //#region src/federation/keycache.ts
-const Temporal$5 = require_temporal_polyfill.Temporal;
+const Temporal$7 = require_http.Temporal;
 var KvKeyCache = class {
 	kv;
 	prefix;
@@ -1265,7 +1448,7 @@ var KvKeyCache = class {
 		this.kv = kv;
 		this.prefix = prefix;
 		this.options = options;
-		this.unavailableKeyTtl = options.unavailableKeyTtl ?? Temporal$5.Duration.from({ minutes: 10 });
+		this.unavailableKeyTtl = options.unavailableKeyTtl ?? Temporal$7.Duration.from({ minutes: 10 });
 		this.nullKeys = /* @__PURE__ */ new Map();
 	}
 	#getFetchErrorKey(keyId) {
@@ -1278,13 +1461,13 @@ var KvKeyCache = class {
 	async get(keyId) {
 		const negativeExpiration = this.nullKeys.get(keyId.href);
 		if (negativeExpiration != null) {
-			if (Temporal$5.Now.instant().until(negativeExpiration).sign >= 0) return null;
+			if (Temporal$7.Now.instant().until(negativeExpiration).sign >= 0) return null;
 			this.nullKeys.delete(keyId.href);
 		}
 		const serialized = await this.kv.get([...this.prefix, keyId.href]);
 		if (serialized === void 0) return void 0;
 		if (serialized === null) {
-			this.nullKeys.set(keyId.href, Temporal$5.Now.instant().add(this.unavailableKeyTtl));
+			this.nullKeys.set(keyId.href, Temporal$7.Now.instant().add(this.unavailableKeyTtl));
 			return null;
 		}
 		try {
@@ -1300,7 +1483,7 @@ var KvKeyCache = class {
 	}
 	async set(keyId, key) {
 		if (key == null) {
-			this.nullKeys.set(keyId.href, Temporal$5.Now.instant().add(this.unavailableKeyTtl));
+			this.nullKeys.set(keyId.href, Temporal$7.Now.instant().add(this.unavailableKeyTtl));
 			await this.kv.set([...this.prefix, keyId.href], null, { ttl: this.unavailableKeyTtl });
 			return;
 		}
@@ -1439,7 +1622,7 @@ function acceptsJsonLd(request) {
 }
 //#endregion
 //#region src/federation/temporal.ts
-const Temporal$4 = require_temporal_polyfill.Temporal;
+const Temporal$6 = require_http.Temporal;
 function isPlainObject$1(value) {
 	return typeof value === "object" && value != null && !Array.isArray(value);
 }
@@ -1449,7 +1632,7 @@ function normalizeDateTimeLiteral(value) {
 function isMalformedDateTimeLiteral(value) {
 	if (typeof value !== "string") return false;
 	try {
-		Temporal$4.Instant.from(normalizeDateTimeLiteral(value));
+		Temporal$6.Instant.from(normalizeDateTimeLiteral(value));
 		return false;
 	} catch {
 		return true;
@@ -1458,13 +1641,13 @@ function isMalformedDateTimeLiteral(value) {
 function isMalformedDurationLiteral(value) {
 	if (typeof value !== "string") return false;
 	try {
-		Temporal$4.Duration.from(value);
+		Temporal$6.Duration.from(value);
 		return false;
 	} catch {
 		return true;
 	}
 }
-const TEMPORAL_DATE_TIME_IRIS = new Set([
+const TEMPORAL_DATE_TIME_IRIS = /* @__PURE__ */ new Set([
 	"https://www.w3.org/ns/activitystreams#deleted",
 	"https://www.w3.org/ns/activitystreams#endTime",
 	"https://www.w3.org/ns/activitystreams#published",
@@ -1473,7 +1656,7 @@ const TEMPORAL_DATE_TIME_IRIS = new Set([
 	"http://purl.org/dc/terms/created",
 	"https://w3id.org/security#created"
 ]);
-const TEMPORAL_DURATION_IRIS = new Set(["https://www.w3.org/ns/activitystreams#duration"]);
+const TEMPORAL_DURATION_IRIS = /* @__PURE__ */ new Set(["https://www.w3.org/ns/activitystreams#duration"]);
 const QUESTION_CLOSED_IRI = "https://www.w3.org/ns/activitystreams#closed";
 const XSD_DATE_TIME_IRI = "http://www.w3.org/2001/XMLSchema#dateTime";
 function hasMalformedExpandedDateTimeLiteral(value) {
@@ -1529,7 +1712,7 @@ async function hasMalformedKnownTemporalLiteral(value, contextLoader) {
 }
 //#endregion
 //#region src/federation/handler.ts
-const Temporal$3 = require_temporal_polyfill.Temporal;
+const Temporal$5 = require_http.Temporal;
 const rawInboxContextFactorySymbol = Symbol("fedify.rawInboxContextFactory");
 function isRemoteContextLoadingFailure$1(error) {
 	return error instanceof Error && typeof error.details === "object" && error.details != null && error.details.code === "loading remote context failed";
@@ -1618,7 +1801,7 @@ async function handleObject(request, { values, context, objectDispatcher, author
 		Vary: "Accept"
 	} });
 }
-const BUILT_IN_COLLECTION_METRIC_KINDS = new Set([
+const BUILT_IN_COLLECTION_METRIC_KINDS = /* @__PURE__ */ new Set([
 	"inbox",
 	"outbox",
 	"following",
@@ -1655,13 +1838,13 @@ function recordCollectionMetrics(meterProvider, base, result, options = {}) {
 * @param parameters The parameters for handling the collection.
 * @returns A promise that resolves to an HTTP response.
 */
-async function handleCollection(request, { name: name$1, identifier, uriGetter, filter, filterPredicate, context, collectionCallbacks, tracerProvider, meterProvider, onUnauthorized, onNotFound }) {
-	const spanName = name$1.trim().replace(/\s+/g, "_");
+async function handleCollection(request, { name: name$2, identifier, uriGetter, filter, filterPredicate, context, collectionCallbacks, tracerProvider, meterProvider, onUnauthorized, onNotFound }) {
+	const spanName = name$2.trim().replace(/\s+/g, "_");
 	tracerProvider = tracerProvider ?? _opentelemetry_api.trace.getTracerProvider();
 	const tracer = tracerProvider.getTracer(require_http.name, require_http.version);
 	const cursor = new URL(request.url).searchParams.get("cursor");
 	const metricBase = {
-		kind: getCollectionMetricKind(name$1),
+		kind: getCollectionMetricKind(name$2),
 		page: cursor != null,
 		dispatcher: "built_in"
 	};
@@ -1702,7 +1885,7 @@ async function handleCollection(request, { name: name$1, identifier, uriGetter,
 							span.setStatus({ code: _opentelemetry_api.SpanStatusCode.ERROR });
 							return await onNotFound(request);
 						}
-						const items = filterCollectionItems(page.items, name$1, filterPredicate);
+						const items = filterCollectionItems(page.items, name$2, filterPredicate);
 						itemCount = items.length;
 						span.setAttribute("fedify.collection.items", itemCount);
 						return items;
@@ -1742,7 +1925,7 @@ async function handleCollection(request, { name: name$1, identifier, uriGetter,
 		} else {
 			const uri = new URL(baseUri);
 			uri.searchParams.set("cursor", cursor);
-			const pageOrResponse = await tracer.startActiveSpan(`activitypub.dispatch_collection_page ${name$1}`, {
+			const pageOrResponse = await tracer.startActiveSpan(`activitypub.dispatch_collection_page ${name$2}`, {
 				kind: _opentelemetry_api.SpanKind.SERVER,
 				attributes: {
 					"activitypub.collection.id": uri.href,
@@ -1758,7 +1941,7 @@ async function handleCollection(request, { name: name$1, identifier, uriGetter,
 						span.setStatus({ code: _opentelemetry_api.SpanStatusCode.ERROR });
 						return await onNotFound(request);
 					}
-					const items = filterCollectionItems(page.items, name$1, filterPredicate);
+					const items = filterCollectionItems(page.items, name$2, filterPredicate);
 					itemCount = items.length;
 					span.setAttribute("fedify.collection.items", itemCount);
 					return {
@@ -2813,8 +2996,8 @@ var CustomCollectionHandler = class {
 	* @param CollectionPage The CollectionPage constructor.
 	* @param filterPredicate Optional filter predicate for items.
 	*/
-	constructor(name$2, values, context, callbacks, tracerProvider = _opentelemetry_api.trace.getTracerProvider(), meterProvider, Collection, CollectionPage, filterPredicate) {
-		this.name = name$2;
+	constructor(name$1, values, context, callbacks, tracerProvider = _opentelemetry_api.trace.getTracerProvider(), meterProvider, Collection, CollectionPage, filterPredicate) {
+		this.name = name$1;
 		this.values = values;
 		this.context = context;
 		this.callbacks = callbacks;
@@ -3229,7 +3412,7 @@ async function respondWithObjectIfAcceptable(object, request, options) {
 	return response;
 }
 function generateNonce() {
-	const bytes = new Uint8Array(16);
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
 	crypto.getRandomValues(bytes);
 	return btoa(String.fromCharCode(...bytes)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 }
@@ -3284,7 +3467,7 @@ async function buildAcceptSignatureHeader(policy, kv, noncePrefix) {
 }
 async function setKey(kv, key, policy) {
 	const seconds = policy.nonceTtlSeconds ?? 300;
-	const ttl = Temporal$3.Duration.from({ seconds });
+	const ttl = Temporal$5.Duration.from({ seconds });
 	await kv.set(key, true, { ttl });
 }
 const DEF_COMPONENTS = [
@@ -3299,6 +3482,94 @@ const MIN_COMPONENTS = [
 	"@authority"
 ];
 //#endregion
+//#region src/federation/kv.ts
+const Temporal$4 = require_http.Temporal;
+/**
+* A key–value store that stores values in memory.
+* Do not use this in production as it does not persist values.
+*
+* @since 0.5.0
+*/
+var MemoryKvStore = class {
+	#values = {};
+	#encodeKey(key) {
+		return JSON.stringify(key);
+	}
+	/**
+	* {@inheritDoc KvStore.get}
+	*/
+	get(key) {
+		const encodedKey = this.#encodeKey(key);
+		const entry = this.#values[encodedKey];
+		if (entry == null) return Promise.resolve(void 0);
+		const [value, expiration] = entry;
+		if (expiration != null && Temporal$4.Now.instant().until(expiration).sign < 0) {
+			delete this.#values[encodedKey];
+			return Promise.resolve(void 0);
+		}
+		return Promise.resolve(value);
+	}
+	/**
+	* {@inheritDoc KvStore.set}
+	*/
+	set(key, value, options) {
+		const encodedKey = this.#encodeKey(key);
+		const expiration = options?.ttl == null ? null : Temporal$4.Now.instant().add(options.ttl.round({ largestUnit: "hour" }));
+		this.#values[encodedKey] = [value, expiration];
+		return Promise.resolve();
+	}
+	/**
+	* {@inheritDoc KvStore.delete}
+	*/
+	delete(key) {
+		const encodedKey = this.#encodeKey(key);
+		delete this.#values[encodedKey];
+		return Promise.resolve();
+	}
+	/**
+	* {@inheritDoc KvStore.cas}
+	*/
+	cas(key, expectedValue, newValue, options) {
+		const encodedKey = this.#encodeKey(key);
+		const entry = this.#values[encodedKey];
+		let currentValue;
+		if (entry == null) currentValue = void 0;
+		else {
+			const [value, expiration] = entry;
+			if (expiration != null && Temporal$4.Now.instant().until(expiration).sign < 0) {
+				delete this.#values[encodedKey];
+				currentValue = void 0;
+			} else currentValue = value;
+		}
+		if (!(0, es_toolkit.isEqual)(currentValue, expectedValue)) return Promise.resolve(false);
+		const expiration = options?.ttl == null ? null : Temporal$4.Now.instant().add(options.ttl.round({ largestUnit: "hour" }));
+		this.#values[encodedKey] = [newValue, expiration];
+		return Promise.resolve(true);
+	}
+	/**
+	* {@inheritDoc KvStore.list}
+	*/
+	async *list(prefix) {
+		const now = Temporal$4.Now.instant();
+		for (const [encodedKey, entry] of Object.entries(this.#values)) {
+			const key = JSON.parse(encodedKey);
+			if (prefix != null) {
+				if (key.length < prefix.length) continue;
+				if (!prefix.every((p, i) => key[i] === p)) continue;
+			}
+			const [value, expiration] = entry;
+			if (expiration != null && now.until(expiration).sign < 0) {
+				delete this.#values[encodedKey];
+				continue;
+			}
+			yield {
+				key,
+				value
+			};
+		}
+	}
+};
+//#endregion
 //#region src/nodeinfo/handler.ts
 /**
 * Handles a NodeInfo request.  You would not typically call this function
@@ -3759,7 +4030,7 @@ function serializeDataPointType(dataPointType) {
 }
 //#endregion
 //#region src/federation/retry.ts
-const Temporal$2 = require_temporal_polyfill.Temporal;
+const Temporal$3 = require_http.Temporal;
 /**
 * Creates an exponential backoff retry policy.  The delay between retries
 * starts at the `initialDelay` and is multiplied by the `factor` for each
@@ -3771,8 +4042,8 @@ const Temporal$2 = require_temporal_polyfill.Temporal;
 * @since 0.12.0
 */
 function createExponentialBackoffPolicy(options = {}) {
-	const initialDelay = Temporal$2.Duration.from(options.initialDelay ?? { seconds: 1 });
-	const maxDelay = Temporal$2.Duration.from(options.maxDelay ?? { hours: 12 });
+	const initialDelay = Temporal$3.Duration.from(options.initialDelay ?? { seconds: 1 });
+	const maxDelay = Temporal$3.Duration.from(options.maxDelay ?? { hours: 12 });
 	const maxAttempts = options.maxAttempts ?? 10;
 	const factor = options.factor ?? 2;
 	const jitter = options.jitter ?? true;
@@ -3784,8 +4055,8 @@ function createExponentialBackoffPolicy(options = {}) {
 			milliseconds *= 1 + Math.random();
 			milliseconds = Math.round(milliseconds);
 		}
-		const delay = Temporal$2.Duration.from({ milliseconds });
-		return Temporal$2.Duration.compare(delay, maxDelay) > 0 ? maxDelay : delay;
+		const delay = Temporal$3.Duration.from({ milliseconds });
+		return Temporal$3.Duration.compare(delay, maxDelay) > 0 ? maxDelay : delay;
 	};
 }
 //#endregion
@@ -3916,7 +4187,7 @@ const classReviver = (filter, init, set) => (seen, revive, node) => {
 *
 * @module
 */
-const Temporal$1 = require_temporal_polyfill.Temporal;
+const Temporal$2 = require_http.Temporal;
 /**
 * Validates the task handle, plans deduplication, encodes every payload, then
 * dispatches the resulting messages to the queue.  A single item flows through
@@ -3954,7 +4225,7 @@ const enqueueTasks = (ctx) => async function(task, items, options) {
 		if (claim.rollback != null) try {
 			await claim.rollback();
 		} catch (rollbackError) {
-			logger$1.warn("Failed to roll back the deduplication marker for task {taskName} after a failed enqueue; it will expire by TTL. {rollbackError}", {
+			logger$2.warn("Failed to roll back the deduplication marker for task {taskName} after a failed enqueue; it will expire by TTL. {rollbackError}", {
 				taskName: task.name,
 				rollbackError
 			});
@@ -3962,7 +4233,7 @@ const enqueueTasks = (ctx) => async function(task, items, options) {
 		throw error;
 	}
 };
-const getDurationIfDefined = (item) => item == null ? void 0 : Temporal$1.Duration.from(item);
+const getDurationIfDefined = (item) => item == null ? void 0 : Temporal$2.Duration.from(item);
 /**
 * Decides how a `deduplicationKey` (if any) is honored: forwarded to a native
 * queue, claimed via `cas`, or—when neither is available—dropped or rejected
@@ -4013,7 +4284,7 @@ async function claimDeduplication(ctx, plan, taskName) {
 				}
 			};
 		}
-		case "open": logger$1.debug("deduplicationKey {deduplicationKey} for task {taskName} ignored: the message queue declares no nativeDeduplication and the key-value store has no cas; proceeding (taskDeduplicationFallback is \"open\").", {
+		case "open": logger$2.debug("deduplicationKey {deduplicationKey} for task {taskName} ignored: the message queue declares no nativeDeduplication and the key-value store has no cas; proceeding (taskDeduplicationFallback is \"open\").", {
 			deduplicationKey: plan.key,
 			taskName
 		});
@@ -4068,13 +4339,13 @@ const encodeTaskMessage = (codec, origin, task, options) => async (data) => {
 		baseUrl: origin,
 		taskName: task.name,
 		data: encoded,
-		started: Temporal$1.Now.instant().toString(),
+		started: Temporal$2.Now.instant().toString(),
 		attempt: 0,
 		orderingKey: options.orderingKey,
 		traceContext: carrier
 	};
 };
-const logger$1 = (0, _logtape_logtape.getLogger)([
+const logger$2 = (0, _logtape_logtape.getLogger)([
 	"fedify",
 	"federation",
 	"task"
@@ -4102,11 +4373,29 @@ const classifyTaskError = (error) => require_http.isAbortError(error) ? { outcom
 };
 //#endregion
 //#region src/federation/webfinger.ts
-const logger = (0, _logtape_logtape.getLogger)([
+const logger$1 = (0, _logtape_logtape.getLogger)([
 	"fedify",
 	"webfinger",
 	"server"
 ]);
+function getWebFingerSubjectAndAliases({ resourceUrl, actorUri, preferredUsername, acctUsername, host, contextHost }) {
+	const aliases = [];
+	let subject = resourceUrl.href;
+	if (resourceUrl.protocol != "acct:" && preferredUsername != null) {
+		aliases.push(`acct:${preferredUsername}@${host ?? contextHost}`);
+		if (host != null && host !== contextHost) aliases.push(`acct:${preferredUsername}@${contextHost}`);
+	}
+	if (resourceUrl.href !== actorUri.href) aliases.push(actorUri.href);
+	if (resourceUrl.protocol === "acct:" && host != null && host !== contextHost && !resourceUrl.href.endsWith(`@${host}`)) {
+		subject = `acct:${preferredUsername ?? acctUsername}@${host}`;
+		aliases.push(resourceUrl.href);
+		if (preferredUsername != null && preferredUsername !== "" && preferredUsername !== acctUsername) aliases.push(`acct:${preferredUsername}@${contextHost}`);
+	}
+	return {
+		subject,
+		aliases
+	};
+}
 /**
 * Handles a WebFinger request.  You would not typically call this function
 * directly, but instead use {@link Federation.fetch} method.
@@ -4155,7 +4444,7 @@ async function handleWebFinger(request, options) {
 		});
 	}
 }
-const WEBFINGER_HANDLE_SCHEME_WHITELIST = new Set([
+const WEBFINGER_HANDLE_SCHEME_WHITELIST = /* @__PURE__ */ new Set([
 	"acct",
 	"http",
 	"https",
@@ -4184,7 +4473,7 @@ function classifyWebFingerHandleResult(response, notFoundResponse) {
 }
 async function handleWebFingerInternal(request, { context, host, actorDispatcher, actorHandleMapper, actorAliasMapper, onNotFound, span, webFingerLinksDispatcher }) {
 	if (actorDispatcher == null) {
-		logger.error("Actor dispatcher is not set.");
+		logger$1.error("Actor dispatcher is not set.");
 		return await onNotFound(request);
 	}
 	const resource = context.url.searchParams.get("resource");
@@ -4200,17 +4489,18 @@ async function handleWebFingerInternal(request, { context, host, actorDispatcher
 	span?.setAttribute("webfinger.resource.scheme", resourceUrl.protocol.replace(/:$/, ""));
 	async function mapUsernameToIdentifier(username) {
 		if (actorHandleMapper == null) {
-			logger.error("No actor handle mapper is set; use the WebFinger username {username} as the actor's internal identifier.", { username });
+			logger$1.error("No actor handle mapper is set; use the WebFinger username {username} as the actor's internal identifier.", { username });
 			return username;
 		}
 		const identifier = await actorHandleMapper(context, username);
 		if (identifier == null) {
-			logger.error("Actor {username} not found.", { username });
+			logger$1.error("Actor {username} not found.", { username });
 			return null;
 		}
 		return identifier;
 	}
 	let identifier = null;
+	let acctUsername = null;
 	const uriParsed = context.parseUri(resourceUrl);
 	if (uriParsed?.type != "actor") {
 		const match = /^acct:([^@]+)@([^@]+)$/.exec(resource);
@@ -4224,24 +4514,26 @@ async function handleWebFingerInternal(request, { context, host, actorDispatcher
 			const normalizedHost = portMatch == null ? (0, node_url.domainToASCII)(match[2].toLowerCase()) : (0, node_url.domainToASCII)(match[2].substring(0, portMatch.index).toLowerCase()) + portMatch[0];
 			if (normalizedHost != context.url.host && normalizedHost != host) return await onNotFound(request);
 			else {
-				identifier = await mapUsernameToIdentifier(match[1]);
-				resourceUrl = new URL(`acct:${match[1]}@${normalizedHost}`);
+				acctUsername = match[1];
+				identifier = await mapUsernameToIdentifier(acctUsername);
+				resourceUrl = new URL(`acct:${acctUsername}@${normalizedHost}`);
 			}
 		}
 	} else identifier = uriParsed.identifier;
 	if (identifier == null) return await onNotFound(request);
 	const actor = await actorDispatcher(context, identifier);
 	if (actor == null) {
-		logger.error("Actor {identifier} not found.", { identifier });
+		logger$1.error("Actor {identifier} not found.", { identifier });
 		return await onNotFound(request);
 	}
 	if (actor instanceof _fedify_vocab.Tombstone) return new Response(null, {
 		status: 410,
 		headers: { "Access-Control-Allow-Origin": "*" }
 	});
+	const actorUri = context.getActorUri(identifier);
 	const links = [{
 		rel: "self",
-		href: context.getActorUri(identifier).href,
+		href: actorUri.href,
 		type: "application/activity+json"
 	}];
 	for (const url of actor.urls) if (url instanceof _fedify_vocab.Link && url.href != null) links.push({
@@ -4265,30 +4557,26 @@ async function handleWebFingerInternal(request, { context, host, actorDispatcher
 		const customLinks = await webFingerLinksDispatcher(context, resourceUrl);
 		if (customLinks != null) for (const link of customLinks) links.push(link);
 	}
-	const aliases = [];
-	const preferredUsername = actor.preferredUsername;
-	if (resourceUrl.protocol != "acct:" && preferredUsername != null) {
-		aliases.push(`acct:${preferredUsername}@${host ?? context.url.host}`);
-		if (host != null && host !== context.url.host) aliases.push(`acct:${preferredUsername}@${context.url.host}`);
-	}
-	if (resourceUrl.href !== context.getActorUri(identifier).href) aliases.push(context.getActorUri(identifier).href);
-	if (resourceUrl.protocol === "acct:" && host != null && host !== context.url.host && !resourceUrl.href.endsWith(`@${host}`)) {
-		const username = resourceUrl.href.replace(/^acct:/, "").replace(/@.*$/, "");
-		aliases.push(`acct:${username}@${host}`);
-	}
-	const jrd = {
-		subject: resourceUrl.href,
+	const { subject, aliases } = getWebFingerSubjectAndAliases({
+		resourceUrl,
+		actorUri,
+		preferredUsername: actor.preferredUsername,
+		acctUsername,
+		host,
+		contextHost: context.url.host
+	});
+	return new Response(JSON.stringify({
+		subject,
 		aliases,
 		links
-	};
-	return new Response(JSON.stringify(jrd), { headers: {
+	}), { headers: {
 		"Content-Type": "application/jrd+json",
 		"Access-Control-Allow-Origin": "*"
 	} });
 }
 //#endregion
 //#region src/federation/middleware.ts
-var middleware_exports = /* @__PURE__ */ require_chunk.__exportAll({
+var middleware_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
 	ContextImpl: () => ContextImpl,
 	FederationImpl: () => FederationImpl,
 	InboxContextImpl: () => InboxContextImpl,
@@ -4296,11 +4584,11 @@ var middleware_exports = /* @__PURE__ */ require_chunk.__exportAll({
 	OutboxContextImpl: () => OutboxContextImpl,
 	createFederation: () => createFederation
 });
-const Temporal = require_temporal_polyfill.Temporal;
+const Temporal$1 = require_http.Temporal;
 const circuitBreakerCasWarningKvStores = /* @__PURE__ */ new WeakSet();
 let nextQueueDepthGaugeSourceId = 0;
 const retryAfterHttpDate = /* @__PURE__ */ new RegExp("^(?:(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), \\d{2} (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \\d{4} \\d{2}:\\d{2}:\\d{2} GMT|(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), \\d{2}-(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-\\d{2} \\d{2}:\\d{2}:\\d{2} GMT|(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (?: \\d|\\d{2}) \\d{2}:\\d{2}:\\d{2} \\d{4})$");
-function parseRetryAfter(headers, now = Temporal.Now.instant()) {
+function parseRetryAfter(headers, now = Temporal$1.Now.instant()) {
 	const value = headers.get("Retry-After");
 	if (value == null) return void 0;
 	const trimmed = value.trim();
@@ -4318,14 +4606,14 @@ function parseRetryAfter(headers, now = Temporal.Now.instant()) {
 }
 function parseRetryAfterDuration(durationLike) {
 	try {
-		return Temporal.Duration.from(durationLike);
+		return Temporal$1.Duration.from(durationLike);
 	} catch (error) {
 		if (error instanceof RangeError) return void 0;
 		throw error;
 	}
 }
 function clampNegativeDelay(delay) {
-	return delay.sign < 0 ? Temporal.Duration.from({ seconds: 0 }) : delay;
+	return delay.sign < 0 ? Temporal$1.Duration.from({ seconds: 0 }) : delay;
 }
 function getBenchmarkRelaxations(allowPrivateAddress, signatureTimeWindow) {
 	const relaxations = [];
@@ -4341,7 +4629,7 @@ function getBenchmarkRelaxations(allowPrivateAddress, signatureTimeWindow) {
 		secureDefaultSeconds: 3600
 	});
 	else try {
-		const seconds = Temporal.Duration.from(signatureTimeWindow).total({ unit: "seconds" });
+		const seconds = Temporal$1.Duration.from(signatureTimeWindow).total({ unit: "seconds" });
 		if (seconds !== 3600) relaxations.push({
 			protection: "http_signature_time_window",
 			effect: "changed",
@@ -4376,7 +4664,7 @@ function getBenchmarkTriggerOptions(benchmarkOptions) {
 	};
 }
 function maxDelay(first, second) {
-	return Temporal.Duration.compare(first, second) >= 0 ? first : second;
+	return Temporal$1.Duration.compare(first, second) >= 0 ? first : second;
 }
 function isTransportDeliveryError(error) {
 	return error instanceof _fedify_vocab_runtime.FetchError || require_http.isAbortError(error);
@@ -4616,7 +4904,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 		this.inboxRetryPolicy = options.inboxRetryPolicy ?? createExponentialBackoffPolicy();
 		this.taskRetryPolicy = options.taskRetryPolicy ?? createExponentialBackoffPolicy();
 		this.taskQueueResolution = options.taskQueueResolution ?? "fallback";
-		this.taskDeduplicationTtl = Temporal.Duration.from(options.taskDeduplicationTtl ?? { hours: 1 });
+		this.taskDeduplicationTtl = Temporal$1.Duration.from(options.taskDeduplicationTtl ?? { hours: 1 });
 		this.taskDeduplicationFallback = options.taskDeduplicationFallback ?? "open";
 		this.activityTransformers = options.activityTransformers ?? require_transformers.getDefaultActivityTransformers();
 		this._tracerProvider = options.tracerProvider;
@@ -5014,7 +5302,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 			const getPolicyDelay = () => {
 				if (!policyDelayCalculated) {
 					retryPolicyDelay = this.outboxRetryPolicy({
-						elapsedTime: Temporal.Instant.from(message.started).until(Temporal.Now.instant()),
+						elapsedTime: Temporal$1.Instant.from(message.started).until(Temporal$1.Now.instant()),
 						attempts: message.attempt
 					});
 					policyDelayCalculated = true;
@@ -5203,7 +5491,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 					throw error;
 				}
 				const delay = this.inboxRetryPolicy({
-					elapsedTime: Temporal.Instant.from(message.started).until(Temporal.Now.instant()),
+					elapsedTime: Temporal$1.Instant.from(message.started).until(Temporal$1.Now.instant()),
 					attempts: message.attempt
 				});
 				if (delay != null) {
@@ -5362,7 +5650,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 				await handleRetriableFailure(error);
 				return;
 			}
-			if (cacheKey != null) await this.kv.set(cacheKey, true, { ttl: Temporal.Duration.from({ days: 1 }) });
+			if (cacheKey != null) await this.kv.set(cacheKey, true, { ttl: Temporal$1.Duration.from({ days: 1 }) });
 			logger.info("Activity {activityId} has been processed.", {
 				activityId: activity?.id?.href,
 				activity: message.activity,
@@ -5416,9 +5704,9 @@ var FederationImpl = class extends FederationBuilderImpl {
 			const queue = this.resolveTaskQueue(def.name);
 			if (queue?.nativeRetrial) throw error;
 			const retryPolicy = def.retryPolicy ?? this.taskRetryPolicy;
-			let elapsedTime = Temporal.Duration.from({ seconds: 0 });
+			let elapsedTime = Temporal$1.Duration.from({ seconds: 0 });
 			try {
-				elapsedTime = Temporal.Instant.from(message.started).until(Temporal.Now.instant());
+				elapsedTime = Temporal$1.Instant.from(message.started).until(Temporal$1.Now.instant());
 			} catch (parseError) {
 				logger.error("Custom task {taskName} has an unparsable started time {started}; treating elapsedTime as zero:\n{error}", {
 					taskName: message.taskName,
@@ -7141,12 +7429,471 @@ function getRequestId(request) {
 	return `req_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
 }
 //#endregion
+//#region src/federation/mq.ts
+const Temporal = require_http.Temporal;
+/**
+* A message queue that processes messages in the same process.
+* Do not use this in production as it does neither persist messages nor
+* distribute them across multiple processes.
+*
+* @since 0.5.0
+*/
+var InProcessMessageQueue = class {
+	#messages;
+	#monitors;
+	#pollIntervalMs;
+	#delayedMessages;
+	/**
+	* Tracks which ordering keys are currently being processed to ensure
+	* sequential processing for messages with the same key.
+	*/
+	#processingKeys;
+	/**
+	* In-process message queue does not provide native retry mechanisms.
+	* @since 1.7.0
+	*/
+	nativeRetrial = false;
+	/**
+	* In-process message queue does not deduplicate messages natively.
+	* @since 2.4.0
+	*/
+	nativeDeduplication = false;
+	/**
+	* Constructs a new {@link InProcessMessageQueue} with the given options.
+	* @param options Additional options for the in-process message queue.
+	*/
+	constructor(options = {}) {
+		this.#messages = [];
+		this.#monitors = {};
+		this.#pollIntervalMs = Temporal.Duration.from(options.pollInterval ?? { seconds: 5 }).total("millisecond");
+		this.#delayedMessages = 0;
+		this.#processingKeys = /* @__PURE__ */ new Set();
+	}
+	enqueue(message, options) {
+		const delay = options?.delay == null ? 0 : Math.max(options.delay.total("millisecond"), 0);
+		if (delay > 0) {
+			this.#delayedMessages++;
+			setTimeout(() => {
+				this.#delayedMessages--;
+				this.#enqueueReady(message, options);
+			}, delay);
+			return Promise.resolve();
+		}
+		this.#enqueueReady(message, options);
+		return Promise.resolve();
+	}
+	#enqueueReady(message, options) {
+		const orderingKey = options?.orderingKey ?? null;
+		this.#messages.push({
+			message,
+			orderingKey
+		});
+		this.#notifyMonitors();
+	}
+	#notifyMonitors() {
+		for (const monitorId in this.#monitors) this.#monitors[monitorId]();
+	}
+	enqueueMany(messages, options) {
+		if (messages.length === 0) return Promise.resolve();
+		const delay = options?.delay == null ? 0 : Math.max(options.delay.total("millisecond"), 0);
+		if (delay > 0) {
+			const delayedCount = messages.length;
+			const deferredMessages = [...messages];
+			this.#delayedMessages += delayedCount;
+			setTimeout(() => {
+				this.#delayedMessages -= delayedCount;
+				this.#enqueueManyReady(deferredMessages, options);
+			}, delay);
+			return Promise.resolve();
+		}
+		this.#enqueueManyReady(messages, options);
+		return Promise.resolve();
+	}
+	#enqueueManyReady(messages, options) {
+		const orderingKey = options?.orderingKey ?? null;
+		for (const message of messages) this.#messages.push({
+			message,
+			orderingKey
+		});
+		this.#notifyMonitors();
+	}
+	async listen(handler, options = {}) {
+		const signal = options.signal;
+		while (signal == null || !signal.aborted) {
+			const idx = this.#messages.findIndex((m) => m.orderingKey == null || !this.#processingKeys.has(m.orderingKey));
+			if (idx >= 0) {
+				const { message, orderingKey } = this.#messages.splice(idx, 1)[0];
+				if (orderingKey != null) this.#processingKeys.add(orderingKey);
+				try {
+					await handler(message);
+				} finally {
+					if (orderingKey != null) this.#processingKeys.delete(orderingKey);
+				}
+			} else if (this.#messages.length === 0) await this.#wait(this.#pollIntervalMs, signal);
+			else await this.#wait(10, signal);
+		}
+	}
+	getDepth() {
+		const ready = this.#messages.length;
+		const delayed = this.#delayedMessages;
+		return Promise.resolve({
+			queued: ready + delayed,
+			ready,
+			delayed
+		});
+	}
+	#wait(ms, signal) {
+		let timer = null;
+		return Promise.any([new Promise((resolve) => {
+			signal?.addEventListener("abort", () => {
+				if (timer != null) clearTimeout(timer);
+				resolve();
+			}, { once: true });
+			const monitorId = crypto.randomUUID();
+			this.#monitors[monitorId] = () => {
+				delete this.#monitors[monitorId];
+				if (timer != null) clearTimeout(timer);
+				resolve();
+			};
+		}), new Promise((resolve) => timer = setTimeout(resolve, ms))]);
+	}
+};
+/**
+* A message queue that processes messages in parallel.  It takes another
+* {@link MessageQueue}, and processes messages in parallel up to a certain
+* number of workers.
+*
+* Actually, it's rather a decorator than a queue itself.
+*
+* Note that the workers do not run in truly parallel, in the sense that they
+* are not running in separate threads or processes.  They are running in the
+* same process, but are scheduled to run in parallel.  Hence, this is useful
+* for I/O-bound tasks, but not for CPU-bound tasks, which is okay for Fedify's
+* workloads.
+*
+* When using `ParallelMessageQueue`, the ordering guarantee is preserved
+* *only if* the underlying queue implementation delivers messages in a wrapper
+* format that includes the `__fedify_ordering_key__` property.  Currently,
+* only `DenoKvMessageQueue` and `WorkersMessageQueue` use this format.
+* For other queue implementations (e.g., `InProcessMessageQueue`,
+* `RedisMessageQueue`, `PostgresMessageQueue`, `SqliteMessageQueue`,
+* `AmqpMessageQueue`), the ordering key cannot be detected by
+* `ParallelMessageQueue`, so ordering guarantees are handled by those
+* implementations directly rather than at the `ParallelMessageQueue` level.
+*
+* Messages with the same ordering key will never be processed concurrently
+* by different workers, ensuring sequential processing within each key.
+* Messages with different ordering keys (or no ordering key) can still be
+* processed in parallel.
+*
+* @since 1.0.0
+*/
+var ParallelMessageQueue = class ParallelMessageQueue {
+	queue;
+	workers;
+	/**
+	* Inherits the native retry capability from the wrapped queue.
+	* @since 1.7.0
+	*/
+	nativeRetrial;
+	/**
+	* Inherits the native deduplication capability from the wrapped queue.
+	* @since 2.4.0
+	*/
+	nativeDeduplication;
+	/**
+	* Inherits the atomic batch capability from the wrapped queue.
+	* @since 2.4.0
+	*/
+	atomicEnqueueMany;
+	getDepth;
+	/**
+	* Tracks which ordering keys are currently being processed to ensure
+	* sequential processing for messages with the same key.
+	*/
+	#processingKeys = /* @__PURE__ */ new Set();
+	/**
+	* Pending messages waiting for their ordering key to become available.
+	*/
+	#pendingMessages = [];
+	/**
+	* Constructs a new {@link ParallelMessageQueue} with the given queue and
+	* number of workers.
+	* @param queue The message queue to use under the hood.  Note that
+	*              {@link ParallelMessageQueue} cannot be nested.
+	* @param workers The number of workers to process messages in parallel.
+	* @throws {TypeError} If the given queue is an instance of
+	*                     {@link ParallelMessageQueue}.
+	*/
+	constructor(queue, workers) {
+		if (queue instanceof ParallelMessageQueue) throw new TypeError("Cannot nest ParallelMessageQueue.");
+		this.queue = queue;
+		this.workers = workers;
+		this.nativeRetrial = queue.nativeRetrial;
+		this.nativeDeduplication = queue.nativeDeduplication;
+		this.atomicEnqueueMany = queue.enqueueMany == null ? false : queue.atomicEnqueueMany;
+		if (queue.getDepth != null) this.getDepth = () => queue.getDepth();
+	}
+	enqueue(message, options) {
+		return this.queue.enqueue(message, options);
+	}
+	async enqueueMany(messages, options) {
+		if (this.queue.enqueueMany == null) {
+			if (messages.length === 1) {
+				await this.queue.enqueue(messages[0], options);
+				return;
+			}
+			if (options?.deduplicationKey != null) throw new TypeError("Cannot enqueue a batch with a deduplicationKey: the wrapped queue does not implement enqueueMany, so ParallelMessageQueue would have to fan out to individual enqueue() calls that cannot share one deduplicationKey atomically.  Wrap a queue that implements enqueueMany instead.");
+			const errors = (await Promise.allSettled(messages.map((message) => this.queue.enqueue(message, options)))).filter((r) => r.status === "rejected").map((r) => r.reason);
+			if (errors.length > 1) throw new AggregateError(errors, "Failed to enqueue messages.");
+			else if (errors.length === 1) throw errors[0];
+			return;
+		}
+		await this.queue.enqueueMany(messages, options);
+	}
+	/**
+	* Extracts ordering key from a message if present.
+	*
+	* This method only works for queue implementations that deliver messages
+	* in the wrapper format with `__fedify_ordering_key__` property.  Currently,
+	* only `DenoKvMessageQueue` and `WorkersMessageQueue` use this format.
+	*
+	* For other queue implementations (`InProcessMessageQueue`,
+	* `RedisMessageQueue`, `PostgresMessageQueue`, `SqliteMessageQueue`,
+	* `AmqpMessageQueue`), messages are delivered as raw payloads without the
+	* wrapper, so the ordering key cannot be detected here.  Those
+	* implementations handle ordering guarantees internally.
+	*/
+	#extractOrderingKey(message) {
+		if (message != null && typeof message === "object") {
+			if ("__fedify_ordering_key__" in message) return message.__fedify_ordering_key__;
+		}
+	}
+	listen(handler, options = {}) {
+		const workers = /* @__PURE__ */ new Map();
+		return this.queue.listen(async (message) => {
+			while (workers.size >= this.workers) {
+				const consumedId = await Promise.any(workers.values());
+				workers.delete(consumedId);
+			}
+			const workerId = crypto.randomUUID();
+			const orderingKey = this.#extractOrderingKey(message);
+			if (orderingKey != null && this.#processingKeys.has(orderingKey)) await new Promise((resolve) => {
+				this.#pendingMessages.push({
+					message,
+					orderingKey,
+					resolve
+				});
+			});
+			if (orderingKey != null) this.#processingKeys.add(orderingKey);
+			const promise = this.#work(workerId, handler, message, orderingKey);
+			workers.set(workerId, promise);
+		}, options);
+	}
+	async #work(workerId, handler, message, orderingKey) {
+		await this.#sleep(0);
+		try {
+			await handler(message);
+		} finally {
+			if (orderingKey != null) {
+				this.#processingKeys.delete(orderingKey);
+				const pendingIdx = this.#pendingMessages.findIndex((p) => p.orderingKey === orderingKey);
+				if (pendingIdx >= 0) this.#pendingMessages.splice(pendingIdx, 1)[0].resolve();
+			}
+		}
+		return workerId;
+	}
+	#sleep(ms) {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+};
+//#endregion
+//#region src/federation/router.ts
+const logger = (0, _logtape_logtape.getLogger)([
+	"fedify",
+	"federation",
+	"router",
+	"deprecated"
+]);
+let deprecationWarned = false;
+function warnDeprecated() {
+	if (deprecationWarned) return;
+	deprecationWarned = true;
+	logger.warn("The `Router` and `RouterError` classes from `@fedify/fedify` are deprecated.  Please use `Router` from `@fedify/uri-template` instead.");
+}
+/**
+* URL router and constructor based on URI Template
+* ([RFC 6570](https://tools.ietf.org/html/rfc6570)).
+*
+* @deprecated Import `Router` from `@fedify/uri-template` instead.  This class
+*             remains only for compatibility with older Fedify code.  The
+*             `@fedify/uri-template` router is the replacement implementation
+*             and should be used directly in new code.
+*/
+var Router = class Router {
+	#router;
+	/**
+	* Create a new {@link Router}.
+	* @param options Options for the router.
+	* @deprecated Use `new Router(options)` from `@fedify/uri-template`
+	*             instead.
+	*/
+	constructor(options) {
+		this.#router = convertRouterError(() => new _fedify_uri_template.Router(options));
+	}
+	/**
+	* Whether to ignore trailing slashes when matching paths.
+	* @deprecated Use `Router` from `@fedify/uri-template` instead.  This
+	*             accessor forwards to the underlying `@fedify/uri-template`
+	*             router so that post-construction mutation keeps working as
+	*             in older Fedify code.
+	*/
+	get trailingSlashInsensitive() {
+		return this.#router.trailingSlashInsensitive;
+	}
+	set trailingSlashInsensitive(value) {
+		this.#router.trailingSlashInsensitive = value;
+	}
+	/**
+	* Clones this router.
+	* @deprecated Use `Router` from `@fedify/uri-template` instead.
+	*/
+	clone() {
+		return convertRouterError(() => {
+			const clone = new Router();
+			clone.#router = this.#router.clone();
+			return clone;
+		});
+	}
+	/**
+	* Checks if a path name exists in the router.
+	* @param name The name of the path.
+	* @returns `true` if the path name exists, otherwise `false`.
+	* @deprecated Use `Router` from `@fedify/uri-template` instead.
+	*/
+	has(name) {
+		return convertRouterError(() => this.#router.has(name));
+	}
+	/**
+	* Adds a new path rule to the router.
+	* @param template The path pattern.
+	* @param name The name of the path.
+	* @returns The names of the variables in the path pattern.
+	* @deprecated Use `Router` from `@fedify/uri-template` instead.  In this
+	*             compatibility class, `add()` both registers the route and
+	*             returns the variables in the path pattern.  In
+	*             `@fedify/uri-template`, these two responsibilities are split:
+	*             `router.add(template, name)` registers the route and returns
+	*             `void`, while the pure static method
+	*             `Router.variables(template)` returns the variable names.  To
+	*             migrate, call `Router.variables(template)` when variables are
+	*             needed, then call `router.add(template, name)` to register the
+	*             route.
+	*/
+	add(template, name) {
+		return convertRouterError(() => {
+			(0, _fedify_uri_template.assertPath)(template);
+			this.#router.add(template, name);
+			return _fedify_uri_template.Router.variables(template);
+		});
+	}
+	/**
+	* Resolves a path name and values from a URL, if any match.
+	* @param url The URL to resolve.
+	* @returns The name of the path and its values, if any match.  Otherwise,
+	*          `null`.
+	* @deprecated Use `Router` from `@fedify/uri-template` instead.  Unlike the
+	*             stricter `@fedify/uri-template` router, this compatibility
+	*             method keeps the old Fedify 2.x contract of returning `null`
+	*             (rather than throwing) for inputs that are not router paths.
+	*/
+	route(url) {
+		return convertRouterError(() => {
+			if (!(0, _fedify_uri_template.isPath)(url)) return null;
+			return this.#router.route(url);
+		});
+	}
+	/**
+	* Constructs a URL/path from a path name and values.
+	* @param name The name of the path.
+	* @param values The values to expand the path with.
+	* @returns The URL/path, if the name exists.  Otherwise, `null`.
+	* @deprecated Use `Router` from `@fedify/uri-template` instead.
+	*/
+	build(name, values) {
+		return convertRouterError(() => this.#router.build(name, values));
+	}
+};
+/**
+* An error thrown by the {@link Router}.
+* @deprecated Import `RouterError` from `@fedify/uri-template` instead.
+*/
+var RouterError = class extends _fedify_uri_template.RouterError {
+	/**
+	* Treats every `RouterError` from `@fedify/uri-template` as an instance of
+	* this deprecated class.
+	*
+	* @deprecated Import `RouterError` from `@fedify/uri-template` instead.
+	*/
+	static [Symbol.hasInstance](instance) {
+		return instance instanceof _fedify_uri_template.RouterError;
+	}
+	/**
+	* Create a new {@link RouterError}.
+	* @param message The error message.
+	* @deprecated Import `RouterError` from `@fedify/uri-template` instead.
+	*/
+	constructor(message) {
+		super(message);
+		warnDeprecated();
+	}
+};
+function convertRouterError(func) {
+	try {
+		warnDeprecated();
+		return func();
+	} catch (error) {
+		if (error instanceof _fedify_uri_template.RouterError) throw new RouterError(error.message);
+		throw error;
+	}
+}
+//#endregion
 Object.defineProperty(exports, "CircuitBreaker", {
 	enumerable: true,
 	get: function() {
 		return CircuitBreaker;
 	}
 });
+Object.defineProperty(exports, "InProcessMessageQueue", {
+	enumerable: true,
+	get: function() {
+		return InProcessMessageQueue;
+	}
+});
+Object.defineProperty(exports, "MemoryKvStore", {
+	enumerable: true,
+	get: function() {
+		return MemoryKvStore;
+	}
+});
+Object.defineProperty(exports, "ParallelMessageQueue", {
+	enumerable: true,
+	get: function() {
+		return ParallelMessageQueue;
+	}
+});
+Object.defineProperty(exports, "Router", {
+	enumerable: true,
+	get: function() {
+		return Router;
+	}
+});
+Object.defineProperty(exports, "RouterError", {
+	enumerable: true,
+	get: function() {
+		return RouterError;
+	}
+});
 Object.defineProperty(exports, "SendActivityError", {
 	enumerable: true,
 	get: function() {
@@ -7189,12 +7936,6 @@ Object.defineProperty(exports, "handleWebFinger", {
 		return handleWebFinger;
 	}
 });
-Object.defineProperty(exports, "middleware_exports", {
-	enumerable: true,
-	get: function() {
-		return middleware_exports;
-	}
-});
 Object.defineProperty(exports, "normalizeCircuitBreakerOptions", {
 	enumerable: true,
 	get: function() {