@fedify/fedify 2.4.0-dev.1666 → 2.4.0-dev.1727

package/README.md

@@ -207,7 +207,7 @@ This project exists thanks to all the people who contribute, donate, and sponsor
 it.  We are grateful for their support.  We would like to thank the following
 financial contributors:[^2]
 
-[^2]: Those lists are automatically updated every hour.
+[^2]: Those lists are automatically updated twice a day.
 
 <!-- hongdown-disable -->
 

package/dist/{assert-CJ1KXcvv.mjs → assert-CebeUf0C.mjs}

@@ -1,7 +1,7 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { l as AssertionError } from "./assert_equals-BV7oLMxm.mjs";
+import { l as AssertionError } from "./assert_equals-CBlRfA-_.mjs";
 //#region ../../node_modules/.pnpm/@jsr+std__assert@0.226.0/node_modules/@jsr/std__assert/assert.js
 /**
 * Make an assertion, error will be thrown if `expr` does not have truthy value.

package/dist/assert_exists-DtzkXC47.mjs

@@ -0,0 +1,28 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { l as AssertionError } from "./assert_equals-CBlRfA-_.mjs";
+//#region ../../node_modules/.pnpm/@jsr+std__assert@0.226.0/node_modules/@jsr/std__assert/assert_exists.js
+/**
+* Make an assertion that actual is not null or undefined.
+* If not then throw.
+*
+* @example Usage
+* ```ts no-eval
+* import { assertExists } from "@std/assert/assert-exists";
+*
+* assertExists("something"); // Doesn't throw
+* assertExists(undefined); // Throws
+* ```
+*
+* @typeParam T The type of the actual value.
+* @param actual The actual value to check.
+* @param msg The optional message to include in the error if the assertion fails.
+*/ function assertExists(actual, msg) {
+	if (actual === void 0 || actual === null) {
+		msg = `Expected actual: "${actual}" to not be null or undefined${msg ? `: ${msg}` : "."}`;
+		throw new AssertionError(msg);
+	}
+}
+//#endregion
+export { assertExists as t };

package/dist/assert_false-3pLLLsO4.mjs

@@ -0,0 +1,23 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { l as AssertionError } from "./assert_equals-CBlRfA-_.mjs";
+//#region ../../node_modules/.pnpm/@jsr+std__assert@0.226.0/node_modules/@jsr/std__assert/assert_false.js
+/**
+* Make an assertion, error will be thrown if `expr` have truthy value.
+*
+* @example Usage
+* ```ts no-eval
+* import { assertFalse } from "@std/assert/assert-false";
+*
+* assertFalse(false); // Doesn't throw
+* assertFalse(true); // Throws
+* ```
+*
+* @param expr The expression to test.
+* @param msg The optional message to display if the assertion fails.
+*/ function assertFalse(expr, msg = "") {
+	if (expr) throw new AssertionError(msg);
+}
+//#endregion
+export { assertFalse as t };

package/dist/assert_greater_or_equal-BApOTh1h.mjs

@@ -0,0 +1,30 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { l as AssertionError, s as format } from "./assert_equals-CBlRfA-_.mjs";
+//#region ../../node_modules/.pnpm/@jsr+std__assert@0.226.0/node_modules/@jsr/std__assert/assert_greater_or_equal.js
+/**
+* Make an assertion that `actual` is greater than or equal to `expected`.
+* If not then throw.
+*
+* @example Usage
+* ```ts no-eval
+* import { assertGreaterOrEqual } from "@std/assert/assert-greater-or-equal";
+*
+* assertGreaterOrEqual(2, 1); // Doesn't throw
+* assertGreaterOrEqual(1, 1); // Doesn't throw
+* assertGreaterOrEqual(0, 1); // Throws
+* ```
+*
+* @typeParam T The type of the values to compare.
+* @param actual The actual value to compare.
+* @param expected The expected value to compare.
+* @param msg The optional message to display if the assertion fails.
+*/ function assertGreaterOrEqual(actual, expected, msg) {
+	if (actual >= expected) return;
+	const actualString = format(actual);
+	const expectedString = format(expected);
+	throw new AssertionError(msg ?? `Expect ${actualString} >= ${expectedString}`);
+}
+//#endregion
+export { assertGreaterOrEqual as t };

package/dist/{assert_instance_of-Q9KTBnrf.mjs → assert_instance_of-g3WcyYNR.mjs}

@@ -1,7 +1,7 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { l as AssertionError } from "./assert_equals-BV7oLMxm.mjs";
+import { l as AssertionError } from "./assert_equals-CBlRfA-_.mjs";
 //#region ../../node_modules/.pnpm/@jsr+std__assert@0.226.0/node_modules/@jsr/std__assert/assert_instance_of.js
 /**
 * Make an assertion that `obj` is an instance of `type`.

package/dist/{assert_not_equals-EPJPoxuf.mjs → assert_not_equals-BN7yDMWe.mjs}

@@ -1,7 +1,7 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { c as equal, l as AssertionError } from "./assert_equals-BV7oLMxm.mjs";
+import { c as equal, l as AssertionError } from "./assert_equals-CBlRfA-_.mjs";
 //#region ../../node_modules/.pnpm/@jsr+std__assert@0.226.0/node_modules/@jsr/std__assert/assert_not_equals.js
 /**
 * Make an assertion that `actual` and `expected` are not equal, deeply.

package/dist/assert_rejects-wFbSPn1O.mjs

@@ -0,0 +1,39 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { l as AssertionError } from "./assert_equals-CBlRfA-_.mjs";
+import { n as assertIsError } from "./assert_throws-BJ5wuvR2.mjs";
+//#region ../../node_modules/.pnpm/@jsr+std__assert@0.226.0/node_modules/@jsr/std__assert/assert_rejects.js
+async function assertRejects(fn, errorClassOrMsg, msgIncludesOrMsg, msg) {
+	let ErrorClass = void 0;
+	let msgIncludes = void 0;
+	let err;
+	if (typeof errorClassOrMsg !== "string") {
+		if (errorClassOrMsg === void 0 || errorClassOrMsg.prototype instanceof Error || errorClassOrMsg.prototype === Error.prototype) {
+			ErrorClass = errorClassOrMsg;
+			msgIncludes = msgIncludesOrMsg;
+		}
+	} else msg = errorClassOrMsg;
+	let doesThrow = false;
+	let isPromiseReturned = false;
+	const msgSuffix = msg ? `: ${msg}` : ".";
+	try {
+		const possiblePromise = fn();
+		if (possiblePromise && typeof possiblePromise === "object" && typeof possiblePromise.then === "function") {
+			isPromiseReturned = true;
+			await possiblePromise;
+		} else throw Error();
+	} catch (error) {
+		if (!isPromiseReturned) throw new AssertionError(`Function throws when expected to reject${msgSuffix}`);
+		if (ErrorClass) {
+			if (!(error instanceof Error)) throw new AssertionError(`A non-Error object was rejected${msgSuffix}`);
+			assertIsError(error, ErrorClass, msgIncludes, msg);
+		}
+		err = error;
+		doesThrow = true;
+	}
+	if (!doesThrow) throw new AssertionError(`Expected function to reject${msgSuffix}`);
+	return err;
+}
+//#endregion
+export { assertRejects as t };

package/dist/{assert_strict_equals-Ec20AUwa.mjs → assert_strict_equals-Bpjl4Psw.mjs}

@@ -1,7 +1,7 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { a as red, i as buildMessage, l as AssertionError, n as diffStr, r as diff, s as format } from "./assert_equals-BV7oLMxm.mjs";
+import { a as red, i as buildMessage, l as AssertionError, n as diffStr, r as diff, s as format } from "./assert_equals-CBlRfA-_.mjs";
 //#region ../../node_modules/.pnpm/@jsr+std__assert@0.226.0/node_modules/@jsr/std__assert/assert_strict_equals.js
 /**
 * Make an assertion that `actual` and `expected` are equal using

package/dist/{assert_throws-NiFfqbnH.mjs → assert_throws-BJ5wuvR2.mjs}

@@ -1,7 +1,7 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { l as AssertionError, o as stripAnsiCode } from "./assert_equals-BV7oLMxm.mjs";
+import { l as AssertionError, o as stripAnsiCode } from "./assert_equals-CBlRfA-_.mjs";
 //#region ../../node_modules/.pnpm/@jsr+std__assert@0.226.0/node_modules/@jsr/std__assert/assert_is_error.js
 /**
 * Make an assertion that `error` is an `Error`.

package/dist/{builder-BGpBs-US.mjs → builder-f5-YwHfj.mjs}

@@ -1,8 +1,8 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as version, t as name } from "./deno-CaQlEENR.mjs";
-import { t as ActivityListenerSet } from "./activity-listener-BtTSxZWA.mjs";
+import { n as version, t as name } from "./deno-Deyoxesx.mjs";
+import { t as ActivityListenerSet } from "./activity-listener-C-BSbKI7.mjs";
 import { getLogger } from "@logtape/logtape";
 import { Router, RouterError, assertPath } from "@fedify/uri-template";
 import { Tombstone, getTypeId } from "@fedify/vocab";
@@ -85,7 +85,7 @@ var FederationBuilderImpl = class {
 	* specified.
 	*/
 	async build(options) {
-		const { FederationImpl } = await import("./middleware-C4oS_tdq.mjs");
+		const { FederationImpl } = await import("./middleware-LPbZz6-1.mjs");
 		const f = new FederationImpl(options);
 		const trailingSlashInsensitiveValue = f.router.trailingSlashInsensitive;
 		f.router = this.router.clone();
@@ -96,6 +96,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 };

package/dist/{circuit-breaker-CBGyz5F7.mjs → circuit-breaker-BT7CiPbz.mjs}

@@ -3,7 +3,13 @@ import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 import { getLogger } from "@logtape/logtape";
 //#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
@@ -13,6 +19,8 @@ var CircuitBreaker = class {
 	#prefix;
 	#options;
 	#now;
+	#legacySweep;
+	#legacySweepDone;
 	#stateChangeObserver;
 	constructor(options) {
 		this.#kv = options.kv;
@@ -29,6 +37,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 {
@@ -110,6 +119,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;
@@ -130,6 +140,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);
@@ -177,26 +188,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 {
@@ -236,18 +343,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.");
@@ -263,9 +377,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,
@@ -273,10 +389,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({
@@ -311,6 +489,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 {
@@ -330,7 +511,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

package/dist/circuit-breaker-test-utils-BYIHoliq.mjs

@@ -0,0 +1,14 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+//#region src/federation/circuit-breaker-test-utils.ts
+function markCircuitBreakerLegacySweepDone(kv) {
+	return kv.set([
+		"_fedify",
+		"circuit",
+		"__fedify_meta",
+		"circuit_breaker_state_ttl_sweep_v1"
+	], { state: "final" });
+}
+//#endregion
+export { markCircuitBreakerLegacySweepDone as t };

package/dist/{client-CjF5IYQS.mjs → client-CtxvmazV.mjs}

@@ -2,22 +2,79 @@ import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 import { getLogger } from "@logtape/logtape";
-import { getUserAgent } from "@fedify/vocab-runtime";
+import { UrlError, getUserAgent, validatePublicUrl } from "@fedify/vocab-runtime";
 //#region src/nodeinfo/client.ts
 const logger = getLogger([
 	"fedify",
 	"nodeinfo",
 	"client"
 ]);
+const DEFAULT_MAX_REDIRECTION = 5;
+/**
+* Fetches a URL while guarding against SSRF.  Before every request—including
+* each redirect hop—the destination is validated with
+* {@link validatePublicUrl}, so that loopback, link-local, and private
+* addresses, as well as non-HTTP(S) schemes such as `data:`, are rejected.
+* Redirects are followed manually with a cap, so that a public URL cannot
+* bounce the request to an internal address.
+* @param url The URL to fetch.
+* @param headers The request headers.
+* @returns The final response, or `null` if the URL is disallowed or there
+*          are too many redirects.
+*/
+async function fetchPublicUrl(url, headers) {
+	let current = url instanceof URL ? url : new URL(url);
+	let redirected = 0;
+	while (true) {
+		try {
+			await validatePublicUrl(current.href);
+		} catch (e) {
+			if (e instanceof UrlError) {
+				logger.error("Refused to fetch a private or invalid URL {url}: {error}", {
+					url: current.href,
+					error: e
+				});
+				return null;
+			}
+			throw e;
+		}
+		const response = await fetch(current, {
+			headers,
+			redirect: "manual"
+		});
+		if (response.status >= 300 && response.status < 400 && response.headers.has("Location")) {
+			redirected++;
+			if (redirected >= DEFAULT_MAX_REDIRECTION) {
+				logger.error("Too many redirections ({redirections}) while fetching {url}.", {
+					redirections: redirected,
+					url: current.href
+				});
+				return null;
+			}
+			const next = new URL(response.headers.get("Location"), response.url == null || response.url === "" ? current : response.url);
+			if (next.protocol !== current.protocol) {
+				logger.error("Refused a redirect to a different protocol ({protocol} to {redirectedProtocol}) while fetching NodeInfo.", {
+					protocol: current.protocol,
+					redirectedProtocol: next.protocol
+				});
+				return null;
+			}
+			current = next;
+			continue;
+		}
+		return response;
+	}
+}
 async function getNodeInfo(url, options = {}) {
 	try {
 		let nodeInfoUrl = url;
 		if (!options.direct) {
 			const wellKnownUrl = new URL("/.well-known/nodeinfo", url);
-			const wellKnownResponse = await fetch(wellKnownUrl, { headers: {
+			const wellKnownResponse = await fetchPublicUrl(wellKnownUrl, {
 				Accept: "application/json",
 				"User-Agent": typeof options.userAgent === "string" ? options.userAgent : getUserAgent(options.userAgent)
-			} });
+			});
+			if (wellKnownResponse == null) return void 0;
 			if (!wellKnownResponse.ok) {
 				logger.error("Failed to fetch {url}: {status} {statusText}", {
 					url: wellKnownUrl.href,
@@ -37,10 +94,11 @@ async function getNodeInfo(url, options = {}) {
 			}
 			nodeInfoUrl = link.href;
 		}
-		const response = await fetch(nodeInfoUrl, { headers: {
+		const response = await fetchPublicUrl(nodeInfoUrl, {
 			Accept: "application/json",
 			"User-Agent": typeof options.userAgent === "string" ? options.userAgent : getUserAgent(options.userAgent)
-		} });
+		});
+		if (response == null) return void 0;
 		if (!response.ok) {
 			logger.error("Failed to fetch NodeInfo document from {url}: {status} {statusText}", {
 				url: nodeInfoUrl.toString(),

package/dist/{collection-BIhlldqK.mjs → collection-CnnP1UAv.mjs}

@@ -13,7 +13,7 @@ import { encodeHex } from "byte-encodings/hex";
 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;

package/dist/compat/mod.cjs

@@ -1,6 +1,6 @@
 const { URLPattern } = require("urlpattern-polyfill");
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_transformers = require("../transformers-DGwl-hD1.cjs");
+const require_transformers = require("../transformers-BalCrSsr.cjs");
 exports.actorDehydrator = require_transformers.actorDehydrator;
 exports.autoIdAssigner = require_transformers.autoIdAssigner;
 exports.getDefaultActivityTransformers = require_transformers.getDefaultActivityTransformers;

package/dist/compat/mod.d.cts

@@ -1,5 +1,5 @@
 /// <reference lib="esnext.temporal" />
-import { Rt as ActivityTransformer, n as Context } from "../context-C05Rgxmu.cjs";
+import { Gt as ActivityTransformer, n as Context } from "../context-B-dsBjZ9.cjs";
 import { Activity } from "@fedify/vocab";
 
 //#region src/compat/transformers.d.ts

package/dist/compat/mod.d.ts

@@ -1,5 +1,5 @@
 /// <reference lib="esnext.temporal" />
-import { Rt as ActivityTransformer, n as Context } from "../context-Cjnr0ig1.js";
+import { Gt as ActivityTransformer, n as Context } from "../context-DrLXudbA.js";
 import { Activity } from "@fedify/vocab";
 
 //#region src/compat/transformers.d.ts