@fedify/vocab-runtime 2.4.0-dev.2155 → 2.4.0-dev.2157

package/dist/tests/{url-DgJM9WJn.mjs → url-D7qRF-dF.mjs}

@@ -1,10 +1,17 @@
-import { lookup } from "node:dns/promises";
+import dns from "node:dns/promises";
 import { isIP } from "node:net";
 //#region src/url.ts
 var UrlError = class extends Error {
+	/**
+	* The failure category. Defaults to `"disallowed"`.
+	* `"dns"` includes lookup errors and results with no usable IP addresses.
+	* @since 2.0.29
+	*/
+	reason;
 	constructor(message, options) {
 		super(message, options);
 		this.name = "UrlError";
+		this.reason = options?.reason ?? "disallowed";
 	}
 };
 const PORTABLE_IRI_PATTERN = /^(ap|ap\+ef61):\/\/([^/?#]*)([^?#]*)(\?[^#]*)?(#.*)?$/i;
@@ -392,9 +399,12 @@ async function validatePublicUrl(url) {
 	}
 	let addresses;
 	try {
-		addresses = await lookup(hostname, { all: true });
+		addresses = await dns.lookup(hostname, { all: true });
 	} catch (error) {
-		throw new UrlError("DNS lookup failed", { cause: error });
+		throw new UrlError("DNS lookup failed", {
+			cause: error,
+			reason: "dns"
+		});
 	}
 	validateLookupAddresses(addresses);
 }
@@ -423,7 +433,7 @@ function validateLookupAddresses(addresses) {
 		ipAddressCount++;
 		validatePublicIpAddress(address, family);
 	}
-	if (ipAddressCount === 0) throw new UrlError("DNS lookup did not return any IP address");
+	if (ipAddressCount === 0) throw new UrlError("DNS lookup did not return any IP address", { reason: "dns" });
 }
 function validatePublicIpAddress(address, family) {
 	if (family === 4 && isValidPublicIPv4Address(address) || family === 6 && isValidPublicIPv6Address(address)) return;

package/dist/tests/{url-BqlldzT8.cjs → url-gLKqAO1H.cjs}

@@ -1,10 +1,19 @@
+const require_rolldown_runtime = require("./rolldown-runtime-emK7D4bc.cjs");
 let node_dns_promises = require("node:dns/promises");
+node_dns_promises = require_rolldown_runtime.__toESM(node_dns_promises, 1);
 let node_net = require("node:net");
 //#region src/url.ts
 var UrlError = class extends Error {
+	/**
+	* The failure category. Defaults to `"disallowed"`.
+	* `"dns"` includes lookup errors and results with no usable IP addresses.
+	* @since 2.0.29
+	*/
+	reason;
 	constructor(message, options) {
 		super(message, options);
 		this.name = "UrlError";
+		this.reason = options?.reason ?? "disallowed";
 	}
 };
 const PORTABLE_IRI_PATTERN = /^(ap|ap\+ef61):\/\/([^/?#]*)([^?#]*)(\?[^#]*)?(#.*)?$/i;
@@ -392,9 +401,12 @@ async function validatePublicUrl(url) {
 	}
 	let addresses;
 	try {
-		addresses = await (0, node_dns_promises.lookup)(hostname, { all: true });
+		addresses = await node_dns_promises.default.lookup(hostname, { all: true });
 	} catch (error) {
-		throw new UrlError("DNS lookup failed", { cause: error });
+		throw new UrlError("DNS lookup failed", {
+			cause: error,
+			reason: "dns"
+		});
 	}
 	validateLookupAddresses(addresses);
 }
@@ -423,7 +435,7 @@ function validateLookupAddresses(addresses) {
 		ipAddressCount++;
 		validatePublicIpAddress(address, family);
 	}
-	if (ipAddressCount === 0) throw new UrlError("DNS lookup did not return any IP address");
+	if (ipAddressCount === 0) throw new UrlError("DNS lookup did not return any IP address", { reason: "dns" });
 }
 function validatePublicIpAddress(address, family) {
 	if (family === 4 && isValidPublicIPv4Address(address) || family === 6 && isValidPublicIPv6Address(address)) return;

package/dist/tests/url.test.cjs

@@ -1,4 +1,4 @@
-const require_url = require("./url-BqlldzT8.cjs");
+const require_url = require("./url-gLKqAO1H.cjs");
 let node_test = require("node:test");
 let node_assert = require("node:assert");
 //#region src/url.test.ts
@@ -463,6 +463,29 @@ let node_assert = require("node:assert");
 	}
 	(0, node_assert.ok)(!require_url.arePortableUrisEqual(require_url.fromCompatibleEf61Id(require_url.toCompatibleEf61Id("ap://did:key:z6MkAlice/actor", "https://server.example")).href, require_url.fromCompatibleEf61Id(require_url.toCompatibleEf61Id("ap://did:key:z6MkAlice/actor#", "https://server.example")).href));
 });
+(0, node_test.test)("UrlError reason is independent of its cause", () => {
+	const cause = /* @__PURE__ */ new Error("Underlying failure");
+	(0, node_assert.strictEqual)(new require_url.UrlError("Rejected URL").reason, "disallowed");
+	const disallowedError = new require_url.UrlError("Rejected URL", { cause });
+	(0, node_assert.strictEqual)(disallowedError.reason, "disallowed");
+	(0, node_assert.strictEqual)(disallowedError.cause, cause);
+	const dnsError = new require_url.UrlError("Lookup failed", {
+		reason: "dns",
+		cause
+	});
+	(0, node_assert.strictEqual)(dnsError.reason, "dns");
+	(0, node_assert.strictEqual)(dnsError.cause, cause);
+});
+(0, node_test.test)("validatePublicUrl() classifies disallowed URLs", async () => {
+	for (const url of [
+		"ftp://example.com",
+		"https://localhost",
+		"https://127.0.0.1"
+	]) await (0, node_assert.rejects)(() => require_url.validatePublicUrl(url), {
+		name: "UrlError",
+		reason: "disallowed"
+	});
+});
 (0, node_test.test)("validatePublicUrl()", async () => {
 	await (0, node_assert.rejects)(() => require_url.validatePublicUrl("ftp://localhost"), require_url.UrlError);
 	await (0, node_assert.rejects)(() => require_url.validatePublicUrl("data:text/plain;base64,SGVsbG8sIFdvcmxkIQ=="), require_url.UrlError);
@@ -512,11 +535,21 @@ let node_assert = require("node:assert");
 	}, {
 		address: "127.0.0.1",
 		family: 4
-	}]), require_url.UrlError);
+	}]), {
+		name: "UrlError",
+		reason: "disallowed"
+	});
 	(0, node_assert.throws)(() => require_url.validateLookupAddresses([{
 		address: "app-host.example.net.",
 		family: 4
-	}]), require_url.UrlError);
+	}]), {
+		name: "UrlError",
+		reason: "dns"
+	});
+	(0, node_assert.throws)(() => require_url.validateLookupAddresses([]), {
+		name: "UrlError",
+		reason: "dns"
+	});
 });
 (0, node_test.test)("isValidPublicIPv4Address()", () => {
 	(0, node_assert.ok)(require_url.isValidPublicIPv4Address("8.8.8.8"));

package/dist/tests/url.test.mjs

@@ -1,6 +1,6 @@
-import { _ as validateLookupAddresses, a as formatIri, c as haveSameFe34Origin, d as isValidPublicIPv4Address, f as isValidPublicIPv6Address, g as toCompatibleEf61Id, h as parseJsonLdId, i as expandIPv6Address, l as haveSameIriOrigin, m as parseIri, n as arePortableUrisEqual, o as fromCompatibleEf61Id, p as parseGatewayUrl, r as canonicalizePortableUri, s as getFe34Origin, t as UrlError, u as isGatewayUrl, v as validatePublicUrl } from "./url-DgJM9WJn.mjs";
+import { _ as validateLookupAddresses, a as formatIri, c as haveSameFe34Origin, d as isValidPublicIPv4Address, f as isValidPublicIPv6Address, g as toCompatibleEf61Id, h as parseJsonLdId, i as expandIPv6Address, l as haveSameIriOrigin, m as parseIri, n as arePortableUrisEqual, o as fromCompatibleEf61Id, p as parseGatewayUrl, r as canonicalizePortableUri, s as getFe34Origin, t as UrlError, u as isGatewayUrl, v as validatePublicUrl } from "./url-D7qRF-dF.mjs";
 import { test } from "node:test";
-import { deepStrictEqual, ok, rejects, throws } from "node:assert";
+import { deepStrictEqual, ok, rejects, strictEqual, throws } from "node:assert";
 //#region src/url.test.ts
 test("parseIri() accepts portable ActivityPub URI schemes", () => {
 	for (const iri of [
@@ -463,6 +463,29 @@ test("compatible identifier conversion round-trips", () => {
 	}
 	ok(!arePortableUrisEqual(fromCompatibleEf61Id(toCompatibleEf61Id("ap://did:key:z6MkAlice/actor", "https://server.example")).href, fromCompatibleEf61Id(toCompatibleEf61Id("ap://did:key:z6MkAlice/actor#", "https://server.example")).href));
 });
+test("UrlError reason is independent of its cause", () => {
+	const cause = /* @__PURE__ */ new Error("Underlying failure");
+	strictEqual(new UrlError("Rejected URL").reason, "disallowed");
+	const disallowedError = new UrlError("Rejected URL", { cause });
+	strictEqual(disallowedError.reason, "disallowed");
+	strictEqual(disallowedError.cause, cause);
+	const dnsError = new UrlError("Lookup failed", {
+		reason: "dns",
+		cause
+	});
+	strictEqual(dnsError.reason, "dns");
+	strictEqual(dnsError.cause, cause);
+});
+test("validatePublicUrl() classifies disallowed URLs", async () => {
+	for (const url of [
+		"ftp://example.com",
+		"https://localhost",
+		"https://127.0.0.1"
+	]) await rejects(() => validatePublicUrl(url), {
+		name: "UrlError",
+		reason: "disallowed"
+	});
+});
 test("validatePublicUrl()", async () => {
 	await rejects(() => validatePublicUrl("ftp://localhost"), UrlError);
 	await rejects(() => validatePublicUrl("data:text/plain;base64,SGVsbG8sIFdvcmxkIQ=="), UrlError);
@@ -512,11 +535,21 @@ test("validateLookupAddresses() rejects unsafe or CNAME-only Cloudflare Workers
 	}, {
 		address: "127.0.0.1",
 		family: 4
-	}]), UrlError);
+	}]), {
+		name: "UrlError",
+		reason: "disallowed"
+	});
 	throws(() => validateLookupAddresses([{
 		address: "app-host.example.net.",
 		family: 4
-	}]), UrlError);
+	}]), {
+		name: "UrlError",
+		reason: "dns"
+	});
+	throws(() => validateLookupAddresses([]), {
+		name: "UrlError",
+		reason: "dns"
+	});
 });
 test("isValidPublicIPv4Address()", () => {
 	ok(isValidPublicIPv4Address("8.8.8.8"));

package/dist/{url-CEhi4hb4.js → url-BHZYe8Vu.js}

@@ -1,11 +1,18 @@
 
-import { lookup } from "node:dns/promises";
+import dns from "node:dns/promises";
 import { isIP } from "node:net";
 //#region src/url.ts
 var UrlError = class extends Error {
+	/**
+	* The failure category. Defaults to `"disallowed"`.
+	* `"dns"` includes lookup errors and results with no usable IP addresses.
+	* @since 2.0.29
+	*/
+	reason;
 	constructor(message, options) {
 		super(message, options);
 		this.name = "UrlError";
+		this.reason = options?.reason ?? "disallowed";
 	}
 };
 const PORTABLE_IRI_PATTERN = /^(ap|ap\+ef61):\/\/([^/?#]*)([^?#]*)(\?[^#]*)?(#.*)?$/i;
@@ -393,9 +400,12 @@ async function validatePublicUrl(url) {
 	}
 	let addresses;
 	try {
-		addresses = await lookup(hostname, { all: true });
+		addresses = await dns.lookup(hostname, { all: true });
 	} catch (error) {
-		throw new UrlError("DNS lookup failed", { cause: error });
+		throw new UrlError("DNS lookup failed", {
+			cause: error,
+			reason: "dns"
+		});
 	}
 	validateLookupAddresses(addresses);
 }
@@ -424,7 +434,7 @@ function validateLookupAddresses(addresses) {
 		ipAddressCount++;
 		validatePublicIpAddress(address, family);
 	}
-	if (ipAddressCount === 0) throw new UrlError("DNS lookup did not return any IP address");
+	if (ipAddressCount === 0) throw new UrlError("DNS lookup did not return any IP address", { reason: "dns" });
 }
 function validatePublicIpAddress(address, family) {
 	if (family === 4 && isValidPublicIPv4Address(address) || family === 6 && isValidPublicIPv6Address(address)) return;

package/dist/{url-Cke4irYD.cjs → url-P6l9s9dN.cjs}

@@ -1,11 +1,20 @@
 
+const require_rolldown_runtime = require("./rolldown-runtime-B7lfambq.cjs");
 let node_dns_promises = require("node:dns/promises");
+node_dns_promises = require_rolldown_runtime.__toESM(node_dns_promises, 1);
 let node_net = require("node:net");
 //#region src/url.ts
 var UrlError = class extends Error {
+	/**
+	* The failure category. Defaults to `"disallowed"`.
+	* `"dns"` includes lookup errors and results with no usable IP addresses.
+	* @since 2.0.29
+	*/
+	reason;
 	constructor(message, options) {
 		super(message, options);
 		this.name = "UrlError";
+		this.reason = options?.reason ?? "disallowed";
 	}
 };
 const PORTABLE_IRI_PATTERN = /^(ap|ap\+ef61):\/\/([^/?#]*)([^?#]*)(\?[^#]*)?(#.*)?$/i;
@@ -393,9 +402,12 @@ async function validatePublicUrl(url) {
 	}
 	let addresses;
 	try {
-		addresses = await (0, node_dns_promises.lookup)(hostname, { all: true });
+		addresses = await node_dns_promises.default.lookup(hostname, { all: true });
 	} catch (error) {
-		throw new UrlError("DNS lookup failed", { cause: error });
+		throw new UrlError("DNS lookup failed", {
+			cause: error,
+			reason: "dns"
+		});
 	}
 	validateLookupAddresses(addresses);
 }
@@ -424,7 +436,7 @@ function validateLookupAddresses(addresses) {
 		ipAddressCount++;
 		validatePublicIpAddress(address, family);
 	}
-	if (ipAddressCount === 0) throw new UrlError("DNS lookup did not return any IP address");
+	if (ipAddressCount === 0) throw new UrlError("DNS lookup did not return any IP address", { reason: "dns" });
 }
 function validatePublicIpAddress(address, family) {
 	if (family === 4 && isValidPublicIPv4Address(address) || family === 6 && isValidPublicIPv6Address(address)) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/vocab-runtime",
-  "version": "2.4.0-dev.2155+2ccc5085",
+  "version": "2.4.0-dev.2157+b76e5888",
   "homepage": "https://fedify.dev/",
   "repository": {
     "type": "git",

package/src/contexts.ts

@@ -41,7 +41,6 @@ const preloadedContexts: Record<string, unknown> = {
   "https://gotosocial.org/ns": gotosocial,
   "https://w3id.org/fep/22cd": fep22cd,
   "https://w3id.org/fep/5711": fep5711,
-  "https://w3id.org/fep/7aa9": fep7aa9,
 
   // Controlled Identifiers v1.0 requires JSON-LD processors to treat this
   // context URL as already resolved.  We ship the official W3C context so that
@@ -60,6 +59,13 @@ const preloadedContexts: Record<string, unknown> = {
   //      https://github.com/fedify-dev/fedify/issues/982
   "https://w3id.org/fep/ef61": fepEf61,
 
+  // The FEP-7aa9 context is hosted on Codeberg Pages, whose outages can
+  // prevent actor documents from being parsed.  Resolve it locally so that
+  // parsing does not depend on the remote context server's availability.
+  // See: https://w3id.org/fep/7aa9
+  //      https://github.com/fedify-dev/fedify/issues/1078
+  "https://w3id.org/fep/7aa9": fep7aa9,
+
   // Lemmy's context document is served as application/json without the JSON-LD
   // context Link header.  The default document loader treats that as a regular
   // JSON response instead of a JSON-LD context, so every Lemmy activity that

package/src/docloader.test.ts

@@ -1,6 +1,7 @@
-import fetchMock from "fetch-mock";
 import { configure, type LogRecord, reset } from "@logtape/logtape";
+import fetchMock from "fetch-mock";
 import { deepStrictEqual, ok, rejects } from "node:assert";
+import dns from "node:dns/promises";
 import { test } from "node:test";
 import { createServer } from "node:http";
 import { gzipSync } from "node:zlib";
@@ -507,6 +508,43 @@ test("getDocumentLoader()", async (t) => {
     });
   });
 
+  // A Codeberg Pages outage must not prevent loading the FEP-7aa9 context.
+  // See: https://github.com/fedify-dev/fedify/issues/1078
+  fetchMock.get("https://w3id.org/fep/7aa9", { status: 502 });
+  await t.test("preloaded FEP-7aa9 context", async () => {
+    const url = "https://w3id.org/fep/7aa9";
+    deepStrictEqual(await fetchDocumentLoader(url), {
+      contextUrl: null,
+      documentUrl: url,
+      document: {
+        "@context": {
+          "FeaturedCollection": "https://w3id.org/fep/7aa9#FeaturedCollection",
+          "FeaturedItem": "https://w3id.org/fep/7aa9#FeaturedItem",
+          "FeatureRequest": "https://w3id.org/fep/7aa9#FeatureRequest",
+          "FeatureAuthorization":
+            "https://w3id.org/fep/7aa9#FeatureAuthorization",
+          "topic": {
+            "@id": "https://w3id.org/fep/7aa9#topic",
+            "@type": "@id",
+          },
+          "featuredObject": {
+            "@id": "https://w3id.org/fep/7aa9#featuredObject",
+            "@type": "@id",
+          },
+          "canFeature": {
+            "@id": "https://w3id.org/fep/7aa9#canFeature",
+            "@type": "@id",
+          },
+          "featureAuthorization": {
+            "@id": "https://w3id.org/fep/7aa9#featureAuthorization",
+            "@type": "@id",
+          },
+        },
+      },
+    });
+    deepStrictEqual(fetchMock.callHistory.calls(url).length, 0);
+  });
+
   await t.test("deny non-HTTP/HTTPS", async () => {
     await rejects(
       () => fetchDocumentLoader("ftp://localhost"),
@@ -812,3 +850,271 @@ test("getRemoteDocument() bounds JSON by default", async () => {
   deepStrictEqual(canceled, true);
   deepStrictEqual(pulls, 257);
 });
+
+test("getDocumentLoader() logs DNS failures as such", async (t) => {
+  // The validator skips DNS when Deno has no network permission.  Checked
+  // here rather than with top-level await, which the CommonJS build rejects.
+  if (
+    "Deno" in globalThis &&
+    (await Deno.permissions.query({ name: "net" })).state !== "granted"
+  ) {
+    t.skip("requires the net permission");
+    return;
+  }
+  const loader = getDocumentLoader();
+  for (const result of ["throws", "empty", "private"] as const) {
+    await t.test(result, async () => {
+      // Stubbing works only because url.ts uses the default node:dns/promises
+      // import; see the FIXME there.
+      const originalLookup = dns.lookup;
+      dns.lookup = (() =>
+        result === "throws"
+          ? Promise.reject(new Error("Resolver unavailable"))
+          : Promise.resolve(
+            result === "empty" ? [] : [{ address: "127.0.0.1", family: 4 }],
+          )) as typeof dns.lookup;
+      const records: LogRecord[] = [];
+      await configure({
+        sinks: {
+          buffer: (record) =>
+            records.push(record),
+        },
+        loggers: [
+          { category: "fedify", sinks: ["buffer"], lowestLevel: "debug" },
+          { category: ["logtape", "meta"], sinks: [] },
+        ],
+        reset: true,
+      });
+      try {
+        const url = "https://dns-failure.invalid/object";
+        let error: unknown;
+        await rejects(() => loader(url), (e) => {
+          error = e;
+          return true;
+        });
+        ok(error instanceof UrlError);
+        deepStrictEqual(
+          error.reason,
+          result === "private" ? "disallowed" : "dns",
+        );
+        deepStrictEqual(
+          records.map((r) => [r.level, r.rawMessage, r.properties.url]),
+          [
+            result === "private"
+              ? ["error", "Disallowed private URL: {url}", url]
+              : ["debug", "DNS lookup failed for {url}", url],
+          ],
+        );
+        ok(records[0].properties.error === error);
+      } finally {
+        await reset();
+        dns.lookup = originalLookup;
+      }
+    });
+  }
+});
+
+test("getDocumentLoader() bounds alternate document chains", async (t) => {
+  const base = "https://example.com/alternate-chain/";
+  const loader = getDocumentLoader({ allowPrivateAddress: true });
+  for (const mode of ["header", "html", "mixed"] as const) {
+    for (const hops of [20, 21]) {
+      await t.test(`${mode}: ${hops} hops`, async () => {
+        fetchMock.mockGlobal();
+        let requests = 0;
+        fetchMock.get(`begin:${base}`, ({ url }) => {
+          requests++;
+          const index = Number(new URL(url).pathname.split("/").at(-1));
+          // Keep the unpatched regression bounded too.
+          if (index === hops || requests > 30) {
+            return Response.json({ done: true });
+          }
+          const next = `${base}${index + 1}`;
+          if (mode === "mixed" && index % 2 === 1) {
+            return Response.redirect(next, 302);
+          }
+          return alternate(next, mode === "html");
+        });
+        try {
+          if (hops === 20) {
+            deepStrictEqual((await loader(`${base}0`)).document, {
+              done: true,
+            });
+          } else {
+            await rejects(loader(`${base}0`), (error: unknown) => {
+              ok(error instanceof FetchError);
+              ok(error.message.includes("Too many redirections (21)"));
+              return true;
+            });
+          }
+          deepStrictEqual(requests, 21);
+        } finally {
+          fetchMock.hardReset();
+        }
+      });
+    }
+  }
+
+  for (
+    const mode of [
+      "header",
+      "html",
+      "alternate-redirect",
+      "redirect-alternate",
+      "redirect-intermediate",
+    ]
+  ) {
+    await t.test(`${mode}: cycle`, async () => {
+      fetchMock.mockGlobal();
+      let requests = 0;
+      fetchMock.get(`begin:${base}`, ({ url }) => {
+        requests++;
+        if (requests > 30) return Response.json({ stopped: true });
+        const index = Number(new URL(url).pathname.split("/").at(-1));
+        const next = `${base}${
+          mode === "redirect-intermediate"
+            ? (index === 0 ? 1 : index === 1 ? 2 : 1)
+            : 1 - index
+        }`;
+        if (
+          (mode === "alternate-redirect" && index === 1) ||
+          ((mode === "redirect-alternate" ||
+            mode === "redirect-intermediate") && index === 0)
+        ) {
+          return Response.redirect(next, 302);
+        }
+        return alternate(next, mode === "html");
+      });
+      try {
+        await rejects(loader(`${base}0`), (error: unknown) => {
+          ok(error instanceof FetchError);
+          ok(error.message.includes("Redirect loop detected:"));
+          return true;
+        });
+        deepStrictEqual(requests, mode === "redirect-intermediate" ? 3 : 2);
+      } finally {
+        fetchMock.hardReset();
+      }
+    });
+  }
+
+  await t.test("alternate followed by 20 redirects shares the limit", async () => {
+    fetchMock.mockGlobal();
+    let requests = 0;
+    fetchMock.get(`begin:${base}`, ({ url }) => {
+      requests++;
+      const index = Number(new URL(url).pathname.split("/").at(-1));
+      if (index === 21) return Response.json({ done: true });
+      return index === 0
+        ? alternate(`${base}1`, false)
+        : Response.redirect(`${base}${index + 1}`, 302);
+    });
+    try {
+      await rejects(loader(`${base}0`), (error: unknown) => {
+        ok(error instanceof FetchError);
+        ok(error.message.includes("Too many redirections (21)"));
+        return true;
+      });
+      deepStrictEqual(requests, 21);
+    } finally {
+      fetchMock.hardReset();
+    }
+  });
+
+  await t.test("relative alternate after redirect and isolated calls", async () => {
+    fetchMock.mockGlobal();
+    fetchMock.get(`${base}start`, Response.redirect(`${base}html`, 302));
+    fetchMock.get(`${base}html`, alternate("./document", true));
+    fetchMock.get(`${base}document`, Response.json({ done: true }));
+    try {
+      for (let i = 0; i < 2; i++) {
+        const results = await Promise.all([
+          loader(`${base}start`),
+          loader(`${base}start`),
+        ]);
+        for (const result of results) {
+          deepStrictEqual(result.document, { done: true });
+          deepStrictEqual(result.documentUrl, `${base}document`);
+        }
+      }
+    } finally {
+      fetchMock.hardReset();
+    }
+  });
+
+  function alternate(next: string, html: boolean): Response {
+    return html
+      ? new Response(
+        `<link rel="alternate" type="application/activity+json" href="${next}">`,
+        {
+          headers: { "Content-Type": "text/html" },
+        },
+      )
+      : new Response("not JSON", {
+        headers: {
+          "Content-Type": "text/plain",
+          Link: `<${next}>; rel="alternate"; type="application/activity+json"`,
+        },
+      });
+  }
+});
+
+test("getDocumentLoader() preserves cancellation across alternates", async (t) => {
+  const base = "https://example.com/alternate-abort/";
+  const loader = getDocumentLoader({ allowPrivateAddress: true });
+  for (const html of [false, true]) {
+    await t.test(html ? "HTML" : "Link header", async () => {
+      fetchMock.mockGlobal();
+      const controller = new AbortController();
+      let requests = 0;
+      fetchMock.get(`begin:${base}`, ({ url }) => {
+        requests++;
+        const index = Number(new URL(url).pathname.split("/").at(-1));
+        if (index === 2) return Response.json({ done: true });
+        if (index === 1) controller.abort();
+        const next = `${base}${index + 1}`;
+        return new Response(
+          html
+            ? `<link rel="alternate" type="application/activity+json" href="${next}">`
+            : "not JSON",
+          {
+            headers: html ? { "Content-Type": "text/html" } : {
+              "Content-Type": "text/plain",
+              Link:
+                `<${next}>; rel="alternate"; type="application/activity+json"`,
+            },
+          },
+        );
+      });
+      try {
+        await rejects(loader(`${base}0`, { signal: controller.signal }), {
+          name: "AbortError",
+        });
+        deepStrictEqual(requests, 2);
+      } finally {
+        fetchMock.hardReset();
+      }
+    });
+  }
+});
+
+test("getDocumentLoader() rejects cancellation before fetching", async () => {
+  fetchMock.mockGlobal();
+  let requests = 0;
+  const url = "https://example.com/pre-aborted-alternate";
+  fetchMock.get(url, () => {
+    requests++;
+    return Response.json({ done: true });
+  });
+  try {
+    const loader = getDocumentLoader({ allowPrivateAddress: true });
+    const controller = new AbortController();
+    controller.abort();
+    await rejects(loader(url, { signal: controller.signal }), {
+      name: "AbortError",
+    });
+    deepStrictEqual(requests, 0);
+  } finally {
+    fetchMock.hardReset();
+  }
+});