@fedify/vocab-runtime 2.3.2 → 2.3.4

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/vocab-runtime",
-  "version": "2.3.2",
+  "version": "2.3.4",
   "license": "MIT",
   "exports": {
     ".": "./src/mod.ts",

package/dist/mod.cjs

@@ -4341,12 +4341,29 @@ const preloadedContexts = {
 			"@id": "toot:attributionDomains",
 			"@type": "@id"
 		}
+	} },
+	"https://purl.archive.org/miscellany": { "@context": {
+		"as": "https://www.w3.org/ns/activitystreams#",
+		"xsd": "http://www.w3.org/2001/XMLSchema#",
+		"Hashtag": "as:Hashtag",
+		"manuallyApprovesFollowers": {
+			"@id": "as:manuallyApprovesFollowers",
+			"@type": "xsd:boolean"
+		},
+		"movedTo": {
+			"@id": "as:movedTo",
+			"@type": "@id"
+		},
+		"sensitive": {
+			"@id": "as:sensitive",
+			"@type": "xsd:boolean"
+		}
 	} }
 };
 //#endregion
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.3.2";
+var version = "2.3.4";
 //#endregion
 //#region src/link.ts
 const parametersNeedLowerCase = ["rel", "type"];
@@ -4601,8 +4618,8 @@ function logRequest(logger, request) {
 //#endregion
 //#region src/url.ts
 var UrlError = class extends Error {
-	constructor(message) {
-		super(message);
+	constructor(message, options) {
+		super(message, options);
 		this.name = "UrlError";
 	}
 };
@@ -4630,10 +4647,37 @@ async function validatePublicUrl(url) {
 	let addresses;
 	try {
 		addresses = await (0, node_dns_promises.lookup)(hostname, { all: true });
-	} catch {
-		addresses = [];
+	} catch (error) {
+		throw new UrlError("DNS lookup failed", { cause: error });
+	}
+	validateLookupAddresses(addresses);
+}
+/**
+* Validates the IP addresses returned by `node:dns.lookup()`.
+*
+* Cloudflare Workers' `node:dns` implementation currently maps every record
+* in a DNS-over-HTTPS `Answer` array—including CNAME records—to a
+* `LookupAddress`, even though Node.js specifies that the `address` field must
+* contain an IPv4 or IPv6 literal.  See:
+* https://github.com/cloudflare/workerd/issues/6886
+*
+* Work around that bug by ignoring non-IP entries only when the lookup also
+* returns at least one actual IP address.  This remains fail-closed: a result
+* containing no IP addresses is rejected, and every returned IP address is
+* still validated and must be public.  This workaround can be revisited once
+* the Workerd issue is fixed in supported Cloudflare Workers runtimes.
+*
+* @internal
+*/
+function validateLookupAddresses(addresses) {
+	let ipAddressCount = 0;
+	for (const { address } of addresses) {
+		const family = (0, node_net.isIP)(address);
+		if (family === 0) continue;
+		ipAddressCount++;
+		validatePublicIpAddress(address, family);
 	}
-	for (const { address, family } of addresses) validatePublicIpAddress(address, family);
+	if (ipAddressCount === 0) throw new UrlError("DNS lookup did not return any IP address");
 }
 function validatePublicIpAddress(address, family) {
 	if (family === 4 && isValidPublicIPv4Address(address) || family === 6 && isValidPublicIPv6Address(address)) return;

package/dist/mod.d.cts

@@ -458,7 +458,9 @@ type PropertyPreprocessor<T = unknown> = (value: Json, context: PropertyPreproce
 //#endregion
 //#region src/url.d.ts
 declare class UrlError extends Error {
-  constructor(message: string);
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
 }
 /**
 * Validates a URL to prevent SSRF attacks.

package/dist/mod.d.ts

@@ -1,7 +1,6 @@
 /// <reference lib="esnext.temporal" />
 import { Logger } from "@logtape/logtape";
 import { TracerProvider } from "@opentelemetry/api";
-
 //#region src/contexts.d.ts
 declare const preloadedContexts: Record<string, unknown>;
 //#endregion
@@ -458,7 +457,9 @@ type PropertyPreprocessor<T = unknown> = (value: Json, context: PropertyPreproce
 //#endregion
 //#region src/url.d.ts
 declare class UrlError extends Error {
-  constructor(message: string);
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
 }
 /**
 * Validates a URL to prevent SSRF attacks.

package/dist/mod.js

@@ -4337,12 +4337,29 @@ const preloadedContexts = {
 			"@id": "toot:attributionDomains",
 			"@type": "@id"
 		}
+	} },
+	"https://purl.archive.org/miscellany": { "@context": {
+		"as": "https://www.w3.org/ns/activitystreams#",
+		"xsd": "http://www.w3.org/2001/XMLSchema#",
+		"Hashtag": "as:Hashtag",
+		"manuallyApprovesFollowers": {
+			"@id": "as:manuallyApprovesFollowers",
+			"@type": "xsd:boolean"
+		},
+		"movedTo": {
+			"@id": "as:movedTo",
+			"@type": "@id"
+		},
+		"sensitive": {
+			"@id": "as:sensitive",
+			"@type": "xsd:boolean"
+		}
 	} }
 };
 //#endregion
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.3.2";
+var version = "2.3.4";
 //#endregion
 //#region src/link.ts
 const parametersNeedLowerCase = ["rel", "type"];
@@ -4597,8 +4614,8 @@ function logRequest(logger, request) {
 //#endregion
 //#region src/url.ts
 var UrlError = class extends Error {
-	constructor(message) {
-		super(message);
+	constructor(message, options) {
+		super(message, options);
 		this.name = "UrlError";
 	}
 };
@@ -4626,10 +4643,37 @@ async function validatePublicUrl(url) {
 	let addresses;
 	try {
 		addresses = await lookup(hostname, { all: true });
-	} catch {
-		addresses = [];
+	} catch (error) {
+		throw new UrlError("DNS lookup failed", { cause: error });
+	}
+	validateLookupAddresses(addresses);
+}
+/**
+* Validates the IP addresses returned by `node:dns.lookup()`.
+*
+* Cloudflare Workers' `node:dns` implementation currently maps every record
+* in a DNS-over-HTTPS `Answer` array—including CNAME records—to a
+* `LookupAddress`, even though Node.js specifies that the `address` field must
+* contain an IPv4 or IPv6 literal.  See:
+* https://github.com/cloudflare/workerd/issues/6886
+*
+* Work around that bug by ignoring non-IP entries only when the lookup also
+* returns at least one actual IP address.  This remains fail-closed: a result
+* containing no IP addresses is rejected, and every returned IP address is
+* still validated and must be public.  This workaround can be revisited once
+* the Workerd issue is fixed in supported Cloudflare Workers runtimes.
+*
+* @internal
+*/
+function validateLookupAddresses(addresses) {
+	let ipAddressCount = 0;
+	for (const { address } of addresses) {
+		const family = isIP(address);
+		if (family === 0) continue;
+		ipAddressCount++;
+		validatePublicIpAddress(address, family);
 	}
-	for (const { address, family } of addresses) validatePublicIpAddress(address, family);
+	if (ipAddressCount === 0) throw new UrlError("DNS lookup did not return any IP address");
 }
 function validatePublicIpAddress(address, family) {
 	if (family === 4 && isValidPublicIPv4Address(address) || family === 6 && isValidPublicIPv6Address(address)) return;

package/dist/tests/decimal.test.cjs

@@ -1,6 +1,6 @@
 require("./chunk-C2EiDwsr.cjs");
-require("./docloader-DmWDiCxH.cjs");
-require("./url-C20FhC7p.cjs");
+require("./docloader-BFM7h1Xa.cjs");
+require("./url-BF_Nb_Cu.cjs");
 require("./key-pMmqUKuo.cjs");
 require("./multibase-Bz_UUDtL.cjs");
 require("./langstr-CbAxaeEZ.cjs");

package/dist/tests/decimal.test.mjs

@@ -1,5 +1,5 @@
-import "./docloader-BOGED_Op.mjs";
-import "./url-m9Qzxy-Y.mjs";
+import "./docloader-BGlBKr7D.mjs";
+import "./url-o0e-aXQY.mjs";
 import "./key-CrrK9mYh.mjs";
 import "./multibase-B4bvakyA.mjs";
 import "./langstr-Di5AvKpB.mjs";

package/dist/tests/{docloader-DmWDiCxH.cjs → docloader-BFM7h1Xa.cjs}

@@ -1,7 +1,7 @@
 require("./chunk-C2EiDwsr.cjs");
-const require_request = require("./request-ClAnB4aH.cjs");
+const require_request = require("./request-BOB5ItB9.cjs");
 const require_link = require("./link-FguCydMA.cjs");
-const require_url = require("./url-C20FhC7p.cjs");
+const require_url = require("./url-BF_Nb_Cu.cjs");
 let _logtape_logtape = require("@logtape/logtape");
 let _opentelemetry_api = require("@opentelemetry/api");
 //#endregion
@@ -4331,6 +4331,23 @@ const preloadedContexts = {
 			"@id": "toot:attributionDomains",
 			"@type": "@id"
 		}
+	} },
+	"https://purl.archive.org/miscellany": { "@context": {
+		"as": "https://www.w3.org/ns/activitystreams#",
+		"xsd": "http://www.w3.org/2001/XMLSchema#",
+		"Hashtag": "as:Hashtag",
+		"manuallyApprovesFollowers": {
+			"@id": "as:manuallyApprovesFollowers",
+			"@type": "xsd:boolean"
+		},
+		"movedTo": {
+			"@id": "as:movedTo",
+			"@type": "@id"
+		},
+		"sensitive": {
+			"@id": "as:sensitive",
+			"@type": "xsd:boolean"
+		}
 	} }
 };
 //#endregion

package/dist/tests/{docloader-BOGED_Op.mjs → docloader-BGlBKr7D.mjs}

@@ -1,6 +1,6 @@
-import { a as name, i as logRequest, n as createActivityPubRequest, o as version, t as FetchError } from "./request-DcqSc5NX.mjs";
+import { a as name, i as logRequest, n as createActivityPubRequest, o as version, t as FetchError } from "./request-BaUm0-cs.mjs";
 import { t as HttpHeaderLink } from "./link-NUUWCdnK.mjs";
-import { a as validatePublicUrl, t as UrlError } from "./url-m9Qzxy-Y.mjs";
+import { o as validatePublicUrl, t as UrlError } from "./url-o0e-aXQY.mjs";
 import { getLogger } from "@logtape/logtape";
 import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 //#endregion
@@ -4330,6 +4330,23 @@ const preloadedContexts = {
 			"@id": "toot:attributionDomains",
 			"@type": "@id"
 		}
+	} },
+	"https://purl.archive.org/miscellany": { "@context": {
+		"as": "https://www.w3.org/ns/activitystreams#",
+		"xsd": "http://www.w3.org/2001/XMLSchema#",
+		"Hashtag": "as:Hashtag",
+		"manuallyApprovesFollowers": {
+			"@id": "as:manuallyApprovesFollowers",
+			"@type": "xsd:boolean"
+		},
+		"movedTo": {
+			"@id": "as:movedTo",
+			"@type": "@id"
+		},
+		"sensitive": {
+			"@id": "as:sensitive",
+			"@type": "xsd:boolean"
+		}
 	} }
 };
 //#endregion

package/dist/tests/docloader.test.cjs

@@ -1,7 +1,7 @@
 const require_chunk = require("./chunk-C2EiDwsr.cjs");
-const require_docloader = require("./docloader-DmWDiCxH.cjs");
-const require_request = require("./request-ClAnB4aH.cjs");
-const require_url = require("./url-C20FhC7p.cjs");
+const require_docloader = require("./docloader-BFM7h1Xa.cjs");
+const require_request = require("./request-BOB5ItB9.cjs");
+const require_url = require("./url-BF_Nb_Cu.cjs");
 let node_assert = require("node:assert");
 let node_test = require("node:test");
 //#region ../../node_modules/.pnpm/glob-to-regexp@0.4.1/node_modules/glob-to-regexp/index.js

package/dist/tests/docloader.test.mjs

@@ -1,6 +1,6 @@
-import { n as preloadedContexts, t as getDocumentLoader } from "./docloader-BOGED_Op.mjs";
-import { t as FetchError } from "./request-DcqSc5NX.mjs";
-import { t as UrlError } from "./url-m9Qzxy-Y.mjs";
+import { n as preloadedContexts, t as getDocumentLoader } from "./docloader-BGlBKr7D.mjs";
+import { t as FetchError } from "./request-BaUm0-cs.mjs";
+import { t as UrlError } from "./url-o0e-aXQY.mjs";
 import { deepStrictEqual, ok, rejects } from "node:assert";
 import { test } from "node:test";
 //#region \0rolldown/runtime.js

package/dist/tests/{request-ClAnB4aH.cjs → request-BOB5ItB9.cjs}

@@ -3,7 +3,7 @@ let node_process = require("node:process");
 node_process = require_chunk.__toESM(node_process, 1);
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.3.2";
+var version = "2.3.4";
 //#endregion
 //#region src/request.ts
 /**

package/dist/tests/{request-DcqSc5NX.mjs → request-BaUm0-cs.mjs}

@@ -1,7 +1,7 @@
 import process from "node:process";
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.3.2";
+var version = "2.3.4";
 //#endregion
 //#region src/request.ts
 /**

package/dist/tests/request.test.cjs

@@ -1,5 +1,5 @@
 const require_chunk = require("./chunk-C2EiDwsr.cjs");
-const require_request = require("./request-ClAnB4aH.cjs");
+const require_request = require("./request-BOB5ItB9.cjs");
 let node_assert = require("node:assert");
 let node_test = require("node:test");
 let node_process = require("node:process");

package/dist/tests/request.test.mjs

@@ -1,4 +1,4 @@
-import { o as version, r as getUserAgent } from "./request-DcqSc5NX.mjs";
+import { o as version, r as getUserAgent } from "./request-BaUm0-cs.mjs";
 import { deepStrictEqual } from "node:assert";
 import { test } from "node:test";
 import process from "node:process";

package/dist/tests/{url-C20FhC7p.cjs → url-BF_Nb_Cu.cjs}

@@ -3,8 +3,8 @@ let node_dns_promises = require("node:dns/promises");
 let node_net = require("node:net");
 //#region src/url.ts
 var UrlError = class extends Error {
-	constructor(message) {
-		super(message);
+	constructor(message, options) {
+		super(message, options);
 		this.name = "UrlError";
 	}
 };
@@ -32,10 +32,37 @@ async function validatePublicUrl(url) {
 	let addresses;
 	try {
 		addresses = await (0, node_dns_promises.lookup)(hostname, { all: true });
-	} catch {
-		addresses = [];
+	} catch (error) {
+		throw new UrlError("DNS lookup failed", { cause: error });
 	}
-	for (const { address, family } of addresses) validatePublicIpAddress(address, family);
+	validateLookupAddresses(addresses);
+}
+/**
+* Validates the IP addresses returned by `node:dns.lookup()`.
+*
+* Cloudflare Workers' `node:dns` implementation currently maps every record
+* in a DNS-over-HTTPS `Answer` array—including CNAME records—to a
+* `LookupAddress`, even though Node.js specifies that the `address` field must
+* contain an IPv4 or IPv6 literal.  See:
+* https://github.com/cloudflare/workerd/issues/6886
+*
+* Work around that bug by ignoring non-IP entries only when the lookup also
+* returns at least one actual IP address.  This remains fail-closed: a result
+* containing no IP addresses is rejected, and every returned IP address is
+* still validated and must be public.  This workaround can be revisited once
+* the Workerd issue is fixed in supported Cloudflare Workers runtimes.
+*
+* @internal
+*/
+function validateLookupAddresses(addresses) {
+	let ipAddressCount = 0;
+	for (const { address } of addresses) {
+		const family = (0, node_net.isIP)(address);
+		if (family === 0) continue;
+		ipAddressCount++;
+		validatePublicIpAddress(address, family);
+	}
+	if (ipAddressCount === 0) throw new UrlError("DNS lookup did not return any IP address");
 }
 function validatePublicIpAddress(address, family) {
 	if (family === 4 && isValidPublicIPv4Address(address) || family === 6 && isValidPublicIPv6Address(address)) return;
@@ -198,6 +225,12 @@ Object.defineProperty(exports, "isValidPublicIPv6Address", {
 		return isValidPublicIPv6Address;
 	}
 });
+Object.defineProperty(exports, "validateLookupAddresses", {
+	enumerable: true,
+	get: function() {
+		return validateLookupAddresses;
+	}
+});
 Object.defineProperty(exports, "validatePublicUrl", {
 	enumerable: true,
 	get: function() {

package/dist/tests/{url-m9Qzxy-Y.mjs → url-o0e-aXQY.mjs}

@@ -2,8 +2,8 @@ import { lookup } from "node:dns/promises";
 import { isIP } from "node:net";
 //#region src/url.ts
 var UrlError = class extends Error {
-	constructor(message) {
-		super(message);
+	constructor(message, options) {
+		super(message, options);
 		this.name = "UrlError";
 	}
 };
@@ -31,10 +31,37 @@ async function validatePublicUrl(url) {
 	let addresses;
 	try {
 		addresses = await lookup(hostname, { all: true });
-	} catch {
-		addresses = [];
+	} catch (error) {
+		throw new UrlError("DNS lookup failed", { cause: error });
 	}
-	for (const { address, family } of addresses) validatePublicIpAddress(address, family);
+	validateLookupAddresses(addresses);
+}
+/**
+* Validates the IP addresses returned by `node:dns.lookup()`.
+*
+* Cloudflare Workers' `node:dns` implementation currently maps every record
+* in a DNS-over-HTTPS `Answer` array—including CNAME records—to a
+* `LookupAddress`, even though Node.js specifies that the `address` field must
+* contain an IPv4 or IPv6 literal.  See:
+* https://github.com/cloudflare/workerd/issues/6886
+*
+* Work around that bug by ignoring non-IP entries only when the lookup also
+* returns at least one actual IP address.  This remains fail-closed: a result
+* containing no IP addresses is rejected, and every returned IP address is
+* still validated and must be public.  This workaround can be revisited once
+* the Workerd issue is fixed in supported Cloudflare Workers runtimes.
+*
+* @internal
+*/
+function validateLookupAddresses(addresses) {
+	let ipAddressCount = 0;
+	for (const { address } of addresses) {
+		const family = isIP(address);
+		if (family === 0) continue;
+		ipAddressCount++;
+		validatePublicIpAddress(address, family);
+	}
+	if (ipAddressCount === 0) throw new UrlError("DNS lookup did not return any IP address");
 }
 function validatePublicIpAddress(address, family) {
 	if (family === 4 && isValidPublicIPv4Address(address) || family === 6 && isValidPublicIPv6Address(address)) return;
@@ -173,4 +200,4 @@ function matchesIPv6Prefix(address, prefixWords, prefixLength) {
 	return true;
 }
 //#endregion
-export { validatePublicUrl as a, isValidPublicIPv6Address as i, expandIPv6Address as n, isValidPublicIPv4Address as r, UrlError as t };
+export { validateLookupAddresses as a, isValidPublicIPv6Address as i, expandIPv6Address as n, validatePublicUrl as o, isValidPublicIPv4Address as r, UrlError as t };

package/dist/tests/url.test.cjs

@@ -1,5 +1,5 @@
 require("./chunk-C2EiDwsr.cjs");
-const require_url = require("./url-C20FhC7p.cjs");
+const require_url = require("./url-BF_Nb_Cu.cjs");
 let node_assert = require("node:assert");
 let node_test = require("node:test");
 //#region src/url.test.ts
@@ -29,6 +29,35 @@ let node_test = require("node:test");
 	await require_url.validatePublicUrl("https://[2001:db8::1]");
 	await require_url.validatePublicUrl("https://[64:ff9b::8.8.8.8]");
 });
+(0, node_test.test)("validateLookupAddresses() tolerates Cloudflare Workers CNAME entries", () => {
+	require_url.validateLookupAddresses([
+		{
+			address: "app-host.example.net.",
+			family: 4
+		},
+		{
+			address: "93.184.216.34",
+			family: 4
+		},
+		{
+			address: "2606:2800:220:1:248:1893:25c8:1946",
+			family: 6
+		}
+	]);
+});
+(0, node_test.test)("validateLookupAddresses() rejects unsafe or CNAME-only Cloudflare Workers results", () => {
+	(0, node_assert.throws)(() => require_url.validateLookupAddresses([{
+		address: "private-host.example.net.",
+		family: 4
+	}, {
+		address: "127.0.0.1",
+		family: 4
+	}]), require_url.UrlError);
+	(0, node_assert.throws)(() => require_url.validateLookupAddresses([{
+		address: "app-host.example.net.",
+		family: 4
+	}]), require_url.UrlError);
+});
 (0, node_test.test)("isValidPublicIPv4Address()", () => {
 	(0, node_assert.ok)(require_url.isValidPublicIPv4Address("8.8.8.8"));
 	(0, node_assert.ok)(!require_url.isValidPublicIPv4Address("192.168.1.1"));

package/dist/tests/url.test.mjs

@@ -1,5 +1,5 @@
-import { a as validatePublicUrl, i as isValidPublicIPv6Address, n as expandIPv6Address, r as isValidPublicIPv4Address, t as UrlError } from "./url-m9Qzxy-Y.mjs";
-import { deepStrictEqual, ok, rejects } from "node:assert";
+import { a as validateLookupAddresses, i as isValidPublicIPv6Address, n as expandIPv6Address, o as validatePublicUrl, r as isValidPublicIPv4Address, t as UrlError } from "./url-o0e-aXQY.mjs";
+import { deepStrictEqual, ok, rejects, throws } from "node:assert";
 import { test } from "node:test";
 //#region src/url.test.ts
 test("validatePublicUrl()", async () => {
@@ -28,6 +28,35 @@ test("validatePublicUrl()", async () => {
 	await validatePublicUrl("https://[2001:db8::1]");
 	await validatePublicUrl("https://[64:ff9b::8.8.8.8]");
 });
+test("validateLookupAddresses() tolerates Cloudflare Workers CNAME entries", () => {
+	validateLookupAddresses([
+		{
+			address: "app-host.example.net.",
+			family: 4
+		},
+		{
+			address: "93.184.216.34",
+			family: 4
+		},
+		{
+			address: "2606:2800:220:1:248:1893:25c8:1946",
+			family: 6
+		}
+	]);
+});
+test("validateLookupAddresses() rejects unsafe or CNAME-only Cloudflare Workers results", () => {
+	throws(() => validateLookupAddresses([{
+		address: "private-host.example.net.",
+		family: 4
+	}, {
+		address: "127.0.0.1",
+		family: 4
+	}]), UrlError);
+	throws(() => validateLookupAddresses([{
+		address: "app-host.example.net.",
+		family: 4
+	}]), UrlError);
+});
 test("isValidPublicIPv4Address()", () => {
 	ok(isValidPublicIPv4Address("8.8.8.8"));
 	ok(!isValidPublicIPv4Address("192.168.1.1"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/vocab-runtime",
-  "version": "2.3.2",
+  "version": "2.3.4",
   "homepage": "https://fedify.dev/",
   "repository": {
     "type": "git",

package/src/contexts/miscellany.json

@@ -0,0 +1,19 @@
+{
+  "@context": {
+    "as": "https://www.w3.org/ns/activitystreams#",
+    "xsd": "http://www.w3.org/2001/XMLSchema#",
+    "Hashtag": "as:Hashtag",
+    "manuallyApprovesFollowers": {
+      "@id": "as:manuallyApprovesFollowers",
+      "@type": "xsd:boolean"
+    },
+    "movedTo": {
+      "@id": "as:movedTo",
+      "@type": "@id"
+    },
+    "sensitive": {
+      "@id": "as:sensitive",
+      "@type": "xsd:boolean"
+    }
+  }
+}

package/src/contexts.ts

@@ -11,6 +11,7 @@ import gotosocial from "./contexts/gotosocial.json" with { type: "json" };
 import identityV1 from "./contexts/identity-v1.json" with { type: "json" };
 import joinLemmyContext from "./contexts/join-lemmy.json" with { type: "json" };
 import joinmastodon from "./contexts/joinmastodon.json" with { type: "json" };
+import miscellany from "./contexts/miscellany.json" with { type: "json" };
 import schemaorg from "./contexts/schemaorg.json" with { type: "json" };
 import securityDataIntegrityV1 from "./contexts/security-data-integrity-v1.json" with {
   type: "json",
@@ -55,6 +56,18 @@ const preloadedContexts: Record<string, unknown> = {
   // See: https://github.com/mastodon/joinmastodon/issues/148
   //      https://github.com/fedify-dev/fedify/issues/630
   "http://joinmastodon.org/ns": joinmastodon,
+
+  // The SWICG "ActivityPub Miscellaneous Terms" context.  Bridgy Fed (via
+  // granary) references this URL in the @context of every activity it sends,
+  // and other implementations use it as the recommended home for widely
+  // deployed extension terms like as:Hashtag and as:sensitive.  It is served
+  // through purl.archive.org (Internet Archive's PURL service), which suffers
+  // recurring outages; while it is unreachable, every activity referencing
+  // this URL fails JSON-LD expansion before application handlers run.  The
+  // document is a deliberately stable, versioned SWICG deliverable, so we
+  // ship a built-in copy.
+  // See: https://swicg.github.io/miscellany/
+  "https://purl.archive.org/miscellany": miscellany,
 };
 
 export default preloadedContexts;

package/src/url.test.ts

@@ -1,10 +1,11 @@
-import { deepStrictEqual, ok, rejects } from "node:assert";
+import { deepStrictEqual, ok, rejects, throws } from "node:assert";
 import { test } from "node:test";
 import {
   expandIPv6Address,
   isValidPublicIPv4Address,
   isValidPublicIPv6Address,
   UrlError,
+  validateLookupAddresses,
   validatePublicUrl,
 } from "./url.ts";
 
@@ -65,6 +66,32 @@ test("validatePublicUrl()", async () => {
   await validatePublicUrl("https://[64:ff9b::8.8.8.8]");
 });
 
+test("validateLookupAddresses() tolerates Cloudflare Workers CNAME entries", () => {
+  validateLookupAddresses([
+    { address: "app-host.example.net.", family: 4 },
+    { address: "93.184.216.34", family: 4 },
+    { address: "2606:2800:220:1:248:1893:25c8:1946", family: 6 },
+  ]);
+});
+
+test("validateLookupAddresses() rejects unsafe or CNAME-only Cloudflare Workers results", () => {
+  throws(
+    () =>
+      validateLookupAddresses([
+        { address: "private-host.example.net.", family: 4 },
+        { address: "127.0.0.1", family: 4 },
+      ]),
+    UrlError,
+  );
+  throws(
+    () =>
+      validateLookupAddresses([
+        { address: "app-host.example.net.", family: 4 },
+      ]),
+    UrlError,
+  );
+});
+
 test("isValidPublicIPv4Address()", () => {
   ok(isValidPublicIPv4Address("8.8.8.8")); // Google DNS
   ok(!isValidPublicIPv4Address("192.168.1.1")); // private

package/src/url.ts

@@ -3,8 +3,8 @@ import { lookup } from "node:dns/promises";
 import { isIP } from "node:net";
 
 export class UrlError extends Error {
-  constructor(message: string) {
-    super(message);
+  constructor(message: string, options?: { cause?: unknown }) {
+    super(message, options);
     this.name = "UrlError";
   }
 }
@@ -51,12 +51,42 @@ export async function validatePublicUrl(url: string): Promise<void> {
   let addresses: LookupAddress[];
   try {
     addresses = await lookup(hostname, { all: true });
-  } catch {
-    addresses = [];
+  } catch (error) {
+    throw new UrlError("DNS lookup failed", { cause: error });
   }
-  for (const { address, family } of addresses) {
+  validateLookupAddresses(addresses);
+}
+
+/**
+ * Validates the IP addresses returned by `node:dns.lookup()`.
+ *
+ * Cloudflare Workers' `node:dns` implementation currently maps every record
+ * in a DNS-over-HTTPS `Answer` array—including CNAME records—to a
+ * `LookupAddress`, even though Node.js specifies that the `address` field must
+ * contain an IPv4 or IPv6 literal.  See:
+ * https://github.com/cloudflare/workerd/issues/6886
+ *
+ * Work around that bug by ignoring non-IP entries only when the lookup also
+ * returns at least one actual IP address.  This remains fail-closed: a result
+ * containing no IP addresses is rejected, and every returned IP address is
+ * still validated and must be public.  This workaround can be revisited once
+ * the Workerd issue is fixed in supported Cloudflare Workers runtimes.
+ *
+ * @internal
+ */
+export function validateLookupAddresses(
+  addresses: readonly LookupAddress[],
+): void {
+  let ipAddressCount = 0;
+  for (const { address } of addresses) {
+    const family = isIP(address);
+    if (family === 0) continue;
+    ipAddressCount++;
     validatePublicIpAddress(address, family);
   }
+  if (ipAddressCount === 0) {
+    throw new UrlError("DNS lookup did not return any IP address");
+  }
 }
 
 function validatePublicIpAddress(address: string, family: number): void {