@fedify/fedify 2.4.0-pr.936.41 → 2.5.0-dev.2271

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

@@ -3,7 +3,14 @@ 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_v2"];
+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_RENEW_INTERVAL = Temporal.Duration.from({ minutes: 1 });
+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 +20,8 @@ var CircuitBreaker = class {
 	#prefix;
 	#options;
 	#now;
+	#legacySweep;
+	#legacySweepDone;
 	#stateChangeObserver;
 	constructor(options) {
 		this.#kv = options.kv;
@@ -29,6 +38,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 {
@@ -37,7 +47,7 @@ var CircuitBreaker = class {
 		};
 		let lastConflictingState;
 		for (let attempt = 0; attempt < 10; attempt++) {
-			const oldState = await this.#get(remoteHost);
+			const { state: oldState, raw: oldValue } = await this.#get(remoteHost);
 			if (oldState == null || oldState.state === "closed") return {
 				type: "send",
 				probe: false
@@ -63,7 +73,7 @@ var CircuitBreaker = class {
 					state: "half-open",
 					halfOpened: now.toString()
 				};
-				if (await this.#replace(remoteHost, oldState, newState)) return {
+				if (await this.#replace(remoteHost, oldValue, newState)) return {
 					type: "send",
 					probe: true
 				};
@@ -85,7 +95,7 @@ var CircuitBreaker = class {
 				state: "half-open",
 				halfOpened: now.toString()
 			};
-			if (await this.#replace(remoteHost, oldState, newState)) {
+			if (await this.#replace(remoteHost, oldValue, newState)) {
 				await this.#notifyStateChange(remoteHost, "open", "half-open");
 				return {
 					type: "send",
@@ -110,10 +120,11 @@ 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);
+			const { state: oldState, raw: oldValue } = await this.#get(remoteHost);
 			if (oldState == null) return void 0;
-			if (await this.#replace(remoteHost, oldState, void 0)) {
+			if (await this.#replace(remoteHost, oldValue, void 0)) {
 				if (oldState.state !== "closed") {
 					await this.#notifyStateChange(remoteHost, oldState.state, "closed");
 					return {
@@ -130,9 +141,10 @@ 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);
+			const { state: oldState, raw: oldValue } = await this.#get(remoteHost);
 			if (oldState?.state === "open") return void 0;
 			const oldFailures = oldState?.failures.map(Temporal.Instant.from) ?? [];
 			const failures = this.#options.pruneFailures([...oldFailures, now], now);
@@ -149,7 +161,7 @@ var CircuitBreaker = class {
 				state: "closed",
 				failures: failures.map((t) => t.toString())
 			};
-			if (await this.#replace(remoteHost, oldState, newState)) {
+			if (await this.#replace(remoteHost, oldValue, newState)) {
 				if (transition != null) {
 					await this.#notifyStateChange(remoteHost, transition[0], transition[1]);
 					return {
@@ -177,26 +189,146 @@ var CircuitBreaker = class {
 		}
 	}
 	async getState(remoteHost) {
-		return await this.#get(remoteHost);
+		this.#sweepLegacyStates();
+		return stripStoredCircuitBreakerState((await this.#get(remoteHost)).state);
+	}
+	/**
+	* 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 acquired = await this.#acquireLegacySweep(markerKey);
+		if (acquired === "done") return;
+		let marker = acquired;
+		let leaseRenewedAt = this.#now();
+		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);
+				if (Temporal.Instant.compare(this.#now(), leaseRenewedAt.add(LEGACY_SWEEP_RENEW_INTERVAL)) >= 0) {
+					const renewed = await this.#renewLegacySweep(markerKey, marker);
+					if (renewed == null) return;
+					marker = renewed;
+					leaseRenewedAt = this.#now();
+				}
+			}
+		} 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);
+	}
+	async #renewLegacySweep(markerKey, marker) {
+		const renewed = {
+			state: "sweeping",
+			started: this.#now().toString(),
+			retryUntil: getLegacySweepRetryUntil(marker) ?? this.#now().add(LEGACY_SWEEP_RETRY_WINDOW).toString()
+		};
+		if (await this.#kv.cas(markerKey, marker, renewed, { ttl: LEGACY_SWEEP_LOCK_TTL })) return renewed;
+	}
+	#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)) {
+			await this.#kv.cas(key, value, value, this.#setOptions());
+			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)));
+		const value = await this.#kv.get(this.#key(remoteHost));
+		const state = parseStoredCircuitBreakerKvState(value);
+		return {
+			state,
+			raw: state == null ? void 0 : value
+		};
 	}
-	async #replace(remoteHost, oldState, newState) {
+	async #replace(remoteHost, oldValue, 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, oldValue, 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 +368,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 +402,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 ?? recoveryDelay.add(heldActivityTtl);
 	}
 	return {
 		failure,
@@ -273,10 +414,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 +514,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 +536,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-DW6YC_Pe.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_v2"
+	], { state: "final" });
+}
+//#endregion
+export { markCircuitBreakerLegacySweepDone as t };

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

@@ -2,22 +2,157 @@ import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 import { getLogger } from "@logtape/logtape";
-import { getUserAgent } from "@fedify/vocab-runtime";
+import { FetchError, UrlError, getUserAgent, validatePublicUrl } from "@fedify/vocab-runtime";
+//#region src/utils/body.ts
+/** Decoded JSON body limit: 16 MiB.  @internal */
+const MAX_BODY_SIZE = 16 * 1024 * 1024;
+/** A body exceeded the byte limit.  @internal */
+var BodyTooLargeError = class extends FetchError {
+	/** Creates an error for a body exceeding the given limit. */
+	constructor(url, maxBytes) {
+		super(url, `Body exceeds the limit of ${maxBytes} bytes`);
+		this.name = "BodyTooLargeError";
+	}
+};
+/** Validates a finite, positive byte limit.  @internal */
+function validateBodySizeLimit(maxBytes) {
+	if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0) throw new RangeError("The body size limit must be a positive safe integer.");
+}
+/**
+* Reads UTF-8 text while limiting bytes received from the body stream.
+* Fetch responses are already decompressed, so the stream count is authoritative.
+* @param message The response or request to read.
+* @param maxBytes The maximum number of decoded bytes to read.
+* @param url The URL to include in errors and logs.
+* @returns The decoded body text.
+* @throws {BodyTooLargeError} If the body exceeds the limit.
+* @internal
+*/
+async function readBoundedText(message, maxBytes, url) {
+	validateBodySizeLimit(maxBytes);
+	const reader = message.body?.getReader();
+	const tooLarge = () => {
+		getLogger([
+			"fedify",
+			"runtime",
+			"body"
+		]).warn("Body from {url} exceeds the limit of {maxBytes} bytes.", {
+			url: url.toString(),
+			maxBytes
+		});
+		throw new BodyTooLargeError(url, maxBytes);
+	};
+	try {
+		const length = message.headers.get("Content-Length");
+		const encoding = message.headers.get("Content-Encoding");
+		if ((encoding == null || encoding.toLowerCase() === "identity") && length != null && /^\d+$/.test(length) && Number(length) > maxBytes) tooLarge();
+		if (reader == null) return "";
+		let size = 0;
+		const textReader = new ReadableStream({ async pull(controller) {
+			const { done, value } = await reader.read();
+			if (done) {
+				controller.close();
+				return;
+			}
+			size += value.byteLength;
+			if (size > maxBytes) tooLarge();
+			controller.enqueue(value);
+		} }, { highWaterMark: 0 }).pipeThrough(new TextDecoderStream()).getReader();
+		try {
+			const chunks = [];
+			while (true) {
+				const { done, value } = await textReader.read();
+				if (done) break;
+				chunks.push(value);
+			}
+			return chunks.join("");
+		} finally {
+			textReader.releaseLock();
+		}
+	} catch (error) {
+		if (reader != null) reader.cancel(error).catch(() => {});
+		throw error;
+	} finally {
+		reader?.releaseLock();
+	}
+}
+//#endregion
 //#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, its
+*          hostname cannot be resolved, 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) {
+				if (e.reason === "dns") logger.error("DNS lookup failed for {url}: {error}", {
+					url: current.href,
+					error: e
+				});
+				else 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,
@@ -26,7 +161,7 @@ async function getNodeInfo(url, options = {}) {
 				});
 				return;
 			}
-			const wellKnownRd = await wellKnownResponse.json();
+			const wellKnownRd = JSON.parse(await readBoundedText(wellKnownResponse, MAX_BODY_SIZE, wellKnownUrl));
 			const link = wellKnownRd?.links?.find((link) => link != null && "rel" in link && (link.rel === "http://nodeinfo.diaspora.software/ns/schema/2.0" || link.rel === "http://nodeinfo.diaspora.software/ns/schema/2.1") && "href" in link && link.href != null);
 			if (link == null || link.href == null) {
 				logger.error("Failed to find a NodeInfo document link from {url}: {resourceDescriptor}", {
@@ -37,10 +172,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(),
@@ -49,7 +185,7 @@ async function getNodeInfo(url, options = {}) {
 			});
 			return;
 		}
-		const data = await response.json();
+		const data = JSON.parse(await readBoundedText(response, MAX_BODY_SIZE, nodeInfoUrl));
 		if (options.parse === "none") return data;
 		return parseNodeInfo(data, { tryBestEffort: options.parse === "best-effort" }) ?? void 0;
 	} catch (error) {
@@ -253,4 +389,4 @@ function parseUsage(data, options = {}) {
 	};
 }
 //#endregion
-export { parseProtocol as a, parseUsage as c, parseOutboundService as i, parseInboundService as n, parseServices as o, parseNodeInfo as r, parseSoftware as s, getNodeInfo as t };
+export { parseProtocol as a, parseUsage as c, readBoundedText as d, parseOutboundService as i, BodyTooLargeError as l, parseInboundService as n, parseServices as o, parseNodeInfo as r, parseSoftware as s, getNodeInfo as t, MAX_BODY_SIZE as u };

package/dist/{codec-BBga-FWI.mjs → codec-C6rTrpIp.mjs}

@@ -1,4 +1,4 @@
-import "temporal-polyfill";
+import { Temporal } from "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 import { Link, Object as Object$1 } from "@fedify/vocab";
@@ -16,8 +16,14 @@ var TaskCodec = class TaskCodec {
 		this.options = options;
 	}
 	/** Serializes `data`, encoding any vocabulary object as its JSON-LD. */
-	serialize = (data) => stringifyAsync(data, { Vocab: this.#stringifyVocab });
-	deserialize = async (raw) => await this.#revive(/* @__PURE__ */ new Map())(parse(raw, { Vocab: VocabHolder.from }));
+	serialize = (data) => stringifyAsync(data, {
+		Vocab: this.#stringifyVocab,
+		FedifyTemporal: stringifyTemporal
+	});
+	deserialize = async (raw) => await this.#revive(/* @__PURE__ */ new Map())(parse(raw, {
+		Vocab: VocabHolder.from,
+		FedifyTemporal: parseTemporal
+	}));
 	/** Validates `data` against `schema`, then serializes it. */
 	encode = async (schema, data) => this.serialize(await TaskCodec.validate(schema, data));
 	/** Deserializes `raw`, then validates the result against `schema`. */
@@ -83,6 +89,23 @@ var TaskCodec = class TaskCodec {
 	];
 };
 const isVocab = (value) => value instanceof Object$1 || value instanceof Link;
+const temporalTypeNames = [
+	"Duration",
+	"Instant",
+	"PlainDate",
+	"PlainTime",
+	"PlainDateTime",
+	"PlainMonthDay",
+	"PlainYearMonth",
+	"ZonedDateTime"
+];
+function stringifyTemporal(value) {
+	for (const name of temporalTypeNames) if (value instanceof Temporal[name]) return [name, value.toString()];
+	return false;
+}
+function parseTemporal([name, value]) {
+	return Temporal[name].from(value);
+}
 const isPlainObject = (value) => value === null || typeof value !== "object" ? false : isObjectPrototype(globalThis.Object.getPrototypeOf(value));
 const isObjectPrototype = (proto) => proto === null || proto === globalThis.Object.prototype;
 const isInstanceOf = (cls) => (v) => v instanceof cls;

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-lxX6I7as.cjs";
+import { en as ActivityTransformer, n as Context } from "../context-tsYPJ2Ew.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-Zii1f5xS.js";
+import { en as ActivityTransformer, n as Context } from "../context-7NyiqIcg.js";
 import { Activity } from "@fedify/vocab";
 
 //#region src/compat/transformers.d.ts

package/dist/compat/mod.js

@@ -1,4 +1,4 @@
 import { Temporal } from "temporal-polyfill";
 import { URLPattern } from "urlpattern-polyfill";
-import { n as autoIdAssigner, r as getDefaultActivityTransformers, t as actorDehydrator } from "../transformers-DXze6FUB.js";
+import { n as autoIdAssigner, r as getDefaultActivityTransformers, t as actorDehydrator } from "../transformers-DAtXl_Kc.js";
 export { actorDehydrator, autoIdAssigner, getDefaultActivityTransformers };