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

package/dist/{key-CM7wDnZG.mjs → key-igh0AMsL.mjs}

@@ -1,8 +1,8 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as version, t as name } from "./deno-DtHcfB0f.mjs";
-import { _ as recordKeyLookup, n as getDurationMs, t as classifyFetchError } from "./metrics-DT-CnD1g.mjs";
+import { n as version, t as name } from "./deno-tRdp8MCl.mjs";
+import { _ as recordKeyLookup, n as getDurationMs, t as classifyFetchError } from "./metrics-DbdNnWIt.mjs";
 import { getLogger } from "@logtape/logtape";
 import { CryptographicKey, Multikey, Object as Object$1, isActor } from "@fedify/vocab";
 import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";

package/dist/{kv-cache-ZQ22hm44.js → kv-cache-BIAB0HKx.js}

@@ -1,6 +1,6 @@
 import { Temporal } from "temporal-polyfill";
 import { URLPattern } from "urlpattern-polyfill";
-import { C as recordDocumentCache, d as validateCryptoKey, t as doubleKnock } from "./http-BbnOMQoy.js";
+import { C as recordDocumentCache, d as validateCryptoKey, t as doubleKnock } from "./http-BIxGa6AG.js";
 import { getLogger } from "@logtape/logtape";
 import { curry } from "es-toolkit";
 import { UrlError, createActivityPubRequest, getRemoteDocument, logRequest, preloadedContexts, validatePublicUrl } from "@fedify/vocab-runtime";

package/dist/{kv-cache-DEXKemJ9.mjs → kv-cache-Bz6aQOOX.mjs}

@@ -1,7 +1,7 @@
 import { Temporal } from "temporal-polyfill";
 import { URLPattern } from "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { p as recordDocumentCache } from "./metrics-DT-CnD1g.mjs";
+import { p as recordDocumentCache } from "./metrics-DbdNnWIt.mjs";
 import { getLogger } from "@logtape/logtape";
 import { preloadedContexts } from "@fedify/vocab-runtime";
 //#region src/utils/kv-cache.ts

package/dist/{kv-cache-zmgG1HUp.cjs → kv-cache-C4U_uBqD.cjs}

@@ -1,7 +1,5 @@
 const { URLPattern } = require("urlpattern-polyfill");
-require("./chunk-Czpeue4M.cjs");
-const require_http = require("./http-BpT5cE6r.cjs");
-const require_temporal_polyfill = require("./temporal-polyfill-BCdTHexd.cjs");
+const require_http = require("./http-DggG1scN.cjs");
 let _logtape_logtape = require("@logtape/logtape");
 let es_toolkit = require("es-toolkit");
 let _fedify_vocab_runtime = require("@fedify/vocab-runtime");
@@ -46,7 +44,7 @@ function getAuthenticatedDocumentLoader(identity, { allowPrivateAddress, maxRedi
 }
 //#endregion
 //#region src/utils/kv-cache.ts
-const Temporal = require_temporal_polyfill.Temporal;
+const Temporal = require_http.Temporal;
 const logger = (0, _logtape_logtape.getLogger)([
 	"fedify",
 	"utils",

package/dist/{ld-BttH_-8K.mjs → ld-DnT9sCWa.mjs}

@@ -1,9 +1,9 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as version, t as name } from "./deno-DtHcfB0f.mjs";
-import { n as getDurationMs, r as getFederationMetrics, s as measureSignatureKeyFetch } from "./metrics-DT-CnD1g.mjs";
-import { n as fetchKey, o as validateCryptoKey } from "./key-CM7wDnZG.mjs";
+import { n as version, t as name } from "./deno-tRdp8MCl.mjs";
+import { n as getDurationMs, r as getFederationMetrics, s as measureSignatureKeyFetch } from "./metrics-DbdNnWIt.mjs";
+import { n as fetchKey, o as validateCryptoKey } from "./key-igh0AMsL.mjs";
 import { getLogger } from "@logtape/logtape";
 import { Activity, CryptographicKey, Object as Object$1, getTypeId } from "@fedify/vocab";
 import { SpanStatusCode, trace } from "@opentelemetry/api";
@@ -25,7 +25,7 @@ const localContext = [
 ];
 const localContextUrls = new Set(localContext);
 const builtInContextLoader = getDocumentLoader();
-const disallowedJsonLdKeywords = new Set([
+const disallowedJsonLdKeywords = /* @__PURE__ */ new Set([
 	"@graph",
 	"@included",
 	"@reverse"
@@ -525,7 +525,7 @@ async function verifySignature(jsonLd, options = {}) {
 * only from external documents and are dropped from the metric attribute to
 * avoid attacker-controlled cardinality.
 */
-const LD_KNOWN_SIGNATURE_TYPES = new Set(["RsaSignature2017"]);
+const LD_KNOWN_SIGNATURE_TYPES = /* @__PURE__ */ new Set(["RsaSignature2017"]);
 /**
 * Reports only whether a `signature` key is present on the document, with
 * no shape check on its value.  This is intentionally looser than

package/dist/metrics-DVKYY6K1.d.cts

@@ -0,0 +1,36 @@
+/// <reference lib="esnext.temporal" />
+import { DocumentLoader } from "@fedify/vocab-runtime";
+import { MeterProvider } from "@opentelemetry/api";
+
+//#region src/federation/metrics.d.ts
+/**
+* The kind of remote ActivityPub lookup, recorded as
+* `activitypub.lookup.kind` on the public-key lookup and remote document
+* fetch metric families.
+*
+*  -  `public_key`: a public key lookup performed by `fetchKey` /
+*     `fetchKeyDetailed` (always recorded on `activitypub.key.lookup*`).
+*  -  `actor`: a document fetch whose resolved value is an Actor.  The
+*     bucket exists in the taxonomy for future actor-aware call sites;
+*     today, actor documents fetched through Fedify's generic document
+*     loader are still classified as `object` because the kind is decided
+*     at the loader boundary, before the response is parsed.
+*  -  `object`: a generic ActivityPub object fetch through Fedify's
+*     document loader.  This is the default classification for
+*     `documentLoader` invocations that do not match a more specific
+*     bucket.
+*  -  `context`: a JSON-LD `@context` document fetch through Fedify's
+*     context loader.
+*  -  `other`: a fetch that does not fit any of the above classifications.
+* @since 2.3.0
+*/
+type LookupKind = "public_key" | "actor" | "object" | "context" | "other";
+/**
+* The {@link LookupKind} values that can appear on remote document fetch
+* metrics.  `public_key` lookups are reported on the
+* `activitypub.key.lookup` metric family instead, so it is excluded here.
+* @since 2.3.0
+*/
+type DocumentFetchKind = Exclude<LookupKind, "public_key">;
+//#endregion
+export { DocumentFetchKind as t };

package/dist/{metrics-DT-CnD1g.mjs → metrics-DbdNnWIt.mjs}

@@ -1,7 +1,7 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as version, t as name } from "./deno-DtHcfB0f.mjs";
+import { n as version, t as name } from "./deno-tRdp8MCl.mjs";
 import { metrics } from "@opentelemetry/api";
 import { FetchError } from "@fedify/vocab-runtime";
 //#region src/federation/metrics.ts
@@ -770,7 +770,7 @@ function isAbortError(error) {
 	const name = error.name;
 	return typeof name === "string" && name === "AbortError";
 }
-const KNOWN_HTTP_METHODS = new Set([
+const KNOWN_HTTP_METHODS = /* @__PURE__ */ new Set([
 	"CONNECT",
 	"DELETE",
 	"GET",

package/dist/metrics-DoRtI0qU.d.ts

@@ -0,0 +1,36 @@
+/// <reference lib="esnext.temporal" />
+import { MeterProvider } from "@opentelemetry/api";
+import { DocumentLoader } from "@fedify/vocab-runtime";
+
+//#region src/federation/metrics.d.ts
+/**
+* The kind of remote ActivityPub lookup, recorded as
+* `activitypub.lookup.kind` on the public-key lookup and remote document
+* fetch metric families.
+*
+*  -  `public_key`: a public key lookup performed by `fetchKey` /
+*     `fetchKeyDetailed` (always recorded on `activitypub.key.lookup*`).
+*  -  `actor`: a document fetch whose resolved value is an Actor.  The
+*     bucket exists in the taxonomy for future actor-aware call sites;
+*     today, actor documents fetched through Fedify's generic document
+*     loader are still classified as `object` because the kind is decided
+*     at the loader boundary, before the response is parsed.
+*  -  `object`: a generic ActivityPub object fetch through Fedify's
+*     document loader.  This is the default classification for
+*     `documentLoader` invocations that do not match a more specific
+*     bucket.
+*  -  `context`: a JSON-LD `@context` document fetch through Fedify's
+*     context loader.
+*  -  `other`: a fetch that does not fit any of the above classifications.
+* @since 2.3.0
+*/
+type LookupKind = "public_key" | "actor" | "object" | "context" | "other";
+/**
+* The {@link LookupKind} values that can appear on remote document fetch
+* metrics.  `public_key` lookups are reported on the
+* `activitypub.key.lookup` metric family instead, so it is excluded here.
+* @since 2.3.0
+*/
+type DocumentFetchKind = Exclude<LookupKind, "public_key">;
+//#endregion
+export { DocumentFetchKind as t };

package/dist/{middleware-ChlYS0Af.mjs → middleware-B6GweVcg.mjs}

@@ -1,5 +1,5 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as FederationImpl } from "./middleware-DrroX3aD.mjs";
+import { n as FederationImpl } from "./middleware-DPIS4fsB.mjs";
 export { FederationImpl };

package/dist/{middleware-D3IAVMcT.js → middleware-CnsPXG0O.js}

@@ -1,11 +1,11 @@
 import { Temporal } from "temporal-polyfill";
 import { URLPattern } from "urlpattern-polyfill";
-import { t as __exportAll } from "./chunk-D5IdezsZ.js";
-import { r as getDefaultActivityTransformers } from "./transformers-DXze6FUB.js";
-import { A as formatAcceptSignature, D as recordOutboxEnqueue, E as recordOutboxActivity, F as version, O as recordWebFingerHandle, P as name, S as recordCollectionTotalItems, T as recordInboxActivity, a as verifyRequestDetailed, b as recordCollectionPageItems, d as validateCryptoKey, f as getDurationMs, g as isAbortError, h as instrumentDocumentLoader, i as verifyRequest, k as registerQueueDepthGauge, m as getRemoteHost, n as parseRfc9421SignatureInput, o as exportJwk, p as getFederationMetrics, t as doubleKnock, u as importJwk, v as recordCircuitBreakerStateChange, w as recordFanoutRecipients, x as recordCollectionRequest, y as recordCollectionDispatchDuration } from "./http-BbnOMQoy.js";
-import { _ as hasSignatureLike, b as signJsonLd, c as getKeyOwner, f as compactJsonLd, g as hasSignature, h as getNormalizationContextLoader, i as verifyObject, l as InvalidContextReferenceError, m as detachSignature, n as hasProofLike, o as normalizeOutgoingActivityJsonLd, r as signObject, s as doesActorOwnKey, u as assertSafeJsonLd, v as isClearlyMalformedContextReference, w as wrapContextLoaderForJsonLd, x as verifyCompactJsonLd, y as isInvalidUrlTypeError } from "./proof-CqA-2nfW.js";
-import { n as getNodeInfo, t as nodeInfoToJson } from "./types-DC1pNgJA.js";
-import { n as getAuthenticatedDocumentLoader, t as kvCache } from "./kv-cache-ZQ22hm44.js";
+import { t as __exportAll } from "./rolldown-runtime-BC-Eo5Mj.js";
+import { r as getDefaultActivityTransformers } from "./transformers-DAtXl_Kc.js";
+import { A as formatAcceptSignature, D as recordOutboxEnqueue, E as recordOutboxActivity, F as version, O as recordWebFingerHandle, P as name, S as recordCollectionTotalItems, T as recordInboxActivity, a as verifyRequestDetailed, b as recordCollectionPageItems, d as validateCryptoKey, f as getDurationMs, g as isAbortError, h as instrumentDocumentLoader, i as verifyRequest, k as registerQueueDepthGauge, m as getRemoteHost, n as parseRfc9421SignatureInput, o as exportJwk, p as getFederationMetrics, t as doubleKnock, u as importJwk, v as recordCircuitBreakerStateChange, w as recordFanoutRecipients, x as recordCollectionRequest, y as recordCollectionDispatchDuration } from "./http-BIxGa6AG.js";
+import { S as verifyCompactJsonLd, T as wrapContextLoaderForJsonLd, _ as hasSignature, b as isInvalidUrlTypeError, c as doesActorOwnKey, d as assertSafeJsonLd, g as getNormalizationContextLoader, h as detachSignature, i as verifyObject, l as getKeyOwner, n as hasProofLike, p as compactJsonLd, r as signObject, s as normalizeOutgoingActivityJsonLd, u as InvalidContextReferenceError, v as hasSignatureLike, x as signJsonLd, y as isClearlyMalformedContextReference } from "./proof-BBLQXRWw.js";
+import { n as getNodeInfo, t as nodeInfoToJson } from "./types-Dtyf8lVj.js";
+import { n as getAuthenticatedDocumentLoader, t as kvCache } from "./kv-cache-BIAB0HKx.js";
 import { getLogger, withContext } from "@logtape/logtape";
 import { Router, RouterError, assertPath } from "@fedify/uri-template";
 import { Activity, Collection, CollectionPage, CryptographicKey, Link, Multikey, Object as Object$1, OrderedCollection, OrderedCollectionPage, Tombstone, getTypeId, lookupObject, traverseCollection } from "@fedify/vocab";
@@ -143,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 };
@@ -722,7 +724,13 @@ function createFederationBuilder() {
 }
 //#endregion
 //#region src/federation/circuit-breaker.ts
-const MAX_CUSTOM_FAILURE_HISTORY = 100;
+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.Duration.from({ minutes: 5 });
+const LEGACY_SWEEP_RETRY_WINDOW = Temporal.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
@@ -732,6 +740,8 @@ var CircuitBreaker = class {
 	#prefix;
 	#options;
 	#now;
+	#legacySweep;
+	#legacySweepDone;
 	#stateChangeObserver;
 	constructor(options) {
 		this.#kv = options.kv;
@@ -748,6 +758,7 @@ 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.Instant.compare(heldSince.add(this.#options.heldActivityTtl), now) <= 0) return {
@@ -829,6 +840,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;
@@ -849,6 +861,7 @@ 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);
@@ -896,26 +909,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) => {
+			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.Instant.compare(this.#now(), Temporal.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.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.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 {
@@ -955,18 +1064,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.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.");
@@ -982,9 +1098,11 @@ function normalizeCircuitBreakerOptions(options) {
 			const last = timestamps[timestamps.length - 1];
 			return Temporal.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,
@@ -992,10 +1110,72 @@ function normalizeCircuitBreakerOptions(options) {
 		recoveryDelay,
 		heldActivityTtl,
 		releaseInterval,
+		stateTtl,
 		onStateChange: options.onStateChange,
 		onActivityDrop: options.onActivityDrop
 	};
 }
+function maxDuration(duration, ...durations) {
+	return durations.reduce((max, candidate) => Temporal.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.Instant.from(value.retryUntil);
+		return Temporal.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.Instant.compare(now, Temporal.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.Instant.compare(now, Temporal.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.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.Duration.from(duration);
 	return Temporal.Duration.from({ milliseconds: Math.trunc(parsed.total({
@@ -1030,6 +1210,9 @@ 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 {
@@ -1049,7 +1232,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
@@ -1064,7 +1248,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;
@@ -1459,7 +1643,7 @@ function isMalformedDurationLiteral(value) {
 		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",
@@ -1468,7 +1652,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) {
@@ -1612,7 +1796,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",
@@ -3223,7 +3407,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(/=+$/, "");
 }
@@ -4099,6 +4283,24 @@ const logger = getLogger([
 	"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.
@@ -4147,7 +4349,7 @@ async function handleWebFinger(request, options) {
 		});
 	}
 }
-const WEBFINGER_HANDLE_SCHEME_WHITELIST = new Set([
+const WEBFINGER_HANDLE_SCHEME_WHITELIST = /* @__PURE__ */ new Set([
 	"acct",
 	"http",
 	"https",
@@ -4203,6 +4405,7 @@ async function handleWebFingerInternal(request, { context, host, actorDispatcher
 		return identifier;
 	}
 	let identifier = null;
+	let acctUsername = null;
 	const uriParsed = context.parseUri(resourceUrl);
 	if (uriParsed?.type != "actor") {
 		const match = /^acct:([^@]+)@([^@]+)$/.exec(resource);
@@ -4216,8 +4419,9 @@ async function handleWebFingerInternal(request, { context, host, actorDispatcher
 			const normalizedHost = portMatch == null ? domainToASCII(match[2].toLowerCase()) : 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;
@@ -4231,9 +4435,10 @@ async function handleWebFingerInternal(request, { context, host, actorDispatcher
 		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 Link && url.href != null) links.push({
@@ -4257,23 +4462,19 @@ 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": "*"
 	} });
@@ -7132,4 +7333,4 @@ function getRequestId(request) {
 	return `req_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
 }
 //#endregion
-export { SendActivityError as a, buildCollectionSynchronizationHeader as c, normalizeCircuitBreakerOptions as d, parseCircuitBreakerKvState as f, createExponentialBackoffPolicy as i, digest as l, middleware_exports as n, respondWithObject as o, createFederationBuilder as p, handleWebFinger as r, respondWithObjectIfAcceptable as s, createFederation as t, CircuitBreaker as u };
+export { respondWithObject as a, digest as c, parseCircuitBreakerKvState as d, createFederationBuilder as f, SendActivityError as i, CircuitBreaker as l, handleWebFinger as n, respondWithObjectIfAcceptable as o, createExponentialBackoffPolicy as r, buildCollectionSynchronizationHeader as s, createFederation as t, normalizeCircuitBreakerOptions as u };