@fedify/webfinger 2.0.35-dev.2470 → 2.0.35-dev.2485

package/dist/lookup.test.js

@@ -1,9 +1,9 @@
 import { test } from "@fedify/fixture";
-import { FetchError, UrlError, getUserAgent, validatePublicUrl } from "@fedify/vocab-runtime";
+import { FetchError, UrlError, getUserAgent } from "@fedify/vocab-runtime";
+import { openDirectFetch, openPublicFetch } from "@fedify/vocab-runtime/internal";
 import { configure, getLogger, reset } from "@logtape/logtape";
 import { withTimeout } from "es-toolkit";
 import { deepStrictEqual, ok } from "node:assert/strict";
-import dns from "node:dns/promises";
 import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
@@ -1228,7 +1228,7 @@ var esm_default = new class FetchMock {
 //#endregion
 //#region deno.json
 var name = "@fedify/webfinger";
-var version = "2.0.35-dev.2470+891ba128";
+var version = "2.0.35-dev.2485+75206550";
 //#endregion
 //#region src/body.ts
 /** Decoded JSON body limit: 16 MiB.  @internal */
@@ -1304,7 +1304,7 @@ async function readBoundedText(message, maxBytes, url) {
 	}
 }
 //#endregion
-//#region src/lookup.ts
+//#region src/lookup-impl.ts
 const logger = getLogger([
 	"fedify",
 	"webfinger",
@@ -1312,36 +1312,16 @@ const logger = 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 ?? trace.getTracerProvider()).getTracer(name, version).startActiveSpan("webfinger.lookup", {
-		kind: 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 ? SpanStatusCode.ERROR : SpanStatusCode.OK });
-			return result;
-		} catch (error) {
-			span.setStatus({
-				code: 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;
@@ -1356,79 +1336,169 @@ 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 ? openDirectFetch(hopUrl) : 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 validatePublicUrl(url.href);
-		} catch (e) {
-			if (e instanceof 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 : 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 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 : 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 ?? trace.getTracerProvider()).getTracer(name, version).startActiveSpan("webfinger.lookup", {
+		kind: 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 ? SpanStatusCode.ERROR : SpanStatusCode.OK });
+			return result;
+		} catch (error) {
+			span.setStatus({
+				code: 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: openDirectFetch });
+}
+function lookupResolving(addresses) {
+	return () => Promise.resolve(addresses);
+}
+function openExampleDirectly(url) {
+	return new URL(url).hostname === "example.com" ? openDirectFetch(url) : openPublicFetch(url, { lookup: lookupResolving([{
+		address: "93.184.215.14",
+		family: 4
+	}]) });
+}
 test({
 	name: "lookupWebFinger()",
 	sanitizeOps: false,
@@ -1444,11 +1514,31 @@ test({
 			deepStrictEqual(await lookupWebFinger("acct:johndoe@fedify-test.internal"), null);
 			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) => openPublicFetch(url, { lookup: (hostname) => {
+					hosts.push(hostname);
+					return Promise.resolve([{
+						address: "10.0.0.1",
+						family: 4
+					}]);
+				} });
+				deepStrictEqual(await lookupWebFingerInternal("acct:johndoe@fedify-test.internal", {}, { openHop }), null);
+				deepStrictEqual(await lookupWebFingerInternal("https://fedify-test.internal/foo", {}, { openHop }), null);
+				deepStrictEqual(hosts, ["fedify-test.internal", "fedify-test.internal"]);
+				deepStrictEqual(esm_default.callHistory.calls().length, 0);
+			} finally {
+				esm_default.hardReset();
+			}
+		});
 		esm_default.spyGlobal();
 		esm_default.get("begin:https://example.com/.well-known/webfinger?", { status: 404 });
 		await t.step("not found", async () => {
-			deepStrictEqual(await lookupWebFinger("acct:johndoe@example.com"), null);
-			deepStrictEqual(await lookupWebFinger("https://example.com/foo"), null);
+			deepStrictEqual(await lookupDirect("acct:johndoe@example.com"), null);
+			deepStrictEqual(await lookupDirect("https://example.com/foo"), null);
 		});
 		const expected = {
 			subject: "acct:johndoe@example.com",
@@ -1457,7 +1547,7 @@ test({
 		esm_default.removeRoutes();
 		esm_default.get("https://example.com/.well-known/webfinger?resource=acct%3Ajohndoe%40example.com", { body: expected });
 		await t.step("acct", async () => {
-			deepStrictEqual(await lookupWebFinger("acct:johndoe@example.com"), expected);
+			deepStrictEqual(await lookupDirect("acct:johndoe@example.com"), expected);
 		});
 		const expected2 = {
 			subject: "https://example.com/foo",
@@ -1466,12 +1556,12 @@ test({
 		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 () => {
-			deepStrictEqual(await lookupWebFinger("https://example.com/foo"), expected2);
+			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 () => {
-			deepStrictEqual(await lookupWebFinger("acct:johndoe@example.com"), null);
+			deepStrictEqual(await lookupDirect("acct:johndoe@example.com"), null);
 		});
 		esm_default.removeRoutes();
 		esm_default.get("begin:https://localhost/.well-known/webfinger?", {
@@ -1500,7 +1590,7 @@ test({
 		});
 		esm_default.get("begin:https://example.com/.well-known/webfinger2", { body: expected });
 		await t.step("redirection", async () => {
-			deepStrictEqual(await lookupWebFinger("acct:johndoe@example.com"), expected);
+			deepStrictEqual(await lookupDirect("acct:johndoe@example.com"), expected);
 		});
 		esm_default.removeRoutes();
 		esm_default.get("begin:https://example.com/.well-known/webfinger?", {
@@ -1508,7 +1598,7 @@ test({
 			headers: { Location: "/.well-known/webfinger" }
 		});
 		await t.step("infinite redirection", async () => {
-			deepStrictEqual(await withTimeout(() => lookupWebFinger("acct:johndoe@example.com"), 2e3), null);
+			deepStrictEqual(await withTimeout(() => lookupDirect("acct:johndoe@example.com"), 2e3), null);
 		});
 		esm_default.removeRoutes();
 		esm_default.get("begin:https://example.com/.well-known/webfinger?", {
@@ -1516,7 +1606,7 @@ test({
 			headers: { Location: "ftp://example.com/" }
 		});
 		await t.step("redirection to different protocol", async () => {
-			deepStrictEqual(await lookupWebFinger("acct:johndoe@example.com"), null);
+			deepStrictEqual(await lookupDirect("acct:johndoe@example.com"), null);
 		});
 		esm_default.removeRoutes();
 		esm_default.get("begin:https://example.com/.well-known/webfinger?", {
@@ -1524,7 +1614,7 @@ test({
 			headers: { Location: "https://localhost/" }
 		});
 		await t.step("redirection to private address", async () => {
-			deepStrictEqual(await lookupWebFinger("acct:johndoe@example.com"), null);
+			deepStrictEqual(await lookupWebFingerInternal("acct:johndoe@example.com", {}, { openHop: openExampleDirectly }), null);
 		});
 		esm_default.removeRoutes();
 		let redirectCount = 0;
@@ -1538,11 +1628,11 @@ test({
 		});
 		await t.step("custom maxRedirection", async () => {
 			redirectCount = 0;
-			deepStrictEqual(await lookupWebFinger("acct:johndoe@example.com", { maxRedirection: 2 }), null);
+			deepStrictEqual(await lookupDirect("acct:johndoe@example.com", { maxRedirection: 2 }), null);
 			redirectCount = 0;
-			deepStrictEqual(await lookupWebFinger("acct:johndoe@example.com", { maxRedirection: 3 }), expected);
+			deepStrictEqual(await lookupDirect("acct:johndoe@example.com", { maxRedirection: 3 }), expected);
 			redirectCount = 0;
-			deepStrictEqual(await lookupWebFinger("acct:johndoe@example.com"), expected);
+			deepStrictEqual(await lookupDirect("acct:johndoe@example.com"), expected);
 		});
 		esm_default.removeRoutes();
 		esm_default.get("begin:https://example.com/.well-known/webfinger?", () => new Promise((resolve) => {
@@ -1553,7 +1643,7 @@ test({
 		}));
 		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();
 			deepStrictEqual(await promise, null);
 		});
@@ -1574,7 +1664,7 @@ test({
 		});
 		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);
 			deepStrictEqual(await promise, null);
 		});
@@ -1588,12 +1678,13 @@ test({
 		await t.step("cancellation with immediate abort", async () => {
 			const controller = new AbortController();
 			controller.abort();
+			deepStrictEqual(await lookupDirect("acct:johndoe@example.com", { signal: controller.signal }), null);
 			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 () => {
-			deepStrictEqual(await lookupWebFinger("acct:johndoe@example.com", { signal: new AbortController().signal }), expected);
+			deepStrictEqual(await lookupDirect("acct:johndoe@example.com", { signal: new AbortController().signal }), expected);
 		});
 		esm_default.hardReset();
 	}
@@ -1614,17 +1705,15 @@ test("lookupWebFinger() bounds resource descriptors", async () => {
 	}
 });
 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 = dns.lookup;
-		dns.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 configure({
 			sinks: { buffer: (record) => records.push(record) },
@@ -1639,7 +1728,7 @@ test("lookupWebFinger() logs DNS failures as such", async (t) => {
 			reset: true
 		});
 		try {
-			deepStrictEqual(await lookupWebFinger("acct:alice@dns-failure.invalid"), null);
+			deepStrictEqual(await lookupWebFingerInternal("acct:alice@dns-failure.invalid", {}, { openHop: (url) => openPublicFetch(url, { lookup }) }), null);
 			const failures = records.filter((r) => r.rawMessage !== "Fetching WebFinger resource descriptor from {url}...");
 			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;
@@ -1647,9 +1736,249 @@ test("lookupWebFinger() logs DNS failures as such", async (t) => {
 			deepStrictEqual(error.reason, result === "private" ? "disallowed" : "dns");
 		} finally {
 			await reset();
-			dns.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() {
+			deepStrictEqual(closes, opens);
+			deepStrictEqual(unsettled, []);
+		}
+	};
+}
+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) });
+		deepStrictEqual(await lookupWebFingerInternal("acct:johndoe@example.com", {}, { openHop: recorder.openHop }), descriptor);
+		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"
+		}));
+		deepStrictEqual(await lookupWebFingerInternal("acct:johndoe@example.com", {}, { openHop: recorder.openHop }), null);
+		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"
+		}));
+		deepStrictEqual(await lookupWebFingerInternal("acct:johndoe@example.com", { maxRedirection: 2 }, { openHop: recorder.openHop }), null);
+		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 configure({
+			sinks: { buffer: (record) => records.push(record) },
+			loggers: [{
+				category: "fedify",
+				sinks: ["buffer"],
+				lowestLevel: "debug"
+			}, {
+				category: ["logtape", "meta"],
+				sinks: []
+			}],
+			reset: true
+		});
+		try {
+			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}");
+			deepStrictEqual(failures.map((r) => [r.level, r.properties.url]), [["debug", first]]);
+			const { error } = failures[0].properties;
+			ok(error instanceof Error);
+			deepStrictEqual(error.message, "Cancellation failed");
+		} finally {
+			await reset();
+		}
+		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
+		});
+		deepStrictEqual(await settleWithin(lookupWebFingerInternal("acct:johndoe@example.com", {}, { openHop: recorder.openHop })), null);
+		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);
+}
+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" } }));
+			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 }));
+			deepStrictEqual(await settleWithin(lookupDirect("acct:johndoe@example.com")), null);
+		});
+	} finally {
+		esm_default.hardReset();
+	}
+});
 //#endregion
 export {};