@fedify/vocab-runtime 2.4.0-dev.2169 → 2.4.0-dev.2193

package/dist/tests/docloader.test.cjs

@@ -1,8 +1,8 @@
 const require_rolldown_runtime = require("./rolldown-runtime-emK7D4bc.cjs");
-const require_request = require("./request-Dm3ye46t.cjs");
+const require_request = require("./request-C5_3S-un.cjs");
 const require_contexts = require("./contexts-DizzBjz4.cjs");
-const require_url = require("./url-gLKqAO1H.cjs");
-const require_docloader = require("./docloader-DLkb9qAS.cjs");
+const require_url = require("./url-B8xyTwP-.cjs");
+const require_docloader = require("./docloader-Vc3BC9ad.cjs");
 let node_test = require("node:test");
 let node_zlib = require("node:zlib");
 let _logtape_logtape = require("@logtape/logtape");
@@ -1990,4 +1990,267 @@ var esm_default = new class FetchMock {
 		esm_default.hardReset();
 	}
 });
+async function withServer(handler, callback) {
+	const server = (0, node_http.createServer)(handler);
+	await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(0, "127.0.0.1", resolve);
+	});
+	try {
+		const address = server.address();
+		(0, node_assert.ok)(address != null && typeof address !== "string");
+		return await callback(`http://127.0.0.1:${address.port}`);
+	} finally {
+		await new Promise((resolve, reject) => {
+			server.close((error) => error == null ? resolve() : reject(error));
+			server.closeAllConnections();
+		});
+	}
+}
+function isTimeoutFetchError(error, url) {
+	(0, node_assert.ok)(error instanceof require_request.FetchError, String(error));
+	(0, node_assert.deepStrictEqual)(error.url.href, url);
+	(0, node_assert.deepStrictEqual)(error.response, void 0);
+	(0, node_assert.ok)(error.cause instanceof DOMException);
+	(0, node_assert.deepStrictEqual)(error.cause.name, "TimeoutError");
+	return true;
+}
+(0, node_test.test)("resolveDocumentLoaderTimeout() validates timeouts", () => {
+	(0, node_assert.deepStrictEqual)(require_docloader.resolveDocumentLoaderTimeout(void 0), 1e4);
+	(0, node_assert.deepStrictEqual)(require_docloader.resolveDocumentLoaderTimeout(null), null);
+	(0, node_assert.deepStrictEqual)(require_docloader.resolveDocumentLoaderTimeout(1500), 1500);
+	(0, node_assert.deepStrictEqual)(require_docloader.resolveDocumentLoaderTimeout(.5), 1);
+	(0, node_assert.deepStrictEqual)(require_docloader.resolveDocumentLoaderTimeout(2147483647), 2147483647);
+	for (const invalid of [
+		0,
+		-1,
+		NaN,
+		Infinity,
+		2147483648
+	]) (0, node_assert.throws)(() => require_docloader.resolveDocumentLoaderTimeout(invalid), RangeError);
+	(0, node_assert.throws)(() => require_docloader.getDocumentLoader({ timeout: 0 }), RangeError);
+});
+(0, node_test.test)("getDocumentLoader() times out a request without a response", async () => {
+	await withServer(() => {}, async (baseUrl) => {
+		const url = `${baseUrl}/hang`;
+		await (0, node_assert.rejects)(require_docloader.getDocumentLoader({
+			allowPrivateAddress: true,
+			timeout: 100
+		})(url), (e) => isTimeoutFetchError(e, url));
+	});
+});
+(0, node_test.test)("getDocumentLoader() times out a stalled response body", async () => {
+	for (const status of [200, 404]) await withServer((_, response) => {
+		response.writeHead(status, { "Content-Type": "application/activity+json" });
+		response.write("{\"id\":");
+	}, async (baseUrl) => {
+		const url = `${baseUrl}/stalled`;
+		await (0, node_assert.rejects)(require_docloader.getDocumentLoader({
+			allowPrivateAddress: true,
+			timeout: 200
+		})(url), (e) => isTimeoutFetchError(e, url));
+	});
+});
+(0, node_test.test)("getDocumentLoader() shares the timeout across redirects", async () => {
+	let requests = 0;
+	await withServer((request, response) => {
+		requests++;
+		const index = Number(request.url?.split("/").at(-1));
+		setTimeout(() => {
+			if (index >= 15) {
+				response.writeHead(200, { "Content-Type": "application/activity+json" });
+				response.end("{\"done\":true}");
+				return;
+			}
+			response.writeHead(302, { Location: `/redirect/${index + 1}` });
+			response.end();
+		}, 50);
+	}, async (baseUrl) => {
+		const url = `${baseUrl}/redirect/0`;
+		await (0, node_assert.rejects)(require_docloader.getDocumentLoader({
+			allowPrivateAddress: true,
+			timeout: 300
+		})(url), (e) => isTimeoutFetchError(e, url));
+		(0, node_assert.ok)(requests < 16, `requests: ${requests}`);
+		(0, node_assert.deepStrictEqual)((await require_docloader.getDocumentLoader({
+			allowPrivateAddress: true,
+			timeout: null
+		})(url)).document, { done: true });
+	});
+});
+(0, node_test.test)("getDocumentLoader() shares the timeout across alternates", async (t) => {
+	for (const html of [false, true]) await t.test(html ? "HTML" : "Link header", async () => {
+		await withServer((request, response) => {
+			const index = Number(request.url?.split("/").at(-1));
+			setTimeout(() => {
+				if (index >= 15) {
+					response.writeHead(200, { "Content-Type": "application/activity+json" });
+					response.end("{\"done\":true}");
+					return;
+				}
+				const next = `/alternate/${index + 1}`;
+				response.writeHead(200, html ? { "Content-Type": "text/html" } : {
+					"Content-Type": "text/plain",
+					Link: `<${next}>; rel="alternate"; type="application/activity+json"`
+				});
+				response.end(html ? `<link rel="alternate" type="application/activity+json" href="${next}">` : "not JSON");
+			}, 50);
+		}, async (baseUrl) => {
+			const url = `${baseUrl}/alternate/0`;
+			await (0, node_assert.rejects)(require_docloader.getDocumentLoader({
+				allowPrivateAddress: true,
+				timeout: 300
+			})(url), (e) => isTimeoutFetchError(e, url));
+		});
+	});
+});
+(0, node_test.test)("getDocumentLoader() lets the caller's signal abort a request", async () => {
+	await withServer(() => {}, async (baseUrl) => {
+		const url = `${baseUrl}/hang`;
+		for (const timeout of [
+			void 0,
+			6e4,
+			null
+		]) {
+			const loader = require_docloader.getDocumentLoader({
+				allowPrivateAddress: true,
+				timeout
+			});
+			const controller = new AbortController();
+			const reason = /* @__PURE__ */ new Error("Canceled by the caller");
+			setTimeout(() => controller.abort(reason), 50);
+			await (0, node_assert.rejects)(loader(url, { signal: controller.signal }), (e) => {
+				(0, node_assert.deepStrictEqual)(e, reason);
+				return true;
+			});
+		}
+		const loader = require_docloader.getDocumentLoader({
+			allowPrivateAddress: true,
+			timeout: 50
+		});
+		const controller = new AbortController();
+		const reason = /* @__PURE__ */ new Error("Canceled by the caller");
+		controller.abort(reason);
+		await (0, node_assert.rejects)(loader(url, { signal: controller.signal }), (e) => {
+			(0, node_assert.deepStrictEqual)(e, reason);
+			return true;
+		});
+	});
+});
+(0, node_test.test)("getDocumentLoader() bounds DNS lookups that ignore the timeout", async (t) => {
+	if ("Deno" in globalThis && (await Deno.permissions.query({ name: "net" })).state !== "granted") {
+		t.skip("requires the net permission");
+		return;
+	}
+	esm_default.mockGlobal();
+	let requests = 0;
+	const url = "https://slow-dns.example/object";
+	esm_default.get(url, () => {
+		requests++;
+		return Response.json({ id: url });
+	});
+	const originalLookup = node_dns_promises.default.lookup;
+	let resolveLookup = () => {};
+	const lookedUp = new Promise((resolve) => resolveLookup = resolve);
+	node_dns_promises.default.lookup = (() => new Promise((resolve) => setTimeout(() => {
+		resolve([{
+			address: "93.184.215.14",
+			family: 4
+		}]);
+		resolveLookup();
+	}, 200)));
+	try {
+		await (0, node_assert.rejects)(require_docloader.getDocumentLoader({ timeout: 50 })(url), (e) => isTimeoutFetchError(e, url));
+		await lookedUp;
+		await new Promise((resolve) => setTimeout(resolve, 10));
+		(0, node_assert.deepStrictEqual)(requests, 0);
+	} finally {
+		node_dns_promises.default.lookup = originalLookup;
+		esm_default.hardReset();
+	}
+});
+(0, node_test.test)("withDocumentLoaderTimeout() cleans up after each call", async () => {
+	const signals = [];
+	const loader = require_docloader.withDocumentLoaderTimeout((url, options) => {
+		signals.push(options.signal);
+		return Promise.resolve({
+			contextUrl: null,
+			document: {},
+			documentUrl: url
+		});
+	}, 50);
+	(0, node_assert.deepStrictEqual)((await Promise.all([loader("https://example.com/a"), loader("https://example.com/b")])).map((r) => r.documentUrl), ["https://example.com/a", "https://example.com/b"]);
+	(0, node_assert.ok)(signals[0] !== signals[1]);
+	await new Promise((resolve) => setTimeout(resolve, 100));
+	(0, node_assert.ok)(signals.every((signal) => !signal.aborted));
+	const inner = () => Promise.reject(/* @__PURE__ */ new Error("unused"));
+	(0, node_assert.ok)(require_docloader.withDocumentLoaderTimeout(inner, null) === inner);
+});
+(0, node_test.test)("getRemoteDocument() keeps error bodies byte for byte", async () => {
+	const bytes = new Uint8Array([
+		239,
+		187,
+		191,
+		78,
+		111,
+		255,
+		254
+	]);
+	const url = "https://example.com/error";
+	let error;
+	await (0, node_assert.rejects)(require_docloader.getRemoteDocument(url, new Response(bytes, { status: 404 }), () => Promise.reject(/* @__PURE__ */ new Error("unused"))), (e) => {
+		error = e;
+		return true;
+	});
+	(0, node_assert.ok)(error instanceof require_request.FetchError);
+	(0, node_assert.ok)(error.response != null);
+	(0, node_assert.deepStrictEqual)(error.response.status, 404);
+	(0, node_assert.deepStrictEqual)(new Uint8Array(await error.response.arrayBuffer()), bytes);
+});
+(0, node_test.test)("getRemoteDocument() keeps metadata of bodiless or large errors", async () => {
+	const url = "https://example.com/error";
+	for (const response of [new Response(null, {
+		status: 304,
+		headers: { ETag: "\"a\"" }
+	}), new Response(/* @__PURE__ */ new Uint8Array(1048577), {
+		status: 500,
+		headers: { ETag: "\"a\"" }
+	})]) await (0, node_assert.rejects)(require_docloader.getRemoteDocument(url, response, () => Promise.reject(/* @__PURE__ */ new Error("unused"))), (e) => {
+		(0, node_assert.ok)(e instanceof require_request.FetchError);
+		(0, node_assert.ok)(e.response != null);
+		(0, node_assert.deepStrictEqual)(e.response.status, response.status);
+		(0, node_assert.deepStrictEqual)(e.response.headers.get("ETag"), "\"a\"");
+		(0, node_assert.deepStrictEqual)(e.response.body, null);
+		return true;
+	});
+});
+(0, node_test.test)("getDocumentLoader() reports statuses that Response cannot hold", async () => {
+	await withServer((_, response) => {
+		response.writeHead(999);
+		response.end("Request denied");
+	}, async (baseUrl) => {
+		const url = `${baseUrl}/denied`;
+		const loader = require_docloader.getDocumentLoader({ allowPrivateAddress: true });
+		let error;
+		await (0, node_assert.rejects)(loader(url), (e) => {
+			error = e;
+			return true;
+		});
+		(0, node_assert.ok)(error instanceof require_request.FetchError, String(error));
+		(0, node_assert.deepStrictEqual)(error.response?.status, 999);
+		(0, node_assert.deepStrictEqual)(await error.response.text(), "Request denied");
+	});
+});
+(0, node_test.test)("getDocumentLoader() times out a stalled body of such a status", async () => {
+	await withServer((_, response) => {
+		response.writeHead(999);
+		response.write("Request");
+	}, async (baseUrl) => {
+		const url = `${baseUrl}/stalled-denied`;
+		await (0, node_assert.rejects)(require_docloader.getDocumentLoader({
+			allowPrivateAddress: true,
+			timeout: 200
+		})(url), (e) => isTimeoutFetchError(e, url));
+	});
+});
 //#endregion

package/dist/tests/docloader.test.mjs

@@ -1,11 +1,11 @@
-import { t as FetchError } from "./request-Cg8MQByW.mjs";
+import { t as FetchError } from "./request-IIntZ5kj.mjs";
 import { n as cid_v1_default, t as preloadedContexts } from "./contexts-CIKsin4e.mjs";
-import { t as UrlError } from "./url-D7qRF-dF.mjs";
-import { n as getRemoteDocument, t as getDocumentLoader } from "./docloader-DWkl3u7X.mjs";
+import { t as UrlError } from "./url-DfS-cvwr.mjs";
+import { i as withDocumentLoaderTimeout, n as getRemoteDocument, r as resolveDocumentLoaderTimeout, t as getDocumentLoader } from "./docloader-CUdtpDuf.mjs";
 import { test } from "node:test";
 import { gzipSync } from "node:zlib";
 import { configure, reset } from "@logtape/logtape";
-import { deepStrictEqual, ok, rejects } from "node:assert";
+import { deepStrictEqual, ok, rejects, throws } from "node:assert";
 import dns from "node:dns/promises";
 import { createServer } from "node:http";
 //#region \0rolldown/runtime.js
@@ -2008,5 +2008,268 @@ test("getDocumentLoader() rejects cancellation before fetching", async () => {
 		esm_default.hardReset();
 	}
 });
+async function withServer(handler, callback) {
+	const server = createServer(handler);
+	await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(0, "127.0.0.1", resolve);
+	});
+	try {
+		const address = server.address();
+		ok(address != null && typeof address !== "string");
+		return await callback(`http://127.0.0.1:${address.port}`);
+	} finally {
+		await new Promise((resolve, reject) => {
+			server.close((error) => error == null ? resolve() : reject(error));
+			server.closeAllConnections();
+		});
+	}
+}
+function isTimeoutFetchError(error, url) {
+	ok(error instanceof FetchError, String(error));
+	deepStrictEqual(error.url.href, url);
+	deepStrictEqual(error.response, void 0);
+	ok(error.cause instanceof DOMException);
+	deepStrictEqual(error.cause.name, "TimeoutError");
+	return true;
+}
+test("resolveDocumentLoaderTimeout() validates timeouts", () => {
+	deepStrictEqual(resolveDocumentLoaderTimeout(void 0), 1e4);
+	deepStrictEqual(resolveDocumentLoaderTimeout(null), null);
+	deepStrictEqual(resolveDocumentLoaderTimeout(1500), 1500);
+	deepStrictEqual(resolveDocumentLoaderTimeout(.5), 1);
+	deepStrictEqual(resolveDocumentLoaderTimeout(2147483647), 2147483647);
+	for (const invalid of [
+		0,
+		-1,
+		NaN,
+		Infinity,
+		2147483648
+	]) throws(() => resolveDocumentLoaderTimeout(invalid), RangeError);
+	throws(() => getDocumentLoader({ timeout: 0 }), RangeError);
+});
+test("getDocumentLoader() times out a request without a response", async () => {
+	await withServer(() => {}, async (baseUrl) => {
+		const url = `${baseUrl}/hang`;
+		await rejects(getDocumentLoader({
+			allowPrivateAddress: true,
+			timeout: 100
+		})(url), (e) => isTimeoutFetchError(e, url));
+	});
+});
+test("getDocumentLoader() times out a stalled response body", async () => {
+	for (const status of [200, 404]) await withServer((_, response) => {
+		response.writeHead(status, { "Content-Type": "application/activity+json" });
+		response.write("{\"id\":");
+	}, async (baseUrl) => {
+		const url = `${baseUrl}/stalled`;
+		await rejects(getDocumentLoader({
+			allowPrivateAddress: true,
+			timeout: 200
+		})(url), (e) => isTimeoutFetchError(e, url));
+	});
+});
+test("getDocumentLoader() shares the timeout across redirects", async () => {
+	let requests = 0;
+	await withServer((request, response) => {
+		requests++;
+		const index = Number(request.url?.split("/").at(-1));
+		setTimeout(() => {
+			if (index >= 15) {
+				response.writeHead(200, { "Content-Type": "application/activity+json" });
+				response.end("{\"done\":true}");
+				return;
+			}
+			response.writeHead(302, { Location: `/redirect/${index + 1}` });
+			response.end();
+		}, 50);
+	}, async (baseUrl) => {
+		const url = `${baseUrl}/redirect/0`;
+		await rejects(getDocumentLoader({
+			allowPrivateAddress: true,
+			timeout: 300
+		})(url), (e) => isTimeoutFetchError(e, url));
+		ok(requests < 16, `requests: ${requests}`);
+		deepStrictEqual((await getDocumentLoader({
+			allowPrivateAddress: true,
+			timeout: null
+		})(url)).document, { done: true });
+	});
+});
+test("getDocumentLoader() shares the timeout across alternates", async (t) => {
+	for (const html of [false, true]) await t.test(html ? "HTML" : "Link header", async () => {
+		await withServer((request, response) => {
+			const index = Number(request.url?.split("/").at(-1));
+			setTimeout(() => {
+				if (index >= 15) {
+					response.writeHead(200, { "Content-Type": "application/activity+json" });
+					response.end("{\"done\":true}");
+					return;
+				}
+				const next = `/alternate/${index + 1}`;
+				response.writeHead(200, html ? { "Content-Type": "text/html" } : {
+					"Content-Type": "text/plain",
+					Link: `<${next}>; rel="alternate"; type="application/activity+json"`
+				});
+				response.end(html ? `<link rel="alternate" type="application/activity+json" href="${next}">` : "not JSON");
+			}, 50);
+		}, async (baseUrl) => {
+			const url = `${baseUrl}/alternate/0`;
+			await rejects(getDocumentLoader({
+				allowPrivateAddress: true,
+				timeout: 300
+			})(url), (e) => isTimeoutFetchError(e, url));
+		});
+	});
+});
+test("getDocumentLoader() lets the caller's signal abort a request", async () => {
+	await withServer(() => {}, async (baseUrl) => {
+		const url = `${baseUrl}/hang`;
+		for (const timeout of [
+			void 0,
+			6e4,
+			null
+		]) {
+			const loader = getDocumentLoader({
+				allowPrivateAddress: true,
+				timeout
+			});
+			const controller = new AbortController();
+			const reason = /* @__PURE__ */ new Error("Canceled by the caller");
+			setTimeout(() => controller.abort(reason), 50);
+			await rejects(loader(url, { signal: controller.signal }), (e) => {
+				deepStrictEqual(e, reason);
+				return true;
+			});
+		}
+		const loader = getDocumentLoader({
+			allowPrivateAddress: true,
+			timeout: 50
+		});
+		const controller = new AbortController();
+		const reason = /* @__PURE__ */ new Error("Canceled by the caller");
+		controller.abort(reason);
+		await rejects(loader(url, { signal: controller.signal }), (e) => {
+			deepStrictEqual(e, reason);
+			return true;
+		});
+	});
+});
+test("getDocumentLoader() bounds DNS lookups that ignore the timeout", async (t) => {
+	if ("Deno" in globalThis && (await Deno.permissions.query({ name: "net" })).state !== "granted") {
+		t.skip("requires the net permission");
+		return;
+	}
+	esm_default.mockGlobal();
+	let requests = 0;
+	const url = "https://slow-dns.example/object";
+	esm_default.get(url, () => {
+		requests++;
+		return Response.json({ id: url });
+	});
+	const originalLookup = dns.lookup;
+	let resolveLookup = () => {};
+	const lookedUp = new Promise((resolve) => resolveLookup = resolve);
+	dns.lookup = (() => new Promise((resolve) => setTimeout(() => {
+		resolve([{
+			address: "93.184.215.14",
+			family: 4
+		}]);
+		resolveLookup();
+	}, 200)));
+	try {
+		await rejects(getDocumentLoader({ timeout: 50 })(url), (e) => isTimeoutFetchError(e, url));
+		await lookedUp;
+		await new Promise((resolve) => setTimeout(resolve, 10));
+		deepStrictEqual(requests, 0);
+	} finally {
+		dns.lookup = originalLookup;
+		esm_default.hardReset();
+	}
+});
+test("withDocumentLoaderTimeout() cleans up after each call", async () => {
+	const signals = [];
+	const loader = withDocumentLoaderTimeout((url, options) => {
+		signals.push(options.signal);
+		return Promise.resolve({
+			contextUrl: null,
+			document: {},
+			documentUrl: url
+		});
+	}, 50);
+	deepStrictEqual((await Promise.all([loader("https://example.com/a"), loader("https://example.com/b")])).map((r) => r.documentUrl), ["https://example.com/a", "https://example.com/b"]);
+	ok(signals[0] !== signals[1]);
+	await new Promise((resolve) => setTimeout(resolve, 100));
+	ok(signals.every((signal) => !signal.aborted));
+	const inner = () => Promise.reject(/* @__PURE__ */ new Error("unused"));
+	ok(withDocumentLoaderTimeout(inner, null) === inner);
+});
+test("getRemoteDocument() keeps error bodies byte for byte", async () => {
+	const bytes = new Uint8Array([
+		239,
+		187,
+		191,
+		78,
+		111,
+		255,
+		254
+	]);
+	const url = "https://example.com/error";
+	let error;
+	await rejects(getRemoteDocument(url, new Response(bytes, { status: 404 }), () => Promise.reject(/* @__PURE__ */ new Error("unused"))), (e) => {
+		error = e;
+		return true;
+	});
+	ok(error instanceof FetchError);
+	ok(error.response != null);
+	deepStrictEqual(error.response.status, 404);
+	deepStrictEqual(new Uint8Array(await error.response.arrayBuffer()), bytes);
+});
+test("getRemoteDocument() keeps metadata of bodiless or large errors", async () => {
+	const url = "https://example.com/error";
+	for (const response of [new Response(null, {
+		status: 304,
+		headers: { ETag: "\"a\"" }
+	}), new Response(/* @__PURE__ */ new Uint8Array(1048577), {
+		status: 500,
+		headers: { ETag: "\"a\"" }
+	})]) await rejects(getRemoteDocument(url, response, () => Promise.reject(/* @__PURE__ */ new Error("unused"))), (e) => {
+		ok(e instanceof FetchError);
+		ok(e.response != null);
+		deepStrictEqual(e.response.status, response.status);
+		deepStrictEqual(e.response.headers.get("ETag"), "\"a\"");
+		deepStrictEqual(e.response.body, null);
+		return true;
+	});
+});
+test("getDocumentLoader() reports statuses that Response cannot hold", async () => {
+	await withServer((_, response) => {
+		response.writeHead(999);
+		response.end("Request denied");
+	}, async (baseUrl) => {
+		const url = `${baseUrl}/denied`;
+		const loader = getDocumentLoader({ allowPrivateAddress: true });
+		let error;
+		await rejects(loader(url), (e) => {
+			error = e;
+			return true;
+		});
+		ok(error instanceof FetchError, String(error));
+		deepStrictEqual(error.response?.status, 999);
+		deepStrictEqual(await error.response.text(), "Request denied");
+	});
+});
+test("getDocumentLoader() times out a stalled body of such a status", async () => {
+	await withServer((_, response) => {
+		response.writeHead(999);
+		response.write("Request");
+	}, async (baseUrl) => {
+		const url = `${baseUrl}/stalled-denied`;
+		await rejects(getDocumentLoader({
+			allowPrivateAddress: true,
+			timeout: 200
+		})(url), (e) => isTimeoutFetchError(e, url));
+	});
+});
 //#endregion
 export {};

package/dist/tests/internal/portable-dereference.test.cjs

@@ -1,6 +1,6 @@
 const require_contexts = require("../contexts-DizzBjz4.cjs");
-const require_url = require("../url-gLKqAO1H.cjs");
-const require_jsonld_cache = require("../jsonld-cache-BO-QXxIc.cjs");
+const require_url = require("../url-B8xyTwP-.cjs");
+const require_jsonld_cache = require("../jsonld-cache-BQMn_ILF.cjs");
 let node_assert_strict = require("node:assert/strict");
 let node_test = require("node:test");
 let _logtape_logtape = require("@logtape/logtape");

package/dist/tests/internal/portable-dereference.test.mjs

@@ -1,6 +1,6 @@
 import { t as preloadedContexts } from "../contexts-CIKsin4e.mjs";
-import { a as formatIri, m as parseIri } from "../url-D7qRF-dF.mjs";
-import { n as createScopedContextLoader, o as registerDocumentLoaderWrapper, s as unwrapReleasedDocumentLoader } from "../jsonld-cache-B7PKo3Lu.mjs";
+import { a as formatIri, m as parseIri } from "../url-DfS-cvwr.mjs";
+import { n as createScopedContextLoader, o as registerDocumentLoaderWrapper, s as unwrapReleasedDocumentLoader } from "../jsonld-cache-DUmuWRwp.mjs";
 import { deepStrictEqual, ok, throws } from "node:assert/strict";
 import { test } from "node:test";
 import { getLogger } from "@logtape/logtape";

package/dist/tests/{jsonld-cache-BO-QXxIc.cjs → jsonld-cache-BQMn_ILF.cjs}

@@ -1,5 +1,5 @@
 const require_rolldown_runtime = require("./rolldown-runtime-emK7D4bc.cjs");
-const require_url = require("./url-gLKqAO1H.cjs");
+const require_url = require("./url-B8xyTwP-.cjs");
 let jsonld_dist_jsonld_esm_js = require("jsonld/dist/jsonld.esm.js");
 jsonld_dist_jsonld_esm_js = require_rolldown_runtime.__toESM(jsonld_dist_jsonld_esm_js, 1);
 //#region src/jsonld.ts

package/dist/tests/{jsonld-cache-B7PKo3Lu.mjs → jsonld-cache-DUmuWRwp.mjs}

@@ -1,4 +1,4 @@
-import { a as formatIri, c as haveSameFe34Origin, l as haveSameIriOrigin } from "./url-D7qRF-dF.mjs";
+import { a as formatIri, c as haveSameFe34Origin, l as haveSameIriOrigin } from "./url-DfS-cvwr.mjs";
 import jsonld from "jsonld/dist/jsonld.esm.js";
 //#region src/jsonld.ts
 var jsonld_default = jsonld;

package/dist/tests/jsonld-cache.test.cjs

@@ -1,5 +1,5 @@
-const require_url = require("./url-gLKqAO1H.cjs");
-const require_jsonld_cache = require("./jsonld-cache-BO-QXxIc.cjs");
+const require_url = require("./url-B8xyTwP-.cjs");
+const require_jsonld_cache = require("./jsonld-cache-BQMn_ILF.cjs");
 let node_test = require("node:test");
 let node_assert = require("node:assert");
 //#region src/jsonld-cache.test.ts

package/dist/tests/jsonld-cache.test.mjs

@@ -1,5 +1,5 @@
-import { m as parseIri } from "./url-D7qRF-dF.mjs";
-import { a as normalizeJsonLdIris, c as jsonld_default, i as isTrustedIriOrigin, r as getJsonLdContext, t as compactJsonLdCache } from "./jsonld-cache-B7PKo3Lu.mjs";
+import { m as parseIri } from "./url-DfS-cvwr.mjs";
+import { a as normalizeJsonLdIris, c as jsonld_default, i as isTrustedIriOrigin, r as getJsonLdContext, t as compactJsonLdCache } from "./jsonld-cache-DUmuWRwp.mjs";
 import { test } from "node:test";
 import { deepStrictEqual, ok, strictEqual } from "node:assert";
 //#region src/jsonld-cache.test.ts

package/dist/tests/{request-Dm3ye46t.cjs → request-C5_3S-un.cjs}

@@ -3,7 +3,7 @@ let node_process = require("node:process");
 node_process = require_rolldown_runtime.__toESM(node_process, 1);
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.4.0-dev.2169+0a45df07";
+var version = "2.4.0-dev.2193+402149b5";
 //#endregion
 //#region src/request.ts
 /**

package/dist/tests/{request-Cg8MQByW.mjs → request-IIntZ5kj.mjs}

@@ -1,7 +1,7 @@
 import process from "node:process";
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.4.0-dev.2169+0a45df07";
+var version = "2.4.0-dev.2193+402149b5";
 //#endregion
 //#region src/request.ts
 /**

package/dist/tests/request.test.cjs

@@ -1,5 +1,5 @@
 const require_rolldown_runtime = require("./rolldown-runtime-emK7D4bc.cjs");
-const require_request = require("./request-Dm3ye46t.cjs");
+const require_request = require("./request-C5_3S-un.cjs");
 let node_test = require("node:test");
 let node_process = require("node:process");
 node_process = require_rolldown_runtime.__toESM(node_process, 1);

package/dist/tests/request.test.mjs

@@ -1,4 +1,4 @@
-import { n as createActivityPubRequest, o as version, r as getUserAgent } from "./request-Cg8MQByW.mjs";
+import { n as createActivityPubRequest, o as version, r as getUserAgent } from "./request-IIntZ5kj.mjs";
 import { test } from "node:test";
 import process from "node:process";
 import { deepStrictEqual } from "node:assert";

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

@@ -226,10 +226,14 @@ function isGatewayUrl(url) {
 }
 /**
 * Parses and validates an FEP-ef61 gateway base URI.
+* @throws {TypeError} If the URI is malformed, or is not an HTTP(S) base URI
+*                     with no credentials, path, query, or fragment.  In the
+*                     latter case, the message starts with
+*                     `Invalid FEP-ef61 gateway:`.
 */
 function parseGatewayUrl(url) {
 	const parsed = parseIri(url);
-	if (!isGatewayUrl(parsed)) throw new TypeError("FEP-ef61 gateways must be HTTP(S) base URIs with no credentials, path, query, or fragment.");
+	if (!isGatewayUrl(parsed)) throw new TypeError(`Invalid FEP-ef61 gateway: ${url}.  FEP-ef61 gateways must be HTTP(S) base URIs with no credentials, path, query, or fragment.`);
 	return parsed;
 }
 const COMPATIBLE_ID_PATH_PREFIX = "/.well-known/apgateway/";