@fedify/webfinger 2.2.18 → 2.2.20

package/dist/lookup.test.cjs

@@ -23,11 +23,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 //#endregion
 let _fedify_fixture = require("@fedify/fixture");
 let _fedify_vocab_runtime = require("@fedify/vocab-runtime");
+let _fedify_vocab_runtime_internal = require("@fedify/vocab-runtime/internal");
 let _logtape_logtape = require("@logtape/logtape");
 let es_toolkit = require("es-toolkit");
 let node_assert_strict = require("node:assert/strict");
-let node_dns_promises = require("node:dns/promises");
-node_dns_promises = __toESM(node_dns_promises);
 let _opentelemetry_api = require("@opentelemetry/api");
 //#endregion
 //#region ../../node_modules/.pnpm/regexparam@3.0.0/node_modules/regexparam/dist/index.mjs
@@ -1230,7 +1229,7 @@ var esm_default = new class FetchMock {
 //#endregion
 //#region deno.json
 var name = "@fedify/webfinger";
-var version = "2.2.18";
+var version = "2.2.20";
 //#endregion
 //#region src/body.ts
 /** Decoded JSON body limit: 16 MiB.  @internal */
@@ -1306,7 +1305,7 @@ async function readBoundedText(message, maxBytes, url) {
 	}
 }
 //#endregion
-//#region src/lookup.ts
+//#region src/lookup-impl.ts
 const logger = (0, _logtape_logtape.getLogger)([
 	"fedify",
 	"webfinger",
@@ -1314,36 +1313,16 @@ const logger = (0, _logtape_logtape.getLogger)([
 ]);
 const DEFAULT_MAX_REDIRECTION = 5;
 /**
-* Looks up a WebFinger resource.
+* Looks up a WebFinger resource, opening a fetch session per hop.  This is
+* the implementation of {@link lookupWebFinger}, which is not exported from
+* the package entry point.
 * @param resource The resource URL to look up.
 * @param options Extra options for looking up the resource.
+* @param deps The dependencies.
 * @returns The resource descriptor, or `null` if not found.
-* @since 0.2.0
+* @internal
 */
-async function lookupWebFinger(resource, options = {}) {
-	return await (options.tracerProvider ?? _opentelemetry_api.trace.getTracerProvider()).getTracer(name, version).startActiveSpan("webfinger.lookup", {
-		kind: _opentelemetry_api.SpanKind.CLIENT,
-		attributes: {
-			"webfinger.resource": resource.toString(),
-			"webfinger.resource.scheme": typeof resource === "string" ? resource.replace(/:.*$/, "") : resource.protocol.replace(/:$/, "")
-		}
-	}, async (span) => {
-		try {
-			const result = await lookupWebFingerInternal(resource, options);
-			span.setStatus({ code: result === null ? _opentelemetry_api.SpanStatusCode.ERROR : _opentelemetry_api.SpanStatusCode.OK });
-			return result;
-		} catch (error) {
-			span.setStatus({
-				code: _opentelemetry_api.SpanStatusCode.ERROR,
-				message: String(error)
-			});
-			throw error;
-		} finally {
-			span.end();
-		}
-	});
-}
-async function lookupWebFingerInternal(resource, options = {}) {
+async function lookupWebFingerInternal(resource, options = {}, deps = {}) {
 	if (typeof resource === "string") resource = new URL(resource);
 	let protocol = "https:";
 	let server;
@@ -1358,84 +1337,175 @@ async function lookupWebFingerInternal(resource, options = {}) {
 	}
 	let url = new URL(`${protocol}//${server}/.well-known/webfinger`);
 	url.searchParams.set("resource", resource.href);
+	const openHop = deps.openHop ?? ((hopUrl) => options.allowPrivateAddress === true ? (0, _fedify_vocab_runtime_internal.openDirectFetch)(hopUrl) : (0, _fedify_vocab_runtime_internal.openPublicFetch)(hopUrl, { signal: options.signal }));
 	let redirected = 0;
 	while (true) {
 		logger.debug("Fetching WebFinger resource descriptor from {url}...", { url: url.href });
-		let response;
-		if (options.allowPrivateAddress !== true) try {
-			await (0, _fedify_vocab_runtime.validatePublicUrl)(url.href);
-		} catch (e) {
-			if (e instanceof _fedify_vocab_runtime.UrlError) {
-				if (e.reason === "dns") logger.debug("DNS lookup failed for {url}", {
-					url: url.href,
-					error: e
-				});
-				else logger.error("Invalid URL for WebFinger resource descriptor: {error}", { error: e });
-				return null;
-			}
-			throw e;
-		}
+		const session = await openSession(url, openHop, options.signal);
+		if (session == null) return null;
+		let hop;
 		try {
-			response = await fetch(url, {
-				headers: {
-					Accept: "application/jrd+json",
-					"User-Agent": typeof options.userAgent === "string" ? options.userAgent : (0, _fedify_vocab_runtime.getUserAgent)(options.userAgent)
-				},
-				redirect: "manual",
-				signal: options.signal
+			hop = await fetchHop(session, url, options);
+		} finally {
+			await session.close();
+		}
+		if ("result" in hop) return hop.result;
+		redirected++;
+		const maxRedirection = options.maxRedirection ?? DEFAULT_MAX_REDIRECTION;
+		if (redirected >= maxRedirection) {
+			logger.error("Too many redirections ({redirections}) while fetching WebFinger resource descriptor.", { redirections: redirected });
+			return null;
+		}
+		const redirectedUrl = new URL(hop.redirect, url);
+		if (redirectedUrl.protocol !== url.protocol) {
+			logger.error("Redirected to a different protocol ({protocol} to {redirectedProtocol}) while fetching WebFinger resource descriptor.", {
+				protocol: url.protocol,
+				redirectedProtocol: redirectedUrl.protocol
 			});
-		} catch (error) {
-			logger.debug("Failed to fetch WebFinger resource descriptor: {error}", {
+			return null;
+		}
+		url = redirectedUrl;
+	}
+}
+/**
+* Opens a fetch session for a hop.  A disallowed URL, a failed DNS lookup,
+* or an aborted lookup yields `null` instead of an error.
+*/
+async function openSession(url, openHop, signal) {
+	try {
+		return await openHop(url.href);
+	} catch (e) {
+		if (e instanceof _fedify_vocab_runtime.UrlError) {
+			if (e.reason === "dns") logger.debug("DNS lookup failed for {url}", {
 				url: url.href,
-				error
+				error: e
 			});
+			else logger.error("Invalid URL for WebFinger resource descriptor: {error}", { error: e });
 			return null;
 		}
-		if (response.status >= 300 && response.status < 400 && response.headers.has("Location")) {
-			redirected++;
-			const maxRedirection = options.maxRedirection ?? DEFAULT_MAX_REDIRECTION;
-			if (redirected >= maxRedirection) {
-				logger.error("Too many redirections ({redirections}) while fetching WebFinger resource descriptor.", { redirections: redirected });
-				return null;
-			}
-			const redirectedUrl = new URL(response.headers.get("Location"), response.url == null || response.url === "" ? url : response.url);
-			if (redirectedUrl.protocol !== url.protocol) {
-				logger.error("Redirected to a different protocol ({protocol} to {redirectedProtocol}) while fetching WebFinger resource descriptor.", {
-					protocol: url.protocol,
-					redirectedProtocol: redirectedUrl.protocol
-				});
-				return null;
-			}
-			url = redirectedUrl;
-			continue;
-		}
-		if (!response.ok) {
-			logger.debug("Failed to fetch WebFinger resource descriptor: {status} {statusText}.", {
+		if (signal?.aborted) {
+			logger.debug("Failed to fetch WebFinger resource descriptor: {error}", {
 				url: url.href,
-				status: response.status,
-				statusText: response.statusText
+				error: e
 			});
 			return null;
 		}
-		try {
-			return JSON.parse(await readBoundedText(response, MAX_BODY_SIZE, url));
-		} catch (e) {
-			if (e instanceof BodyTooLargeError) return null;
-			if (e instanceof SyntaxError) {
-				logger.debug("Failed to parse WebFinger resource descriptor as JSON: {error}", { error: e });
-				return null;
-			}
-			throw e;
+		throw e;
+	}
+}
+/**
+* Fetches a hop with the given session, and consumes the response body or
+* starts cancelling it before returning.  The caller closes the session.
+*/
+async function fetchHop(session, url, options) {
+	let response;
+	try {
+		response = await session.fetch(url, {
+			headers: {
+				Accept: "application/jrd+json",
+				"User-Agent": typeof options.userAgent === "string" ? options.userAgent : (0, _fedify_vocab_runtime.getUserAgent)(options.userAgent)
+			},
+			redirect: "manual",
+			signal: options.signal
+		});
+	} catch (error) {
+		logger.debug("Failed to fetch WebFinger resource descriptor: {error}", {
+			url: url.href,
+			error
+		});
+		return { result: null };
+	}
+	if (response.status >= 300 && response.status < 400 && response.headers.has("Location")) {
+		cancelBody(response, url);
+		return { redirect: response.headers.get("Location") };
+	}
+	if (!response.ok) {
+		logger.debug("Failed to fetch WebFinger resource descriptor: {status} {statusText}.", {
+			url: url.href,
+			status: response.status,
+			statusText: response.statusText
+		});
+		cancelBody(response, url);
+		return { result: null };
+	}
+	try {
+		return { result: JSON.parse(await readBoundedText(response, MAX_BODY_SIZE, url)) };
+	} catch (e) {
+		if (e instanceof BodyTooLargeError) return { result: null };
+		if (e instanceof SyntaxError) {
+			logger.debug("Failed to parse WebFinger resource descriptor as JSON: {error}", { error: e });
+			return { result: null };
 		}
+		throw e;
 	}
 }
+/**
+* Starts cancelling a response body that is not read, 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.  A failure is
+* only logged.
+*/
+function cancelBody(response, url) {
+	response.body?.cancel().catch((error) => {
+		logger.debug("Failed to cancel the response body from {url}: {error}", {
+			url: url.href,
+			error
+		});
+	});
+}
+//#endregion
+//#region src/lookup.ts
+/**
+* Looks up a WebFinger resource.
+* @param resource The resource URL to look up.
+* @param options Extra options for looking up the resource.
+* @returns The resource descriptor, or `null` if not found.
+* @since 0.2.0
+*/
+async function lookupWebFinger(resource, options = {}) {
+	return await (options.tracerProvider ?? _opentelemetry_api.trace.getTracerProvider()).getTracer(name, version).startActiveSpan("webfinger.lookup", {
+		kind: _opentelemetry_api.SpanKind.CLIENT,
+		attributes: {
+			"webfinger.resource": resource.toString(),
+			"webfinger.resource.scheme": typeof resource === "string" ? resource.replace(/:.*$/, "") : resource.protocol.replace(/:$/, "")
+		}
+	}, async (span) => {
+		try {
+			const result = await lookupWebFingerInternal(resource, options);
+			span.setStatus({ code: result === null ? _opentelemetry_api.SpanStatusCode.ERROR : _opentelemetry_api.SpanStatusCode.OK });
+			return result;
+		} catch (error) {
+			span.setStatus({
+				code: _opentelemetry_api.SpanStatusCode.ERROR,
+				message: String(error)
+			});
+			throw error;
+		} finally {
+			span.end();
+		}
+	});
+}
 //#endregion
 //#region src/lookup.test.ts
+function lookupDirect(resource, options) {
+	return lookupWebFingerInternal(resource, options, { openHop: _fedify_vocab_runtime_internal.openDirectFetch });
+}
+function lookupResolving(addresses) {
+	return () => Promise.resolve(addresses);
+}
+function openExampleDirectly(url) {
+	return new URL(url).hostname === "example.com" ? (0, _fedify_vocab_runtime_internal.openDirectFetch)(url) : (0, _fedify_vocab_runtime_internal.openPublicFetch)(url, { lookup: lookupResolving([{
+		address: "93.184.215.14",
+		family: 4
+	}]) });
+}
 (0, _fedify_fixture.test)({
 	name: "lookupWebFinger()",
 	sanitizeOps: false,
 	sanitizeResources: false,
 	async fn(t) {
+		const responseTimers = [];
 		await t.step("invalid resource", async () => {
 			(0, node_assert_strict.deepStrictEqual)(await lookupWebFinger("acct:johndoe"), null);
 			(0, node_assert_strict.deepStrictEqual)(await lookupWebFinger(new URL("acct:johndoe")), null);
@@ -1446,11 +1516,32 @@ async function lookupWebFingerInternal(resource, options = {}) {
 			(0, node_assert_strict.deepStrictEqual)(await lookupWebFinger("acct:johndoe@fedify-test.internal"), null);
 			(0, node_assert_strict.deepStrictEqual)(await lookupWebFinger("https://fedify-test.internal/foo"), null);
 		});
+		await t.step("fedify-test.internal resolving to a private address", async () => {
+			esm_default.mockGlobal();
+			esm_default.catch(500);
+			try {
+				const hosts = [];
+				const openHop = (url) => (0, _fedify_vocab_runtime_internal.openPublicFetch)(url, { lookup: (hostname) => {
+					hosts.push(hostname);
+					return Promise.resolve([{
+						address: "10.0.0.1",
+						family: 4
+					}]);
+				} });
+				(0, node_assert_strict.deepStrictEqual)(await lookupWebFingerInternal("acct:johndoe@fedify-test.internal", {}, { openHop }), null);
+				(0, node_assert_strict.deepStrictEqual)(await lookupWebFingerInternal("https://fedify-test.internal/foo", {}, { openHop }), null);
+				(0, node_assert_strict.deepStrictEqual)(hosts, ["fedify-test.internal", "fedify-test.internal"]);
+				(0, node_assert_strict.deepStrictEqual)(esm_default.callHistory.calls().length, 0);
+			} finally {
+				for (const timer of responseTimers) clearTimeout(timer);
+				esm_default.hardReset();
+			}
+		});
 		esm_default.spyGlobal();
 		esm_default.get("begin:https://example.com/.well-known/webfinger?", { status: 404 });
 		await t.step("not found", async () => {
-			(0, node_assert_strict.deepStrictEqual)(await lookupWebFinger("acct:johndoe@example.com"), null);
-			(0, node_assert_strict.deepStrictEqual)(await lookupWebFinger("https://example.com/foo"), null);
+			(0, node_assert_strict.deepStrictEqual)(await lookupDirect("acct:johndoe@example.com"), null);
+			(0, node_assert_strict.deepStrictEqual)(await lookupDirect("https://example.com/foo"), null);
 		});
 		const expected = {
 			subject: "acct:johndoe@example.com",
@@ -1459,7 +1550,7 @@ async function lookupWebFingerInternal(resource, options = {}) {
 		esm_default.removeRoutes();
 		esm_default.get("https://example.com/.well-known/webfinger?resource=acct%3Ajohndoe%40example.com", { body: expected });
 		await t.step("acct", async () => {
-			(0, node_assert_strict.deepStrictEqual)(await lookupWebFinger("acct:johndoe@example.com"), expected);
+			(0, node_assert_strict.deepStrictEqual)(await lookupDirect("acct:johndoe@example.com"), expected);
 		});
 		const expected2 = {
 			subject: "https://example.com/foo",
@@ -1468,12 +1559,12 @@ async function lookupWebFingerInternal(resource, options = {}) {
 		esm_default.removeRoutes();
 		esm_default.get("https://example.com/.well-known/webfinger?resource=https%3A%2F%2Fexample.com%2Ffoo", { body: expected2 });
 		await t.step("https", async () => {
-			(0, node_assert_strict.deepStrictEqual)(await lookupWebFinger("https://example.com/foo"), expected2);
+			(0, node_assert_strict.deepStrictEqual)(await lookupDirect("https://example.com/foo"), expected2);
 		});
 		esm_default.removeRoutes();
 		esm_default.get("begin:https://example.com/.well-known/webfinger?", { body: "not json" });
 		await t.step("invalid response", async () => {
-			(0, node_assert_strict.deepStrictEqual)(await lookupWebFinger("acct:johndoe@example.com"), null);
+			(0, node_assert_strict.deepStrictEqual)(await lookupDirect("acct:johndoe@example.com"), null);
 		});
 		esm_default.removeRoutes();
 		esm_default.get("begin:https://localhost/.well-known/webfinger?", {
@@ -1502,7 +1593,7 @@ async function lookupWebFingerInternal(resource, options = {}) {
 		});
 		esm_default.get("begin:https://example.com/.well-known/webfinger2", { body: expected });
 		await t.step("redirection", async () => {
-			(0, node_assert_strict.deepStrictEqual)(await lookupWebFinger("acct:johndoe@example.com"), expected);
+			(0, node_assert_strict.deepStrictEqual)(await lookupDirect("acct:johndoe@example.com"), expected);
 		});
 		esm_default.removeRoutes();
 		esm_default.get("begin:https://example.com/.well-known/webfinger?", {
@@ -1510,7 +1601,7 @@ async function lookupWebFingerInternal(resource, options = {}) {
 			headers: { Location: "/.well-known/webfinger" }
 		});
 		await t.step("infinite redirection", async () => {
-			(0, node_assert_strict.deepStrictEqual)(await (0, es_toolkit.withTimeout)(() => lookupWebFinger("acct:johndoe@example.com"), 2e3), null);
+			(0, node_assert_strict.deepStrictEqual)(await (0, es_toolkit.withTimeout)(() => lookupDirect("acct:johndoe@example.com"), 2e3), null);
 		});
 		esm_default.removeRoutes();
 		esm_default.get("begin:https://example.com/.well-known/webfinger?", {
@@ -1518,7 +1609,7 @@ async function lookupWebFingerInternal(resource, options = {}) {
 			headers: { Location: "ftp://example.com/" }
 		});
 		await t.step("redirection to different protocol", async () => {
-			(0, node_assert_strict.deepStrictEqual)(await lookupWebFinger("acct:johndoe@example.com"), null);
+			(0, node_assert_strict.deepStrictEqual)(await lookupDirect("acct:johndoe@example.com"), null);
 		});
 		esm_default.removeRoutes();
 		esm_default.get("begin:https://example.com/.well-known/webfinger?", {
@@ -1526,7 +1617,7 @@ async function lookupWebFingerInternal(resource, options = {}) {
 			headers: { Location: "https://localhost/" }
 		});
 		await t.step("redirection to private address", async () => {
-			(0, node_assert_strict.deepStrictEqual)(await lookupWebFinger("acct:johndoe@example.com"), null);
+			(0, node_assert_strict.deepStrictEqual)(await lookupWebFingerInternal("acct:johndoe@example.com", {}, { openHop: openExampleDirectly }), null);
 		});
 		esm_default.removeRoutes();
 		let redirectCount = 0;
@@ -1540,22 +1631,22 @@ async function lookupWebFingerInternal(resource, options = {}) {
 		});
 		await t.step("custom maxRedirection", async () => {
 			redirectCount = 0;
-			(0, node_assert_strict.deepStrictEqual)(await lookupWebFinger("acct:johndoe@example.com", { maxRedirection: 2 }), null);
+			(0, node_assert_strict.deepStrictEqual)(await lookupDirect("acct:johndoe@example.com", { maxRedirection: 2 }), null);
 			redirectCount = 0;
-			(0, node_assert_strict.deepStrictEqual)(await lookupWebFinger("acct:johndoe@example.com", { maxRedirection: 3 }), expected);
+			(0, node_assert_strict.deepStrictEqual)(await lookupDirect("acct:johndoe@example.com", { maxRedirection: 3 }), expected);
 			redirectCount = 0;
-			(0, node_assert_strict.deepStrictEqual)(await lookupWebFinger("acct:johndoe@example.com"), expected);
+			(0, node_assert_strict.deepStrictEqual)(await lookupDirect("acct:johndoe@example.com"), expected);
 		});
 		esm_default.removeRoutes();
 		esm_default.get("begin:https://example.com/.well-known/webfinger?", () => new Promise((resolve) => {
 			const timeoutId = setTimeout(() => {
 				resolve({ body: expected });
 			}, 1e3);
-			return () => clearTimeout(timeoutId);
+			responseTimers.push(timeoutId);
 		}));
 		await t.step("request cancellation", async () => {
 			const controller = new AbortController();
-			const promise = lookupWebFinger("acct:johndoe@example.com", { signal: controller.signal });
+			const promise = lookupDirect("acct:johndoe@example.com", { signal: controller.signal });
 			controller.abort();
 			(0, node_assert_strict.deepStrictEqual)(await promise, null);
 		});
@@ -1571,12 +1662,12 @@ async function lookupWebFingerInternal(resource, options = {}) {
 				const timeoutId = setTimeout(() => {
 					resolve({ body: expected });
 				}, 1e3);
-				return () => clearTimeout(timeoutId);
+				responseTimers.push(timeoutId);
 			});
 		});
 		await t.step("cancellation during redirection", async () => {
 			const controller = new AbortController();
-			const promise = lookupWebFinger("acct:johndoe@example.com", { signal: controller.signal });
+			const promise = lookupDirect("acct:johndoe@example.com", { signal: controller.signal });
 			setTimeout(() => controller.abort(), 100);
 			(0, node_assert_strict.deepStrictEqual)(await promise, null);
 		});
@@ -1585,18 +1676,20 @@ async function lookupWebFingerInternal(resource, options = {}) {
 			const timeoutId = setTimeout(() => {
 				resolve({ body: expected });
 			}, 500);
-			return () => clearTimeout(timeoutId);
+			responseTimers.push(timeoutId);
 		}));
 		await t.step("cancellation with immediate abort", async () => {
 			const controller = new AbortController();
 			controller.abort();
+			(0, node_assert_strict.deepStrictEqual)(await lookupDirect("acct:johndoe@example.com", { signal: controller.signal }), null);
 			(0, node_assert_strict.deepStrictEqual)(await lookupWebFinger("acct:johndoe@example.com", { signal: controller.signal }), null);
 		});
 		esm_default.removeRoutes();
 		esm_default.get("begin:https://example.com/.well-known/webfinger?", { body: expected });
 		await t.step("successful request with signal", async () => {
-			(0, node_assert_strict.deepStrictEqual)(await lookupWebFinger("acct:johndoe@example.com", { signal: new AbortController().signal }), expected);
+			(0, node_assert_strict.deepStrictEqual)(await lookupDirect("acct:johndoe@example.com", { signal: new AbortController().signal }), expected);
 		});
+		for (const timer of responseTimers) clearTimeout(timer);
 		esm_default.hardReset();
 	}
 });
@@ -1616,17 +1709,15 @@ async function lookupWebFingerInternal(resource, options = {}) {
 	}
 });
 (0, _fedify_fixture.test)("lookupWebFinger() logs DNS failures as such", async (t) => {
-	if ("Deno" in globalThis && (await Deno.permissions.query({ name: "net" })).state !== "granted") return;
 	for (const result of [
 		"throws",
 		"empty",
 		"private"
 	]) await t.step(result, async () => {
-		const originalLookup = node_dns_promises.default.lookup;
-		node_dns_promises.default.lookup = (() => result === "throws" ? Promise.reject(/* @__PURE__ */ new Error("Resolver unavailable")) : Promise.resolve(result === "empty" ? [] : [{
+		const lookup = () => result === "throws" ? Promise.reject(/* @__PURE__ */ new Error("Resolver unavailable")) : Promise.resolve(result === "empty" ? [] : [{
 			address: "127.0.0.1",
 			family: 4
-		}]));
+		}]);
 		const records = [];
 		await (0, _logtape_logtape.configure)({
 			sinks: { buffer: (record) => records.push(record) },
@@ -1641,7 +1732,7 @@ async function lookupWebFingerInternal(resource, options = {}) {
 			reset: true
 		});
 		try {
-			(0, node_assert_strict.deepStrictEqual)(await lookupWebFinger("acct:alice@dns-failure.invalid"), null);
+			(0, node_assert_strict.deepStrictEqual)(await lookupWebFingerInternal("acct:alice@dns-failure.invalid", {}, { openHop: (url) => (0, _fedify_vocab_runtime_internal.openPublicFetch)(url, { lookup }) }), null);
 			const failures = records.filter((r) => r.rawMessage !== "Fetching WebFinger resource descriptor from {url}...");
 			(0, node_assert_strict.deepStrictEqual)(failures.map((r) => [r.level, r.rawMessage]), [result === "private" ? ["error", "Invalid URL for WebFinger resource descriptor: {error}"] : ["debug", "DNS lookup failed for {url}"]]);
 			const { error } = failures[0].properties;
@@ -1649,8 +1740,248 @@ async function lookupWebFingerInternal(resource, options = {}) {
 			(0, node_assert_strict.deepStrictEqual)(error.reason, result === "private" ? "disallowed" : "dns");
 		} finally {
 			await (0, _logtape_logtape.reset)();
-			node_dns_promises.default.lookup = originalLookup;
 		}
 	});
 });
+function recordHops(respond) {
+	const events = [];
+	const unsettled = [];
+	let opens = 0;
+	let closes = 0;
+	let responses = 0;
+	return {
+		events,
+		async openHop(url) {
+			opens++;
+			events.push(`open ${url}`);
+			const states = [];
+			let closed = false;
+			return {
+				url: new URL(url),
+				async fetch(input) {
+					if (closed) throw new TypeError("The fetch session is closed.");
+					const target = new URL(input instanceof Request ? input.url : input);
+					const id = ++responses;
+					events.push(`fetch ${target.href} #${id}`);
+					const fake = respond(target);
+					const state = {
+						id,
+						settled: false
+					};
+					states.push(state);
+					let sent = false;
+					const body = new ReadableStream({
+						pull(controller) {
+							if (!sent && fake.body != null && fake.body !== "") {
+								sent = true;
+								controller.enqueue(new TextEncoder().encode(fake.body));
+								return;
+							}
+							state.settled = true;
+							events.push(`consumed #${id}`);
+							controller.close();
+						},
+						cancel() {
+							state.settled = true;
+							events.push(`cancel #${id}`);
+							if (fake.cancelFails) throw new Error("Cancellation failed");
+							if (fake.cancelNeverSettles) return new Promise(() => {});
+						}
+					}, { highWaterMark: 0 });
+					const response = new Response(body, {
+						status: fake.status ?? 200,
+						headers: fake.headers
+					});
+					if (fake.url != null) Object.defineProperty(response, "url", { value: fake.url });
+					return response;
+				},
+				async close() {
+					if (closed) return;
+					closed = true;
+					closes++;
+					for (const state of states) if (!state.settled) unsettled.push(`#${state.id}`);
+					events.push(`close ${url}`);
+				}
+			};
+		},
+		assertInvariants() {
+			(0, node_assert_strict.deepStrictEqual)(closes, opens);
+			(0, node_assert_strict.deepStrictEqual)(unsettled, []);
+		}
+	};
+}
+(0, _fedify_fixture.test)("lookupWebFinger() closes each hop after cleaning up its body", async (t) => {
+	const descriptor = {
+		subject: "acct:johndoe@example.com",
+		links: []
+	};
+	const first = "https://example.com/.well-known/webfinger?resource=acct%3Ajohndoe%40example.com";
+	const second = "https://example.com/.well-known/webfinger2";
+	await t.step("redirect", async () => {
+		const recorder = recordHops((url) => url.pathname === "/.well-known/webfinger" ? {
+			status: 302,
+			headers: { Location: "/.well-known/webfinger2" },
+			body: "redirecting",
+			url: url.href.replace("example.com", "93.184.215.14")
+		} : { body: JSON.stringify(descriptor) });
+		(0, node_assert_strict.deepStrictEqual)(await lookupWebFingerInternal("acct:johndoe@example.com", {}, { openHop: recorder.openHop }), descriptor);
+		(0, node_assert_strict.deepStrictEqual)(recorder.events, [
+			`open ${first}`,
+			`fetch ${first} #1`,
+			"cancel #1",
+			`close ${first}`,
+			`open ${second}`,
+			`fetch ${second} #2`,
+			"consumed #2",
+			`close ${second}`
+		]);
+		recorder.assertInvariants();
+	});
+	await t.step("non-2xx response", async () => {
+		const recorder = recordHops(() => ({
+			status: 404,
+			body: "not found"
+		}));
+		(0, node_assert_strict.deepStrictEqual)(await lookupWebFingerInternal("acct:johndoe@example.com", {}, { openHop: recorder.openHop }), null);
+		(0, node_assert_strict.deepStrictEqual)(recorder.events, [
+			`open ${first}`,
+			`fetch ${first} #1`,
+			"cancel #1",
+			`close ${first}`
+		]);
+		recorder.assertInvariants();
+	});
+	await t.step("too many redirections", async () => {
+		const recorder = recordHops(() => ({
+			status: 302,
+			headers: { Location: "/.well-known/webfinger2" },
+			body: "redirecting"
+		}));
+		(0, node_assert_strict.deepStrictEqual)(await lookupWebFingerInternal("acct:johndoe@example.com", { maxRedirection: 2 }, { openHop: recorder.openHop }), null);
+		(0, node_assert_strict.deepStrictEqual)(recorder.events, [
+			`open ${first}`,
+			`fetch ${first} #1`,
+			"cancel #1",
+			`close ${first}`,
+			`open ${second}`,
+			`fetch ${second} #2`,
+			"cancel #2",
+			`close ${second}`
+		]);
+		recorder.assertInvariants();
+	});
+	await t.step("failed redirect body cancellation", async () => {
+		const recorder = recordHops((url) => url.pathname === "/.well-known/webfinger" ? {
+			status: 302,
+			headers: { Location: "/.well-known/webfinger2" },
+			body: "redirecting",
+			cancelFails: true
+		} : { body: JSON.stringify(descriptor) });
+		const records = [];
+		await (0, _logtape_logtape.configure)({
+			sinks: { buffer: (record) => records.push(record) },
+			loggers: [{
+				category: "fedify",
+				sinks: ["buffer"],
+				lowestLevel: "debug"
+			}, {
+				category: ["logtape", "meta"],
+				sinks: []
+			}],
+			reset: true
+		});
+		try {
+			(0, node_assert_strict.deepStrictEqual)(await lookupWebFingerInternal("acct:johndoe@example.com", {}, { openHop: recorder.openHop }), descriptor);
+			const failures = records.filter((r) => r.rawMessage === "Failed to cancel the response body from {url}: {error}");
+			(0, node_assert_strict.deepStrictEqual)(failures.map((r) => [r.level, r.properties.url]), [["debug", first]]);
+			const { error } = failures[0].properties;
+			(0, node_assert_strict.ok)(error instanceof Error);
+			(0, node_assert_strict.deepStrictEqual)(error.message, "Cancellation failed");
+		} finally {
+			await (0, _logtape_logtape.reset)();
+		}
+		(0, node_assert_strict.deepStrictEqual)(recorder.events, [
+			`open ${first}`,
+			`fetch ${first} #1`,
+			"cancel #1",
+			`close ${first}`,
+			`open ${second}`,
+			`fetch ${second} #2`,
+			"consumed #2",
+			`close ${second}`
+		]);
+		recorder.assertInvariants();
+	});
+	await t.step("never-settling body cancellation", async () => {
+		const recorder = recordHops((url) => url.pathname === "/.well-known/webfinger" ? {
+			status: 302,
+			headers: { Location: "/.well-known/webfinger2" },
+			body: "redirecting",
+			cancelNeverSettles: true
+		} : {
+			status: 404,
+			body: "not found",
+			cancelNeverSettles: true
+		});
+		(0, node_assert_strict.deepStrictEqual)(await settleWithin(lookupWebFingerInternal("acct:johndoe@example.com", {}, { openHop: recorder.openHop })), null);
+		(0, node_assert_strict.deepStrictEqual)(recorder.events, [
+			`open ${first}`,
+			`fetch ${first} #1`,
+			"cancel #1",
+			`close ${first}`,
+			`open ${second}`,
+			`fetch ${second} #2`,
+			"cancel #2",
+			`close ${second}`
+		]);
+		recorder.assertInvariants();
+	});
+});
+/**
+* Rejects if the given promise does not settle within the timeout, so that
+* a hang fails the test instead of blocking it.
+*/
+async function settleWithin(promise, ms = 5e3) {
+	let timer;
+	try {
+		return await Promise.race([promise, new Promise((_, reject) => {
+			timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Did not settle within ${ms} ms.`)), ms);
+		})]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+function neverCancellableResponse(init) {
+	return new Response(new ReadableStream({
+		start(controller) {
+			controller.enqueue(new TextEncoder().encode("never cancelled"));
+		},
+		cancel: () => new Promise(() => {})
+	}), init);
+}
+(0, _fedify_fixture.test)("lookupWebFinger() does not wait for cancelling response bodies", async (t) => {
+	const descriptor = {
+		subject: "acct:johndoe@example.com",
+		links: []
+	};
+	esm_default.mockGlobal();
+	try {
+		await t.step("redirect", async () => {
+			esm_default.removeRoutes();
+			esm_default.get("begin:https://example.com/.well-known/webfinger?", () => neverCancellableResponse({
+				status: 302,
+				headers: { Location: "/.well-known/webfinger2" }
+			}));
+			esm_default.get("https://example.com/.well-known/webfinger2", () => new Response(JSON.stringify(descriptor), { headers: { "Content-Type": "application/jrd+json" } }));
+			(0, node_assert_strict.deepStrictEqual)(await settleWithin(lookupDirect("acct:johndoe@example.com")), descriptor);
+		});
+		await t.step("non-2xx response", async () => {
+			esm_default.removeRoutes();
+			esm_default.get("begin:https://example.com/.well-known/webfinger?", () => neverCancellableResponse({ status: 404 }));
+			(0, node_assert_strict.deepStrictEqual)(await settleWithin(lookupDirect("acct:johndoe@example.com")), null);
+		});
+	} finally {
+		esm_default.hardReset();
+	}
+});
 //#endregion