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

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-BU0mCgOL.cjs");
 const require_contexts = require("./contexts-DizzBjz4.cjs");
 const require_url = require("./url-gLKqAO1H.cjs");
-const require_docloader = require("./docloader-DLkb9qAS.cjs");
+const require_docloader = require("./docloader-B0omnjRS.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-CGmX5n4v.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 { i as withDocumentLoaderTimeout, n as getRemoteDocument, r as resolveDocumentLoaderTimeout, t as getDocumentLoader } from "./docloader-6iodlx7G.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/{request-Dm3ye46t.cjs → request-BU0mCgOL.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.2190+be3a8be0";
 //#endregion
 //#region src/request.ts
 /**

package/dist/tests/{request-Cg8MQByW.mjs → request-CGmX5n4v.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.2190+be3a8be0";
 //#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-BU0mCgOL.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-CGmX5n4v.mjs";
 import { test } from "node:test";
 import process from "node:process";
 import { deepStrictEqual } from "node:assert";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/vocab-runtime",
-  "version": "2.4.0-dev.2169+0a45df07",
+  "version": "2.4.0-dev.2190+be3a8be0",
   "homepage": "https://fedify.dev/",
   "repository": {
     "type": "git",

package/src/body.ts

@@ -93,3 +93,60 @@ export async function readBoundedText(
     reader?.releaseLock();
   }
 }
+
+/**
+ * Reads raw bytes while limiting bytes received from the body stream.
+ * Unlike {@link readBoundedText}, the bytes are returned as they were
+ * received, without decoding.
+ * @param message The response or request to read.
+ * @param maxBytes The maximum number of decoded bytes to read.
+ * @param url The URL to include in errors and logs.
+ * @returns The body bytes.
+ * @throws {BodyTooLargeError} If the body exceeds the limit.
+ * @internal
+ */
+export async function readBoundedBytes(
+  message: Pick<Request, "body" | "headers">,
+  maxBytes: number,
+  url: string | URL,
+): Promise<Uint8Array<ArrayBuffer>> {
+  validateBodySizeLimit(maxBytes);
+  const reader = message.body?.getReader();
+  const tooLarge = (): never => {
+    getLogger(["fedify", "runtime", "body"]).warn(
+      "Body from {url} exceeds the limit of {maxBytes} bytes.",
+      { url: url.toString(), maxBytes },
+    );
+    throw new BodyTooLargeError(url, maxBytes);
+  };
+  try {
+    const length = message.headers.get("Content-Length");
+    const encoding = message.headers.get("Content-Encoding");
+    if (
+      (encoding == null || encoding.toLowerCase() === "identity") &&
+      length != null && /^\d+$/.test(length) && Number(length) > maxBytes
+    ) tooLarge();
+    if (reader == null) return new Uint8Array(0);
+    const chunks: Uint8Array[] = [];
+    let size = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.byteLength;
+      if (size > maxBytes) tooLarge();
+      chunks.push(value);
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return bytes;
+  } catch (error) {
+    if (reader != null) void reader.cancel(error).catch(() => {});
+    throw error;
+  } finally {
+    reader?.releaseLock();
+  }
+}