@fedify/fedify 2.4.5-dev.2462 → 2.4.6-dev.2628

package/dist/{http-BVrOR6MG.js → http-rH230xCD.js}

@@ -15,7 +15,7 @@ import serialize from "json-canon";
 import { ATTR_HTTP_REQUEST_HEADER, ATTR_HTTP_REQUEST_METHOD, ATTR_URL_FULL } from "@opentelemetry/semantic-conventions";
 //#region deno.json
 var name = "@fedify/fedify";
-var version = "2.4.5-dev.2462+46a3f2c5";
+var version = "2.4.6-dev.2628+2a78382f";
 //#endregion
 //#region src/sig/portable-key-id.ts
 const COMPATIBLE_KEY_ID_PATH_PATTERN = /^\/\.well-known\/apgateway\/did(?::|%3A)/i;
@@ -6434,10 +6434,10 @@ async function createRedirectRequest(request, location, body, validateRedirect)
 		cache: request.cache
 	});
 }
-async function fetchDoubleKnockRequest(request, signedRequest, signal) {
+async function fetchDoubleKnockRequest(session, request, signedRequest, signal) {
 	const maxAttempts = request.method === "GET" || request.method === "HEAD" ? 2 : 1;
 	for (let attempt = 1;; attempt++) try {
-		return await fetch(signedRequest, {
+		return await session.fetch(signedRequest, {
 			redirect: "manual",
 			signal
 		});
@@ -6488,125 +6488,194 @@ function getAbortReason(signal) {
 	return signal.reason ?? new DOMException("The operation was aborted.", "AbortError");
 }
 /**
-* Performs a double-knock request to the given URL.  For the details of
-* double-knocking, see
-* <https://swicg.github.io/activitypub-http-signature/#how-to-upgrade-supported-versions>.
+* Performs a double-knock request like {@link doubleKnock}, opening a session
+* for every hop with the given function, and passes the final response to
+* the given function.  The final session is closed after `consume` settles,
+* so `consume` must read or cancel the response body before it returns.
+* This is not exported from any entry point.
 * @param request The request to send.
 * @param identity The identity to use for signing the request.
 * @param options The options for double-knock requests.
-* @returns The response to the request.
-* @since 1.6.0
+* @param openHop The function to open a session for each hop.  The session of
+*                a hop is closed before the next hop is opened.
+* @param consume The function to consume the final response.
+* @returns The value returned by `consume`.
 */
-async function doubleKnock(request, identity, options = {}) {
-	return await doubleKnockInternal(request, identity, options);
+async function doubleKnockScoped(request, identity, options, openHop, consume) {
+	const { response, session } = await doubleKnockCore(request, identity, options, openHop);
+	try {
+		return await consume(response);
+	} catch (error) {
+		getLogger([
+			"fedify",
+			"sig",
+			"http"
+		]).debug("Failed to consume the response from {url}; closing the session: {error}", {
+			url: request.url,
+			error
+		});
+		throw error;
+	} finally {
+		await session.close();
+	}
+}
+function isRedirectResponse(response) {
+	return response.status >= 300 && response.status < 400 && response.headers.has("Location");
 }
-async function doubleKnockInternal(request, identity, options, redirected = 0, visited = /* @__PURE__ */ new Set()) {
+/**
+* Starts cancelling the body of a response that is not passed to the caller,
+* 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) => {
+		getLogger([
+			"fedify",
+			"sig",
+			"http"
+		]).debug("Failed to cancel the response body from {url}: {error}", {
+			url,
+			error
+		});
+	});
+}
+async function doubleKnockCore(request, identity, options, openHop) {
 	const { specDeterminer, log, tracerProvider, signal } = options;
 	signal?.throwIfAborted();
 	const maximumRedirection = options.maxRedirection ?? DEFAULT_MAX_REDIRECTION;
-	visited.add(request.url);
-	const origin = new URL(request.url).origin;
-	const firstTrySpec = specDeterminer == null ? "rfc9421" : await specDeterminer.determineSpec(origin);
-	signal?.throwIfAborted();
+	const visited = /* @__PURE__ */ new Set();
 	const body = options.body !== void 0 ? options.body : request.method !== "GET" && request.method !== "HEAD" ? await request.clone().arrayBuffer() : null;
-	let signedRequest = await signRequest(request, identity.privateKey, identity.keyId, {
-		spec: firstTrySpec,
-		tracerProvider,
-		body
-	});
-	signal?.throwIfAborted();
-	log?.(signedRequest);
-	let response = await fetchDoubleKnockRequest(request, signedRequest, signal);
-	if (response.status >= 300 && response.status < 400 && response.headers.has("Location")) {
-		if (redirected >= maximumRedirection) throw new FetchError(request.url, `Too many redirections (${redirected + 1})`);
-		const redirectRequest = await createRedirectRequest(request, response.headers.get("Location"), body, options.validateRedirect);
-		if (visited.has(redirectRequest.url)) throw new FetchError(request.url, `Redirect loop detected: ${redirectRequest.url}`);
-		return doubleKnockInternal(redirectRequest, identity, {
-			...options,
-			body
-		}, redirected + 1, visited);
-	} else if (response.status === 400 || response.status === 401 || response.status > 401) {
-		const logger = getLogger([
-			"fedify",
-			"sig",
-			"http"
-		]);
-		const acceptSigHeader = response.headers.get("Accept-Signature");
-		if (acceptSigHeader != null) {
-			const entries = validateAcceptSignature(parseAcceptSignature(acceptSigHeader));
-			const localKeyId = identity.keyId.href;
-			const localAlg = "rsa-v1_5-sha256";
-			let fulfilled = false;
-			let challengeRequest;
-			for (const entry of entries) {
-				signal?.throwIfAborted();
-				const rfc9421 = fulfillAcceptSignature(entry, localKeyId, localAlg);
-				if (rfc9421 == null) continue;
-				logger.debug("Received Accept-Signature challenge; accumulating label {label} and components {components}.", {
-					label: rfc9421.label,
-					components: rfc9421.components
-				});
-				try {
-					challengeRequest = await signRequest(challengeRequest ?? request, identity.privateKey, identity.keyId, {
-						spec: "rfc9421",
-						tracerProvider,
-						body,
-						rfc9421
+	let session = await openHop(request.url);
+	try {
+		for (let redirected = 0;; redirected++) {
+			visited.add(request.url);
+			const origin = new URL(request.url).origin;
+			const firstTrySpec = specDeterminer == null ? "rfc9421" : await specDeterminer.determineSpec(origin);
+			signal?.throwIfAborted();
+			let signedRequest = await signRequest(request, identity.privateKey, identity.keyId, {
+				spec: firstTrySpec,
+				tracerProvider,
+				body
+			});
+			signal?.throwIfAborted();
+			log?.(signedRequest);
+			let response = await fetchDoubleKnockRequest(session, request, signedRequest, signal);
+			const firstRedirected = isRedirectResponse(response);
+			if (!firstRedirected && (response.status === 400 || response.status === 401 || response.status > 401)) {
+				const logger = getLogger([
+					"fedify",
+					"sig",
+					"http"
+				]);
+				const acceptSigHeader = response.headers.get("Accept-Signature");
+				if (acceptSigHeader != null) {
+					const entries = validateAcceptSignature(parseAcceptSignature(acceptSigHeader));
+					const localKeyId = identity.keyId.href;
+					const localAlg = "rsa-v1_5-sha256";
+					let fulfilled = false;
+					let challengeRequest;
+					for (const entry of entries) {
+						signal?.throwIfAborted();
+						const rfc9421 = fulfillAcceptSignature(entry, localKeyId, localAlg);
+						if (rfc9421 == null) continue;
+						logger.debug("Received Accept-Signature challenge; accumulating label {label} and components {components}.", {
+							label: rfc9421.label,
+							components: rfc9421.components
+						});
+						try {
+							challengeRequest = await signRequest(challengeRequest ?? request, identity.privateKey, identity.keyId, {
+								spec: "rfc9421",
+								tracerProvider,
+								body,
+								rfc9421
+							});
+							fulfilled = true;
+						} catch (error) {
+							logger.debug("Failed to fulfill Accept-Signature challenge entry {label}: {error}", {
+								label: entry.label,
+								error
+							});
+						}
+					}
+					if (fulfilled && challengeRequest != null) {
+						signal?.throwIfAborted();
+						cancelResponseBody(response, request.url);
+						signedRequest = challengeRequest;
+						log?.(signedRequest);
+						response = await session.fetch(signedRequest, {
+							redirect: "manual",
+							signal
+						});
+					}
+					if (fulfilled && !isRedirectResponse(response)) {
+						if (response.status < 300) {
+							await specDeterminer?.rememberSpec(origin, "rfc9421");
+							return {
+								response,
+								session
+							};
+						}
+						if (response.status !== 400 && response.status !== 401) return {
+							response,
+							session
+						};
+					}
+				}
+				if (!isRedirectResponse(response)) {
+					const spec = firstTrySpec === "draft-cavage-http-signatures-12" ? "rfc9421" : "draft-cavage-http-signatures-12";
+					getLogger([
+						"fedify",
+						"sig",
+						"http"
+					]).debug("Failed to verify with the spec {spec} ({status} {statusText}); retrying with spec {secondSpec}... (double-knocking)", {
+						spec: firstTrySpec,
+						secondSpec: spec,
+						status: response.status,
+						statusText: response.statusText
 					});
-					fulfilled = true;
-				} catch (error) {
-					logger.debug("Failed to fulfill Accept-Signature challenge entry {label}: {error}", {
-						label: entry.label,
-						error
+					cancelResponseBody(response, request.url);
+					signal?.throwIfAborted();
+					signedRequest = await signRequest(request, identity.privateKey, identity.keyId, {
+						spec,
+						tracerProvider,
+						body
 					});
+					signal?.throwIfAborted();
+					log?.(signedRequest);
+					response = await fetchDoubleKnockRequest(session, request, signedRequest, signal);
+					if (!isRedirectResponse(response) && response.status !== 400 && response.status !== 401) await specDeterminer?.rememberSpec(origin, spec);
 				}
-			}
-			if (fulfilled && challengeRequest != null) {
-				signal?.throwIfAborted();
-				signedRequest = challengeRequest;
-				log?.(signedRequest);
-				response = await fetch(signedRequest, {
-					redirect: "manual",
-					signal
-				});
-				if (response.status >= 300 && response.status < 400 && response.headers.has("Location")) return doubleKnock(await createRedirectRequest(request, response.headers.get("Location"), body, options.validateRedirect), identity, {
-					...options,
-					body
-				});
-			}
-			if (fulfilled && response.status < 300) {
-				await specDeterminer?.rememberSpec(origin, "rfc9421");
-				return response;
-			}
-			if (fulfilled && response.status !== 400 && response.status !== 401) return response;
-		}
-		const spec = firstTrySpec === "draft-cavage-http-signatures-12" ? "rfc9421" : "draft-cavage-http-signatures-12";
-		logger.debug("Failed to verify with the spec {spec} ({status} {statusText}); retrying with spec {secondSpec}... (double-knocking)", {
-			spec: firstTrySpec,
-			secondSpec: spec,
-			status: response.status,
-			statusText: response.statusText
-		});
-		signal?.throwIfAborted();
-		signedRequest = await signRequest(request, identity.privateKey, identity.keyId, {
-			spec,
-			tracerProvider,
-			body
-		});
-		signal?.throwIfAborted();
-		log?.(signedRequest);
-		response = await fetchDoubleKnockRequest(request, signedRequest, signal);
-		if (response.status >= 300 && response.status < 400 && response.headers.has("Location")) {
+			} else if (!firstRedirected) await specDeterminer?.rememberSpec(origin, firstTrySpec);
+			if (!isRedirectResponse(response)) return {
+				response,
+				session
+			};
+			cancelResponseBody(response, request.url);
+			await session.close();
 			if (redirected >= maximumRedirection) throw new FetchError(request.url, `Too many redirections (${redirected + 1})`);
-			const redirectRequest = await createRedirectRequest(request, response.headers.get("Location"), body, options.validateRedirect);
+			const location = response.headers.get("Location");
+			const redirectRequest = await createRedirectRequest(request, location, body, options.validateRedirect);
 			if (visited.has(redirectRequest.url)) throw new FetchError(request.url, `Redirect loop detected: ${redirectRequest.url}`);
-			return doubleKnockInternal(redirectRequest, identity, {
-				...options,
-				body
-			}, redirected + 1, visited);
-		} else if (response.status !== 400 && response.status !== 401) await specDeterminer?.rememberSpec(origin, spec);
-	} else await specDeterminer?.rememberSpec(origin, firstTrySpec);
-	return response;
+			request = redirectRequest;
+			session = await openHop(request.url);
+		}
+	} catch (error) {
+		try {
+			await session.close();
+		} catch (closeError) {
+			getLogger([
+				"fedify",
+				"sig",
+				"http"
+			]).debug("Failed to close the session for {url}: {error}", {
+				url: request.url,
+				error: closeError
+			});
+		}
+		throw error;
+	}
 }
 /**
 * Performs a timing-safe equality comparison between two `Uint8Array` values.
@@ -6636,4 +6705,4 @@ function timingSafeEqual(a, b) {
 	return result === 0;
 }
 //#endregion
-export { instrumentDocumentLoader as $, hasSignature as A, isPortableUri as At, fetchActorDocument as B, InvalidContextReferenceError as C, getGatewayKeyBase as Ct, createSignature as D, isCompatibleKeyId as Dt, compactJsonLd as E, hasPortableActor as Et, verifyCompactJsonLd as F, validateCryptoKey as G, fetchKeyDetailed as H, verifyJsonLd as I, getVerifiedKeyOwnerEvidence as J, verifyKeyOwnership as K, verifySignature as L, isClearlyMalformedContextReference as M, isSamePublicKey as Mt, isInvalidUrlTypeError as N, name as Nt, detachSignature as O, isPortableId as Ot, signJsonLd as P, version as Pt, getRemoteHost as Q, wrapContextLoaderForJsonLd as R, normalizeOutgoingActivityJsonLd as S, getCanonicalPortableId as St, attachSignature as T, getRawCanonicalPortableId as Tt, generateCryptoKeyPair as U, fetchKey as V, importJwk as W, getDurationMs as X, parseKeyOwnerEvidence as Y, getFederationMetrics as Z, verifyObject as _, validateAcceptSignature as _t, signRequest as a, recordCollectionTotalItems as at, verifyPortableObjectProofWithRoot as b, verificationObservation as bt, verifyRequestDetailed as c, recordInboxActivity as ct, InvalidPortableObjectIdError as d, recordWebFingerHandle as dt, isAbortError$1 as et, classifyFep2277CoreType as f, registerQueueDepthGauge as ft, verifyMapLocalProof as g, parseAcceptSignature as gt, signObject as h, fulfillAcceptSignature as ht, selectRequestSignature as i, recordCollectionRequest as it, hasSignatureLike as j, isSameObjectId as jt, getNormalizationContextLoader as k, isPortableKeyId as kt, fetchPortableGatewayKey as l, recordOutboxActivity as lt, hasProofLike as m, formatAcceptSignature as mt, listRequestSignatures as n, recordCollectionDispatchDuration as nt, validateMaxSignatures as o, recordDocumentCache as ot, createProof as p, preloadedOnlyDocumentLoader as pt, MAX_PORTABLE_KEY_TTL as q, parseRfc9421SignatureInput as r, recordCollectionPageItems as rt, verifyRequest as s, recordFanoutRecipients as st, doubleKnock as t, recordCircuitBreakerStateChange as tt, resolvePortableActorKey as u, recordOutboxEnqueue as ut, verifyPortableObjectProof as v, observeAttempt as vt, assertSafeJsonLd as w, getPortableDid as wt, verifyProof as x, getAuthenticationOrigin as xt, verifyPortableObjectProofPolicy as y, snapshotKey as yt, exportJwk as z };
+export { instrumentDocumentLoader as $, hasSignature as A, isPortableUri as At, fetchActorDocument as B, InvalidContextReferenceError as C, getGatewayKeyBase as Ct, createSignature as D, isCompatibleKeyId as Dt, compactJsonLd as E, hasPortableActor as Et, verifyCompactJsonLd as F, validateCryptoKey as G, fetchKeyDetailed as H, verifyJsonLd as I, getVerifiedKeyOwnerEvidence as J, verifyKeyOwnership as K, verifySignature as L, isClearlyMalformedContextReference as M, isSamePublicKey as Mt, isInvalidUrlTypeError as N, name as Nt, detachSignature as O, isPortableId as Ot, signJsonLd as P, version as Pt, getRemoteHost as Q, wrapContextLoaderForJsonLd as R, normalizeOutgoingActivityJsonLd as S, getCanonicalPortableId as St, attachSignature as T, getRawCanonicalPortableId as Tt, generateCryptoKeyPair as U, fetchKey as V, importJwk as W, getDurationMs as X, parseKeyOwnerEvidence as Y, getFederationMetrics as Z, verifyObject as _, validateAcceptSignature as _t, signRequest as a, recordCollectionTotalItems as at, verifyPortableObjectProofWithRoot as b, verificationObservation as bt, verifyRequestDetailed as c, recordInboxActivity as ct, InvalidPortableObjectIdError as d, recordWebFingerHandle as dt, isAbortError$1 as et, classifyFep2277CoreType as f, registerQueueDepthGauge as ft, verifyMapLocalProof as g, parseAcceptSignature as gt, signObject as h, fulfillAcceptSignature as ht, selectRequestSignature as i, recordCollectionRequest as it, hasSignatureLike as j, isSameObjectId as jt, getNormalizationContextLoader as k, isPortableKeyId as kt, fetchPortableGatewayKey as l, recordOutboxActivity as lt, hasProofLike as m, formatAcceptSignature as mt, listRequestSignatures as n, recordCollectionDispatchDuration as nt, validateMaxSignatures as o, recordDocumentCache as ot, createProof as p, preloadedOnlyDocumentLoader as pt, MAX_PORTABLE_KEY_TTL as q, parseRfc9421SignatureInput as r, recordCollectionPageItems as rt, verifyRequest as s, recordFanoutRecipients as st, doubleKnockScoped as t, recordCircuitBreakerStateChange as tt, resolvePortableActorKey as u, recordOutboxEnqueue as ut, verifyPortableObjectProof as v, observeAttempt as vt, assertSafeJsonLd as w, getPortableDid as wt, verifyProof as x, getAuthenticationOrigin as xt, verifyPortableObjectProofPolicy as y, snapshotKey as yt, exportJwk as z };

package/dist/{inbox-DtEKOr3W.mjs → inbox-BdZenpZQ.mjs}

@@ -2,8 +2,8 @@ import { Temporal } from "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 import { t as getAuthenticationOrigin } from "./portable-key-id-Ca30-hOa.mjs";
-import { n as version, t as name } from "./deno-BO7-a3hz.mjs";
-import { g as recordInboxActivity, n as getDurationMs, r as getFederationMetrics } from "./metrics-CGR9cI-Y.mjs";
+import { n as version, t as name } from "./deno-ksnVeCA7.mjs";
+import { g as recordInboxActivity, n as getDurationMs, r as getFederationMetrics } from "./metrics-DtxsYIkN.mjs";
 import { getLogger } from "@logtape/logtape";
 import { getTypeId } from "@fedify/vocab";
 import { SpanKind, SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";

package/dist/{key-DYxuyd-s.d.cts → key-CyCcut3h.d.ts}

@@ -1,8 +1,7 @@
 /// <reference lib="esnext.temporal" />
 import { Actor, CryptographicKey, DataIntegrityProof, Multikey, Object as Object$1 } from "@fedify/vocab";
-import { DocumentLoader, PortableObjectVerifier } from "@fedify/vocab-runtime";
 import { MeterProvider, TracerProvider } from "@opentelemetry/api";
-
+import { DocumentLoader, PortableObjectVerifier } from "@fedify/vocab-runtime";
 //#region src/sig/proof.d.ts
 /**
 * Checks if the given JSON-LD document has a DataIntegrityProof-like object,

package/dist/{key-C1nv7_jD.d.ts → key-VEL1QqHF.d.cts}

@@ -1,8 +1,7 @@
 /// <reference lib="esnext.temporal" />
 import { Actor, CryptographicKey, DataIntegrityProof, Multikey, Object as Object$1 } from "@fedify/vocab";
-import { MeterProvider, TracerProvider } from "@opentelemetry/api";
 import { DocumentLoader, PortableObjectVerifier } from "@fedify/vocab-runtime";
-
+import { MeterProvider, TracerProvider } from "@opentelemetry/api";
 //#region src/sig/proof.d.ts
 /**
 * Checks if the given JSON-LD document has a DataIntegrityProof-like object,

package/dist/{kv-cache-Dkzuqs8B.cjs → kv-cache-BpGIONmd.cjs}

@@ -1,8 +1,9 @@
 const { URLPattern } = require("urlpattern-polyfill");
-const require_http = require("./http-DLf8QYD6.cjs");
+const require_http = require("./http-CeVcKQMZ.cjs");
 let _logtape_logtape = require("@logtape/logtape");
 let _fedify_vocab_runtime = require("@fedify/vocab-runtime");
 let es_toolkit = require("es-toolkit");
+let _fedify_vocab_runtime_internal = require("@fedify/vocab-runtime/internal");
 //#region src/utils/docloader.ts
 const logger$1 = (0, _logtape_logtape.getLogger)([
 	"fedify",
@@ -26,13 +27,35 @@ const DEFAULT_MAX_REDIRECTION = 20;
 * @throws {RangeError} If the `timeout` option is invalid.
 * @since 0.4.0
 */
-function getAuthenticatedDocumentLoader(identity, { allowPrivateAddress, maxRedirection, userAgent, specDeterminer, timeout, 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, maxRedirection, userAgent, specDeterminer, timeout, tracerProvider } = {}, deps = {}) {
 	require_http.validateCryptoKey(identity.privateKey);
 	const resolvedTimeout = (0, _fedify_vocab_runtime.resolveDocumentLoaderTimeout)(timeout);
 	async function load(url, options, redirected = 0, visited = /* @__PURE__ */ new Set()) {
 		options?.signal?.throwIfAborted();
 		let currentUrl = new URL(url).href;
-		await validateUrl(currentUrl, options);
+		validateUrl(currentUrl);
 		visited.add(currentUrl);
 		const originalRequest = (0, _fedify_vocab_runtime.createActivityPubRequest)(currentUrl, { userAgent });
 		function follow(nextUrl) {
@@ -41,46 +64,68 @@ function getAuthenticatedDocumentLoader(identity, { allowPrivateAddress, maxRedi
 			if (visited.has(nextUrl)) throw new _fedify_vocab_runtime.FetchError(currentUrl, `Redirect loop detected: ${nextUrl}`);
 			redirected++;
 		}
-		const response = await require_http.doubleKnock(originalRequest, identity, {
+		const result = await require_http.doubleKnockScoped(originalRequest, identity, {
 			maxRedirection,
 			specDeterminer,
 			log: (0, es_toolkit.curry)(_fedify_vocab_runtime.logRequest)(logger$1),
 			tracerProvider,
 			signal: options?.signal,
-			validateRedirect: async (nextUrl) => {
+			validateRedirect: (nextUrl) => {
 				follow(nextUrl);
-				await validateUrl(nextUrl, options);
+				validateUrl(nextUrl);
 				visited.add(nextUrl);
 				currentUrl = nextUrl;
 			}
+		}, (hopUrl) => openHop(hopUrl, options), async (response) => {
+			options?.signal?.throwIfAborted();
+			let alternateUrl;
+			const document = await (0, _fedify_vocab_runtime.getRemoteDocument)(currentUrl, response, (url) => {
+				alternateUrl = url;
+				return Promise.resolve(ALTERNATE_PLACEHOLDER);
+			}, options);
+			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 };
 		});
 		options?.signal?.throwIfAborted();
-		return (0, _fedify_vocab_runtime.getRemoteDocument)(currentUrl, response, (alternateUrl) => {
-			follow(alternateUrl);
-			return load(alternateUrl, options, redirected, visited);
-		}, options);
+		if ("document" in result) return result.document;
+		follow(result.alternateUrl);
+		return load(result.alternateUrl, options, redirected, visited);
+	}
+	function openUnvalidatedHop(url, signal) {
+		if (deps.openHop != null) return deps.openHop(url);
+		return allowPrivateAddress ? (0, _fedify_vocab_runtime_internal.openDirectFetch)(url) : (0, _fedify_vocab_runtime_internal.openPublicFetch)(url, { signal });
 	}
-	async function validateUrl(url, options) {
+	async function openHop(url, options) {
+		try {
+			const session = await openUnvalidatedHop(url, options?.signal);
+			if (options?.signal?.aborted) {
+				await session.close();
+				options.signal.throwIfAborted();
+			}
+			return session;
+		} catch (error) {
+			if (error instanceof _fedify_vocab_runtime.UrlError) if (error.reason === "dns") logger$1.debug("DNS lookup failed for {url}", {
+				url,
+				error
+			});
+			else logger$1[options?.suppressError ? "warn" : "error"]("Disallowed private URL: {url}", {
+				url,
+				error
+			});
+			throw error;
+		}
+	}
+	function validateUrl(url) {
 		const parsedUrl = new URL(url);
 		const protocol = parsedUrl.protocol;
 		if (protocol !== "http:" && protocol !== "https:") throw new _fedify_vocab_runtime.UrlError(`Unsupported protocol: ${protocol}`);
 		if (parsedUrl.username !== "" || parsedUrl.password !== "") throw new _fedify_vocab_runtime.UrlError("URLs with credentials are not allowed");
-		if (!allowPrivateAddress) {
-			try {
-				await (0, _fedify_vocab_runtime.validatePublicUrl)(url);
-			} catch (error) {
-				if (error instanceof _fedify_vocab_runtime.UrlError) if (error.reason === "dns") logger$1.debug("DNS lookup failed for {url}", {
-					url,
-					error
-				});
-				else logger$1[options?.suppressError ? "warn" : "error"]("Disallowed private URL: {url}", {
-					url,
-					error
-				});
-				throw error;
-			}
-			options?.signal?.throwIfAborted();
-		}
 	}
 	return (0, _fedify_vocab_runtime.withDocumentLoaderTimeout)((url, options) => load(url, options), resolvedTimeout);
 }

package/dist/{kv-cache-DoZoRS9p.js → kv-cache-CNfNI_95.js}

@@ -1,9 +1,10 @@
 import { Temporal } from "temporal-polyfill";
 import { URLPattern } from "urlpattern-polyfill";
-import { G as validateCryptoKey, ot as recordDocumentCache, t as doubleKnock } from "./http-BVrOR6MG.js";
+import { G as validateCryptoKey, ot as recordDocumentCache, t as doubleKnockScoped } from "./http-rH230xCD.js";
 import { getLogger } from "@logtape/logtape";
-import { FetchError, UrlError, createActivityPubRequest, getRemoteDocument, logRequest, preloadedContexts, resolveDocumentLoaderTimeout, validatePublicUrl, withDocumentLoaderTimeout } from "@fedify/vocab-runtime";
+import { FetchError, UrlError, createActivityPubRequest, getRemoteDocument, logRequest, preloadedContexts, resolveDocumentLoaderTimeout, withDocumentLoaderTimeout } from "@fedify/vocab-runtime";
 import { curry } from "es-toolkit";
+import { openDirectFetch, openPublicFetch } from "@fedify/vocab-runtime/internal";
 //#region src/utils/docloader.ts
 const logger$1 = getLogger([
 	"fedify",
@@ -27,13 +28,35 @@ const DEFAULT_MAX_REDIRECTION = 20;
 * @throws {RangeError} If the `timeout` option is invalid.
 * @since 0.4.0
 */
-function getAuthenticatedDocumentLoader(identity, { allowPrivateAddress, maxRedirection, userAgent, specDeterminer, timeout, 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, maxRedirection, userAgent, specDeterminer, timeout, tracerProvider } = {}, deps = {}) {
 	validateCryptoKey(identity.privateKey);
 	const resolvedTimeout = resolveDocumentLoaderTimeout(timeout);
 	async function load(url, options, redirected = 0, visited = /* @__PURE__ */ new Set()) {
 		options?.signal?.throwIfAborted();
 		let currentUrl = new URL(url).href;
-		await validateUrl(currentUrl, options);
+		validateUrl(currentUrl);
 		visited.add(currentUrl);
 		const originalRequest = createActivityPubRequest(currentUrl, { userAgent });
 		function follow(nextUrl) {
@@ -42,46 +65,68 @@ function getAuthenticatedDocumentLoader(identity, { allowPrivateAddress, maxRedi
 			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, {
 			maxRedirection,
 			specDeterminer,
 			log: curry(logRequest)(logger$1),
 			tracerProvider,
 			signal: options?.signal,
-			validateRedirect: async (nextUrl) => {
+			validateRedirect: (nextUrl) => {
 				follow(nextUrl);
-				await validateUrl(nextUrl, options);
+				validateUrl(nextUrl);
 				visited.add(nextUrl);
 				currentUrl = nextUrl;
 			}
+		}, (hopUrl) => openHop(hopUrl, options), async (response) => {
+			options?.signal?.throwIfAborted();
+			let alternateUrl;
+			const document = await getRemoteDocument(currentUrl, response, (url) => {
+				alternateUrl = url;
+				return Promise.resolve(ALTERNATE_PLACEHOLDER);
+			}, options);
+			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 };
 		});
 		options?.signal?.throwIfAborted();
-		return getRemoteDocument(currentUrl, response, (alternateUrl) => {
-			follow(alternateUrl);
-			return load(alternateUrl, options, redirected, visited);
-		}, options);
+		if ("document" in result) return result.document;
+		follow(result.alternateUrl);
+		return load(result.alternateUrl, options, redirected, visited);
+	}
+	function openUnvalidatedHop(url, signal) {
+		if (deps.openHop != null) return deps.openHop(url);
+		return allowPrivateAddress ? openDirectFetch(url) : openPublicFetch(url, { signal });
+	}
+	async function openHop(url, options) {
+		try {
+			const session = await openUnvalidatedHop(url, options?.signal);
+			if (options?.signal?.aborted) {
+				await session.close();
+				options.signal.throwIfAborted();
+			}
+			return session;
+		} catch (error) {
+			if (error instanceof UrlError) if (error.reason === "dns") logger$1.debug("DNS lookup failed for {url}", {
+				url,
+				error
+			});
+			else logger$1[options?.suppressError ? "warn" : "error"]("Disallowed private URL: {url}", {
+				url,
+				error
+			});
+			throw error;
+		}
 	}
-	async function validateUrl(url, options) {
+	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");
-		if (!allowPrivateAddress) {
-			try {
-				await validatePublicUrl(url);
-			} catch (error) {
-				if (error instanceof UrlError) if (error.reason === "dns") logger$1.debug("DNS lookup failed for {url}", {
-					url,
-					error
-				});
-				else logger$1[options?.suppressError ? "warn" : "error"]("Disallowed private URL: {url}", {
-					url,
-					error
-				});
-				throw error;
-			}
-			options?.signal?.throwIfAborted();
-		}
 	}
 	return withDocumentLoaderTimeout((url, options) => load(url, options), resolvedTimeout);
 }

package/dist/{kv-cache-m3RIr811.mjs → kv-cache-Cxn7pNMx.mjs}

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