@fedify/fedify 2.1.29 → 2.1.31

package/dist/{kv-cache-8Kg2CHiD.js → kv-cache-DQcyZL5T.js}

@@ -1,9 +1,10 @@
 import { Temporal } from "@js-temporal/polyfill";
 import { URLPattern } from "urlpattern-polyfill";
-import { f as validateCryptoKey, t as doubleKnock } from "./http-B3rSb2GQ.js";
+import { f as validateCryptoKey, t as doubleKnockScoped } from "./http-Crml3gei.js";
 import { getLogger } from "@logtape/logtape";
 import { curry } from "es-toolkit";
-import { FetchError, UrlError, createActivityPubRequest, getRemoteDocument, logRequest, preloadedContexts, validatePublicUrl } from "@fedify/vocab-runtime";
+import { FetchError, UrlError, createActivityPubRequest, getRemoteDocument, logRequest, preloadedContexts } from "@fedify/vocab-runtime";
+import { openDirectFetch, openPublicFetch } from "@fedify/vocab-runtime/internal";
 //#region src/utils/docloader.ts
 const logger$1 = getLogger([
 	"fedify",
@@ -24,12 +25,34 @@ const DEFAULT_MAX_REDIRECTION = 20;
 * @throws {TypeError} If the key is invalid or unsupported.
 * @since 0.4.0
 */
-function getAuthenticatedDocumentLoader(identity, { allowPrivateAddress, userAgent, specDeterminer, tracerProvider } = {}) {
+function getAuthenticatedDocumentLoader(identity, options = {}) {
+	return createAuthenticatedDocumentLoader(identity, options);
+}
+/**
+* The placeholder that the alternate document callback of
+* `getRemoteDocument()` returns, so that the alternate document is loaded
+* after the current hop is closed.
+*/
+const ALTERNATE_PLACEHOLDER = Object.freeze({
+	contextUrl: null,
+	document: null,
+	documentUrl: "about:blank"
+});
+/**
+* The implementation of {@link getAuthenticatedDocumentLoader}.  This is not
+* exported from any entry point.
+* @param identity The identity to get the document loader for.
+* @param options The options for the document loader.
+* @param deps The dependencies, for tests.
+* @returns The authenticated document loader.
+* @throws {TypeError} If the key is invalid or unsupported.
+*/
+function createAuthenticatedDocumentLoader(identity, { allowPrivateAddress, userAgent, specDeterminer, tracerProvider } = {}, deps = {}) {
 	validateCryptoKey(identity.privateKey);
 	async function load(url, options, redirected = 0, visited = /* @__PURE__ */ new Set()) {
 		options?.signal?.throwIfAborted();
 		let currentUrl = new URL(url).href;
-		await validateUrl(currentUrl);
+		validateUrl(currentUrl);
 		visited.add(currentUrl);
 		const originalRequest = createActivityPubRequest(currentUrl, { userAgent });
 		function follow(nextUrl) {
@@ -38,28 +61,43 @@ function getAuthenticatedDocumentLoader(identity, { allowPrivateAddress, userAge
 			if (visited.has(nextUrl)) throw new FetchError(currentUrl, `Redirect loop detected: ${nextUrl}`);
 			redirected++;
 		}
-		const response = await doubleKnock(originalRequest, identity, {
+		const result = await doubleKnockScoped(originalRequest, identity, {
 			specDeterminer,
 			log: curry(logRequest)(logger$1),
 			tracerProvider,
 			signal: options?.signal,
-			validateRedirect: async (nextUrl) => {
+			validateRedirect: (nextUrl) => {
 				follow(nextUrl);
-				await validateUrl(nextUrl);
+				validateUrl(nextUrl);
 				visited.add(nextUrl);
 				currentUrl = nextUrl;
 			}
+		}, (hopUrl) => openHop(hopUrl, options?.signal), async (response) => {
+			let alternateUrl;
+			const document = await getRemoteDocument(currentUrl, response, (url) => {
+				alternateUrl = url;
+				return Promise.resolve(ALTERNATE_PLACEHOLDER);
+			});
+			if (alternateUrl == null) return { document };
+			if (!response.bodyUsed && response.body?.locked !== true) response.body?.cancel().catch((error) => {
+				logger$1.debug("Failed to cancel the response body from {url}: {error}", {
+					url: currentUrl,
+					error
+				});
+			});
+			return { alternateUrl };
 		});
-		return getRemoteDocument(currentUrl, response, (alternateUrl) => {
-			follow(alternateUrl);
-			return load(alternateUrl, options, redirected, visited);
-		});
+		if ("document" in result) return result.document;
+		follow(result.alternateUrl);
+		return load(result.alternateUrl, options, redirected, visited);
 	}
-	async function validateUrl(url) {
-		const protocol = new URL(url).protocol;
-		if (protocol !== "http:" && protocol !== "https:") throw new UrlError(`Unsupported protocol: ${protocol}`);
-		if (!allowPrivateAddress) try {
-			await validatePublicUrl(url);
+	function openUnvalidatedHop(url, signal) {
+		if (deps.openHop != null) return deps.openHop(url);
+		return allowPrivateAddress ? openDirectFetch(url) : openPublicFetch(url, { signal });
+	}
+	async function openHop(url, signal) {
+		try {
+			return await openUnvalidatedHop(url, signal);
 		} catch (error) {
 			if (error instanceof UrlError) if (error.reason === "dns") logger$1.debug("DNS lookup failed for {url}", {
 				url,
@@ -72,6 +110,12 @@ function getAuthenticatedDocumentLoader(identity, { allowPrivateAddress, userAge
 			throw error;
 		}
 	}
+	function validateUrl(url) {
+		const parsedUrl = new URL(url);
+		const protocol = parsedUrl.protocol;
+		if (protocol !== "http:" && protocol !== "https:") throw new UrlError(`Unsupported protocol: ${protocol}`);
+		if (parsedUrl.username !== "" || parsedUrl.password !== "") throw new UrlError("URLs with credentials are not allowed");
+	}
 	return (url, options) => load(url, options);
 }
 //#endregion

package/dist/{ld-C-fCGM-z.mjs → ld-COjDN6Nb.mjs}

@@ -1,8 +1,8 @@
 import "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as version, t as name } from "./deno-BiYv5RT5.mjs";
-import { r as fetchKey, s as validateCryptoKey } from "./key-O-ATwIGS.mjs";
+import { n as version, t as name } from "./deno-CiaJqTcu.mjs";
+import { r as fetchKey, s as validateCryptoKey } from "./key-Dg6-DV_O.mjs";
 import { Activity, CryptographicKey, Object as Object$1, getTypeId } from "@fedify/vocab";
 import { SpanStatusCode, trace } from "@opentelemetry/api";
 import { getDocumentLoader } from "@fedify/vocab-runtime";

package/dist/{middleware-CVRFS7PZ.cjs → middleware-BbgR7xOI.cjs}

@@ -2,10 +2,10 @@ const { Temporal } = require("@js-temporal/polyfill");
 const { URLPattern } = require("urlpattern-polyfill");
 const require_chunk = require("./chunk-DDcVe30Y.cjs");
 const require_transformers = require("./transformers-NeAONrAq.cjs");
-const require_http = require("./http-Cginz7L0.cjs");
-const require_types = require("./types-DRPjmHVV.cjs");
-const require_proof = require("./proof-BbHMAkPG.cjs");
-const require_kv_cache = require("./kv-cache-BdylAE9w.cjs");
+const require_http = require("./http-CRiVlZd5.cjs");
+const require_types = require("./types-DOvyymM4.cjs");
+const require_proof = require("./proof-0JkSC_pT.cjs");
+const require_kv_cache = require("./kv-cache-Cqmm-yQa.cjs");
 let _logtape_logtape = require("@logtape/logtape");
 let _fedify_vocab = require("@fedify/vocab");
 let _opentelemetry_api = require("@opentelemetry/api");
@@ -18,6 +18,7 @@ let _opentelemetry_semantic_conventions = require("@opentelemetry/semantic-conve
 let _fedify_vocab_runtime_jsonld = require("@fedify/vocab-runtime/jsonld");
 _fedify_vocab_runtime_jsonld = require_chunk.__toESM(_fedify_vocab_runtime_jsonld);
 let _fedify_webfinger = require("@fedify/webfinger");
+let _fedify_vocab_runtime_internal = require("@fedify/vocab-runtime/internal");
 let node_url = require("node:url");
 //#region src/federation/inbox.ts
 var InboxListenerSet = class InboxListenerSet {
@@ -350,7 +351,7 @@ var FederationBuilderImpl = class {
 		this.collectionTypeIds = {};
 	}
 	async build(options) {
-		const { FederationImpl } = await Promise.resolve().then(() => require("./middleware-VvrqPwHL.cjs"));
+		const { FederationImpl } = await Promise.resolve().then(() => require("./middleware-BtDQUCcz.cjs"));
 		const f = new FederationImpl(options);
 		const trailingSlashInsensitiveValue = f.router.trailingSlashInsensitive;
 		f.router = this.router.clone();
@@ -883,7 +884,7 @@ async function buildCollectionSynchronizationHeader(collectionId, actorIds) {
 }
 //#endregion
 //#region src/federation/keycache.ts
-const KEY_CACHE_GENERATION = "2";
+const KEY_CACHE_GENERATION = "3";
 var KvKeyCache = class {
 	kv;
 	prefix;
@@ -2478,9 +2479,10 @@ function extractInboxes({ recipients, preferSharedInbox, excludeBaseUris }) {
 *
 * @param parameters The parameters for sending the activity.
 *                   See also {@link SendActivityParameters}.
+* @param deps The dependencies, for tests.
 * @throws {Error} If the activity fails to send.
 */
-function sendActivity(options) {
+function sendActivity(options, deps = {}) {
 	const tracerProvider = options.tracerProvider ?? _opentelemetry_api.trace.getTracerProvider();
 	return tracerProvider.getTracer(require_http.name, require_http.version).startActiveSpan("activitypub.send_activity", {
 		kind: _opentelemetry_api.SpanKind.CLIENT,
@@ -2492,7 +2494,7 @@ function sendActivity(options) {
 			await sendActivityInternal({
 				...options,
 				tracerProvider
-			}, span);
+			}, span, deps);
 		} catch (e) {
 			span.setStatus({
 				code: _opentelemetry_api.SpanStatusCode.ERROR,
@@ -2526,21 +2528,25 @@ async function readLimitedResponseBody(response, maxBytes) {
 			totalBytes += value.length;
 		}
 	} finally {
+		if (truncated) reader.cancel().catch(() => {});
 		reader.releaseLock();
 	}
 	let result = chunks.join("");
 	if (truncated) result += "… (truncated)";
 	return result;
 }
-async function sendActivityInternal({ activity, activityId, keys, inbox, allowPrivateAddress, headers, specDeterminer, tracerProvider }, span) {
+async function sendActivityInternal({ activity, activityId, keys, inbox, allowPrivateAddress, headers, specDeterminer, tracerProvider }, span, deps) {
 	const logger = (0, _logtape_logtape.getLogger)([
 		"fedify",
 		"federation",
 		"outbox"
 	]);
-	async function validateUrl(url) {
-		if (!allowPrivateAddress) try {
-			await (0, _fedify_vocab_runtime.validatePublicUrl)(url);
+	const openUnvalidatedHop = deps.openHop ?? (allowPrivateAddress ? _fedify_vocab_runtime_internal.openDirectFetch : (url) => (0, _fedify_vocab_runtime_internal.openPublicFetch)(url));
+	let opened = false;
+	async function openHop(url) {
+		let session;
+		try {
+			session = await openUnvalidatedHop(url);
 		} catch (error) {
 			if (error instanceof _fedify_vocab_runtime.UrlError && error.reason === "dns") {
 				logger.error("DNS resolution failed for URL: {url}", {
@@ -2557,8 +2563,9 @@ async function sendActivityInternal({ activity, activityId, keys, inbox, allowPr
 			});
 			throw error;
 		}
+		opened = true;
+		return session;
 	}
-	await validateUrl(inbox.href);
 	headers = new Headers(headers);
 	headers.set("Content-Type", "application/activity+json");
 	const request = new Request(inbox, {
@@ -2579,36 +2586,30 @@ async function sendActivityInternal({ activity, activityId, keys, inbox, allowPr
 			privateKey: pair.privateKey
 		}))
 	});
-	let response;
+	let outcome;
 	try {
-		response = rsaKey == null ? await fetchWithValidatedRedirects(request, validateUrl) : await require_http.doubleKnock(request, rsaKey, {
+		outcome = rsaKey == null ? await fetchWithValidatedRedirects(request, openHop, (response) => consumeSendActivityResponse(response, inbox)) : await require_http.doubleKnockScoped(request, rsaKey, {
 			tracerProvider,
-			specDeterminer,
-			validateRedirect: validateUrl
-		});
+			specDeterminer
+		}, openHop, (response) => consumeSendActivityResponse(response, inbox));
 	} catch (error) {
-		logger.error("Failed to send activity {activityId} to {inbox}:\n{error}", {
+		if (opened) logger.error("Failed to send activity {activityId} to {inbox}:\n{error}", {
 			activityId,
 			inbox: inbox.href,
 			error
 		});
 		throw error;
 	}
-	if (!response.ok) {
-		let error;
-		try {
-			error = await readLimitedResponseBody(response, MAX_ERROR_RESPONSE_BODY_BYTES);
-		} catch (_) {
-			error = "";
-		}
+	if (!outcome.ok) {
+		const { status, statusText, error } = outcome;
 		logger.error("Failed to send activity {activityId} to {inbox} ({status} {statusText}):\n{error}", {
 			activityId,
 			inbox: inbox.href,
-			status: response.status,
-			statusText: response.statusText,
+			status,
+			statusText,
 			error
 		});
-		throw new SendActivityError(inbox, response.status, `Failed to send activity ${activityId} to ${inbox.href} (${response.status} ${response.statusText}):\n${error}`, error);
+		throw new SendActivityError(inbox, status, `Failed to send activity ${activityId} to ${inbox.href} (${status} ${statusText}):\n${error}`, error);
 	}
 	span.addEvent("activitypub.activity.sent", {
 		"activitypub.activity.json": JSON.stringify(activity),
@@ -2616,10 +2617,74 @@ async function sendActivityInternal({ activity, activityId, keys, inbox, allowPr
 		"activitypub.activity.id": activityId ?? ""
 	});
 }
-async function fetchWithValidatedRedirects(request, validateUrl) {
+/**
+* Starts cancelling the body of a response without waiting for it to settle.
+* The cancellation of a branch of a tee (e.g., a body cloned by a fetch mock)
+* settles only after the other branch is cancelled too, per the Streams
+* standard, so awaiting it could block forever.  Failures are only logged.
+*/
+function cancelResponseBody(response, url) {
+	response.body?.cancel().catch((error) => {
+		(0, _logtape_logtape.getLogger)([
+			"fedify",
+			"federation",
+			"outbox"
+		]).debug("Failed to cancel the response body from {url}: {error}", {
+			url,
+			error
+		});
+	});
+}
+/**
+* Reads what is needed from the final response of a delivery while its
+* session is open: the body of a successful response is cancelled, and at
+* most 1 KiB of an error response body is read.
+*/
+async function consumeSendActivityResponse(response, inbox) {
+	if (response.ok) {
+		cancelResponseBody(response, response.url || inbox.href);
+		return { ok: true };
+	}
+	let error;
+	try {
+		error = await readLimitedResponseBody(response, MAX_ERROR_RESPONSE_BODY_BYTES);
+	} catch (_) {
+		error = "";
+	}
+	return {
+		ok: false,
+		status: response.status,
+		statusText: response.statusText,
+		error
+	};
+}
+/**
+* Sends a request without signing it, following redirects manually like the
+* Fetch standard does.  Every hop is opened with `openHop()`, which validates
+* the destination, after the previous hop is closed.  The final response is
+* passed to `consume()`, and its session is closed after that.
+* This is exported only for tests; it is not exported from any entry point.
+* @param request The request to send.
+* @param openHop The function to open a session for each hop.
+* @param consume The function to consume the final response.
+* @returns The value returned by `consume`.
+*/
+async function fetchWithValidatedRedirects(request, openHop, consume) {
+	const logger = (0, _logtape_logtape.getLogger)([
+		"fedify",
+		"federation",
+		"outbox"
+	]);
 	let body = await request.clone().text();
 	for (let redirects = 0;; redirects++) {
-		const response = await fetch(request, { redirect: "manual" });
+		const session = await openHop(request.url);
+		let response;
+		try {
+			response = await session.fetch(request, { redirect: "manual" });
+		} catch (error) {
+			await closeAfterError(session, logger);
+			throw error;
+		}
 		const location = response.headers.get("Location");
 		if (![
 			301,
@@ -2627,11 +2692,21 @@ async function fetchWithValidatedRedirects(request, validateUrl) {
 			303,
 			307,
 			308
-		].includes(response.status) || location == null) return response;
-		await response.body?.cancel();
+		].includes(response.status) || location == null) try {
+			return await consume(response);
+		} catch (error) {
+			logger.debug("Failed to consume the response from {url}; closing the session: {error}", {
+				url: request.url,
+				error
+			});
+			throw error;
+		} finally {
+			await session.close();
+		}
+		cancelResponseBody(response, request.url);
+		await session.close();
 		if (redirects >= 20) throw new TypeError("Too many redirects");
 		const url = new URL(location, request.url);
-		await validateUrl(url.href);
 		const headers = new Headers(request.headers);
 		if (url.origin !== new URL(request.url).origin) {
 			headers.delete("Authorization");
@@ -2659,6 +2734,16 @@ async function fetchWithValidatedRedirects(request, validateUrl) {
 		});
 	}
 }
+async function closeAfterError(session, logger) {
+	try {
+		await session.close();
+	} catch (error) {
+		logger.debug("Failed to close the session for {url}: {error}", {
+			url: session.url.href,
+			error
+		});
+	}
+}
 /**
 * An error that is thrown when an activity fails to send to a remote inbox.
 * It contains structured information about the failure, including the HTTP
@@ -4591,43 +4676,83 @@ var RequestContextImpl = class RequestContextImpl extends ContextImpl {
 			}
 		}), values);
 	}
-	#signedKey = void 0;
+	#signedKey = null;
+	#signedKeyOwner = null;
+	#signatureChecks = /* @__PURE__ */ new WeakMap();
+	#getSignatureCheck(documentLoader, contextLoader) {
+		let checks = this.#signatureChecks.get(documentLoader);
+		if (checks == null) {
+			checks = /* @__PURE__ */ new WeakMap();
+			this.#signatureChecks.set(documentLoader, checks);
+		}
+		let check = checks.get(contextLoader);
+		if (check == null) {
+			check = {};
+			checks.set(contextLoader, check);
+		}
+		return check;
+	}
 	async getSignedKey(options = {}) {
 		if (this.#signedKey != null) return this.#signedKey;
-		return this.#signedKey = await require_http.verifyRequest(this.request, {
+		const documentLoader = options.documentLoader ?? this.documentLoader;
+		const contextLoader = options.contextLoader ?? this.contextLoader;
+		const check = this.#getSignatureCheck(documentLoader, contextLoader);
+		if (check.key != null) return check.key;
+		const promise = require_http.verifyRequest(this.request, {
 			...this,
-			contextLoader: options.contextLoader ?? this.contextLoader,
-			documentLoader: options.documentLoader ?? this.documentLoader,
+			contextLoader,
+			documentLoader,
 			timeWindow: this.federation.signatureTimeWindow,
 			tracerProvider: options.tracerProvider ?? this.tracerProvider
+		}).then((key) => {
+			if (key != null) this.#signedKey ??= key;
+			return key;
+		}).catch((error) => {
+			if (check.key === promise) check.key = void 0;
+			throw error;
 		});
+		check.key = promise;
+		return await promise;
 	}
-	#signedKeyOwner = void 0;
 	async getSignedKeyOwner(options = {}) {
 		if (this.#signedKeyOwner != null) return this.#signedKeyOwner;
-		const key = await this.getSignedKey(options);
-		if (key == null) return this.#signedKeyOwner = null;
-		try {
-			return this.#signedKeyOwner = await require_proof.getKeyOwner(key, {
-				contextLoader: options.contextLoader ?? this.contextLoader,
-				documentLoader: options.documentLoader ?? this.documentLoader,
-				tracerProvider: options.tracerProvider ?? this.tracerProvider
-			});
-		} catch (error) {
-			if (error instanceof _fedify_vocab_runtime.FetchError) {
-				(0, _logtape_logtape.getLogger)([
-					"fedify",
-					"federation",
-					"actor"
-				]).warn("Failed to fetch the key owner {keyOwner} of {keyId} while verifying the request signature; treating the request as unauthenticated: {error}", {
-					keyId: key.id?.href,
-					keyOwner: error.url.href,
-					error
-				});
-				return this.#signedKeyOwner = null;
+		const normalizedOptions = {
+			documentLoader: options.documentLoader ?? this.documentLoader,
+			contextLoader: options.contextLoader ?? this.contextLoader,
+			tracerProvider: options.tracerProvider ?? this.tracerProvider
+		};
+		const check = this.#getSignatureCheck(normalizedOptions.documentLoader, normalizedOptions.contextLoader);
+		if (check.owner != null) return check.owner;
+		const promise = this.getSignedKey(normalizedOptions).then(async (key) => {
+			if (key == null) {
+				if (check.owner === promise) check.owner = void 0;
+				return null;
 			}
+			try {
+				const owner = await require_proof.getKeyOwner(key, normalizedOptions);
+				if (owner != null) this.#signedKeyOwner ??= owner;
+				return owner;
+			} catch (error) {
+				if (error instanceof _fedify_vocab_runtime.FetchError) {
+					(0, _logtape_logtape.getLogger)([
+						"fedify",
+						"federation",
+						"actor"
+					]).warn("Failed to fetch the key owner {keyOwner} of {keyId} while verifying the request signature; treating the request as unauthenticated: {error}", {
+						keyId: key.id?.href,
+						keyOwner: error.url.href,
+						error
+					});
+					return null;
+				}
+				throw error;
+			}
+		}).catch((error) => {
+			if (check.owner === promise) check.owner = void 0;
 			throw error;
-		}
+		});
+		check.owner = promise;
+		return await promise;
 	}
 };
 var InboxContextImpl = class InboxContextImpl extends ContextImpl {

package/dist/{middleware-VvrqPwHL.cjs → middleware-BtDQUCcz.cjs}

@@ -1,4 +1,4 @@
 const { Temporal } = require("@js-temporal/polyfill");
 const { URLPattern } = require("urlpattern-polyfill");
-const require_middleware = require("./middleware-CVRFS7PZ.cjs");
+const require_middleware = require("./middleware-BbgR7xOI.cjs");
 exports.FederationImpl = require_middleware.FederationImpl;

package/dist/{middleware-C9UCWOqw.mjs → middleware-COFlKeYn.mjs}

@@ -2,25 +2,25 @@ import { Temporal } from "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 import { n as RouterError } from "./router-CrMLXoOr.mjs";
-import { n as version, t as name } from "./deno-BiYv5RT5.mjs";
+import { n as version, t as name } from "./deno-CiaJqTcu.mjs";
 import { t as formatAcceptSignature } from "./accept-BavzedPB.mjs";
-import { o as importJwk, s as validateCryptoKey, t as exportJwk } from "./key-O-ATwIGS.mjs";
-import { l as verifyRequest, o as parseRfc9421SignatureInput, u as verifyRequestDetailed } from "./http-C1ga9WQu.mjs";
-import { t as getAuthenticatedDocumentLoader } from "./docloader-DrxXBFL8.mjs";
+import { o as importJwk, s as validateCryptoKey, t as exportJwk } from "./key-Dg6-DV_O.mjs";
+import { d as verifyRequestDetailed, s as parseRfc9421SignatureInput, u as verifyRequest } from "./http-A9mP2uM7.mjs";
+import { n as getAuthenticatedDocumentLoader } from "./docloader-DOrwedT7.mjs";
 import { n as kvCache } from "./kv-cache-DqEKe5E0.mjs";
-import { t as KvKeyCache } from "./keycache-RFlZObU3.mjs";
-import { a as compactJsonLd, c as getNormalizationContextLoader, d as isInvalidUrlTypeError, f as signJsonLd, g as wrapContextLoaderForJsonLd, l as hasSignature, p as verifyCompactJsonLd, r as assertSafeJsonLd, s as detachSignature, t as InvalidContextReferenceError, u as isClearlyMalformedContextReference } from "./ld-C-fCGM-z.mjs";
-import { n as getKeyOwner, t as doesActorOwnKey } from "./owner-C8IVASD3.mjs";
-import { n as signObject, r as verifyObject } from "./proof-CUdcBgvg.mjs";
-import { d as readBoundedText, l as BodyTooLargeError, t as getNodeInfo, u as MAX_BODY_SIZE } from "./client-CjDMsn4a.mjs";
+import { t as KvKeyCache } from "./keycache-DahCaG_m.mjs";
+import { a as compactJsonLd, c as getNormalizationContextLoader, d as isInvalidUrlTypeError, f as signJsonLd, g as wrapContextLoaderForJsonLd, l as hasSignature, p as verifyCompactJsonLd, r as assertSafeJsonLd, s as detachSignature, t as InvalidContextReferenceError, u as isClearlyMalformedContextReference } from "./ld-COjDN6Nb.mjs";
+import { n as getKeyOwner, t as doesActorOwnKey } from "./owner-CFHq61cq.mjs";
+import { n as signObject, r as verifyObject } from "./proof-KSHlbPCG.mjs";
+import { d as MAX_BODY_SIZE, f as readBoundedText, t as getNodeInfo, u as BodyTooLargeError } from "./client-BZr7TGyu.mjs";
 import { t as nodeInfoToJson } from "./types-DCP0WLdt.mjs";
-import { n as actorsHaveSameOrigin, r as routeActivity } from "./inbox-BWzL0xMU.mjs";
-import { t as FederationBuilderImpl } from "./builder-Mg2G3qj8.mjs";
+import { n as actorsHaveSameOrigin, r as routeActivity } from "./inbox-KESLudq4.mjs";
+import { t as FederationBuilderImpl } from "./builder-isMRh_I6.mjs";
 import { t as buildCollectionSynchronizationHeader } from "./collection-BD6-SZ6O.mjs";
 import { t as acceptsJsonLd } from "./negotiation-BehA2uul.mjs";
-import { t as hasMalformedKnownTemporalLiteral } from "./temporal-BJlnku_d.mjs";
+import { t as hasMalformedKnownTemporalLiteral } from "./temporal-DNGH8o2E.mjs";
 import { t as createExponentialBackoffPolicy } from "./retry-B_E3V_Dx.mjs";
-import { n as extractInboxes, r as sendActivity, t as SendActivityError } from "./send-BoV4dyVO.mjs";
+import { i as sendActivity, n as extractInboxes, t as SendActivityError } from "./send-DaDe2YCb.mjs";
 import { Activity, Collection, CollectionPage, CryptographicKey, Link, Multikey, Object as Object$1, OrderedCollection, OrderedCollectionPage, getTypeId, lookupObject, traverseCollection } from "@fedify/vocab";
 import { lookupWebFinger } from "@fedify/webfinger";
 import { SpanKind, SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
@@ -3275,43 +3275,83 @@ var RequestContextImpl = class RequestContextImpl extends ContextImpl {
 			}
 		}), values);
 	}
-	#signedKey = void 0;
+	#signedKey = null;
+	#signedKeyOwner = null;
+	#signatureChecks = /* @__PURE__ */ new WeakMap();
+	#getSignatureCheck(documentLoader, contextLoader) {
+		let checks = this.#signatureChecks.get(documentLoader);
+		if (checks == null) {
+			checks = /* @__PURE__ */ new WeakMap();
+			this.#signatureChecks.set(documentLoader, checks);
+		}
+		let check = checks.get(contextLoader);
+		if (check == null) {
+			check = {};
+			checks.set(contextLoader, check);
+		}
+		return check;
+	}
 	async getSignedKey(options = {}) {
 		if (this.#signedKey != null) return this.#signedKey;
-		return this.#signedKey = await verifyRequest(this.request, {
+		const documentLoader = options.documentLoader ?? this.documentLoader;
+		const contextLoader = options.contextLoader ?? this.contextLoader;
+		const check = this.#getSignatureCheck(documentLoader, contextLoader);
+		if (check.key != null) return check.key;
+		const promise = verifyRequest(this.request, {
 			...this,
-			contextLoader: options.contextLoader ?? this.contextLoader,
-			documentLoader: options.documentLoader ?? this.documentLoader,
+			contextLoader,
+			documentLoader,
 			timeWindow: this.federation.signatureTimeWindow,
 			tracerProvider: options.tracerProvider ?? this.tracerProvider
+		}).then((key) => {
+			if (key != null) this.#signedKey ??= key;
+			return key;
+		}).catch((error) => {
+			if (check.key === promise) check.key = void 0;
+			throw error;
 		});
+		check.key = promise;
+		return await promise;
 	}
-	#signedKeyOwner = void 0;
 	async getSignedKeyOwner(options = {}) {
 		if (this.#signedKeyOwner != null) return this.#signedKeyOwner;
-		const key = await this.getSignedKey(options);
-		if (key == null) return this.#signedKeyOwner = null;
-		try {
-			return this.#signedKeyOwner = await getKeyOwner(key, {
-				contextLoader: options.contextLoader ?? this.contextLoader,
-				documentLoader: options.documentLoader ?? this.documentLoader,
-				tracerProvider: options.tracerProvider ?? this.tracerProvider
-			});
-		} catch (error) {
-			if (error instanceof FetchError) {
-				getLogger([
-					"fedify",
-					"federation",
-					"actor"
-				]).warn("Failed to fetch the key owner {keyOwner} of {keyId} while verifying the request signature; treating the request as unauthenticated: {error}", {
-					keyId: key.id?.href,
-					keyOwner: error.url.href,
-					error
-				});
-				return this.#signedKeyOwner = null;
+		const normalizedOptions = {
+			documentLoader: options.documentLoader ?? this.documentLoader,
+			contextLoader: options.contextLoader ?? this.contextLoader,
+			tracerProvider: options.tracerProvider ?? this.tracerProvider
+		};
+		const check = this.#getSignatureCheck(normalizedOptions.documentLoader, normalizedOptions.contextLoader);
+		if (check.owner != null) return check.owner;
+		const promise = this.getSignedKey(normalizedOptions).then(async (key) => {
+			if (key == null) {
+				if (check.owner === promise) check.owner = void 0;
+				return null;
 			}
+			try {
+				const owner = await getKeyOwner(key, normalizedOptions);
+				if (owner != null) this.#signedKeyOwner ??= owner;
+				return owner;
+			} catch (error) {
+				if (error instanceof FetchError) {
+					getLogger([
+						"fedify",
+						"federation",
+						"actor"
+					]).warn("Failed to fetch the key owner {keyOwner} of {keyId} while verifying the request signature; treating the request as unauthenticated: {error}", {
+						keyId: key.id?.href,
+						keyOwner: error.url.href,
+						error
+					});
+					return null;
+				}
+				throw error;
+			}
+		}).catch((error) => {
+			if (check.owner === promise) check.owner = void 0;
 			throw error;
-		}
+		});
+		check.owner = promise;
+		return await promise;
 	}
 };
 var InboxContextImpl = class InboxContextImpl extends ContextImpl {