@fedify/vocab-runtime 2.2.12 → 2.2.14-dev.2082

package/dist/tests/body-C6xPNNar.mjs

@@ -0,0 +1,77 @@
+import { t as FetchError } from "./request-B6Trcv2U.mjs";
+import { getLogger } from "@logtape/logtape";
+//#region src/body.ts
+/** Decoded JSON body limit: 16 MiB.  @internal */
+const MAX_BODY_SIZE = 16 * 1024 * 1024;
+/** A body exceeded the byte limit.  @internal */
+var BodyTooLargeError = class extends FetchError {
+	/** Creates an error for a body exceeding the given limit. */
+	constructor(url, maxBytes) {
+		super(url, `Body exceeds the limit of ${maxBytes} bytes`);
+		this.name = "BodyTooLargeError";
+	}
+};
+/** Validates a finite, positive byte limit.  @internal */
+function validateBodySizeLimit(maxBytes) {
+	if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0) throw new RangeError("The body size limit must be a positive safe integer.");
+}
+/**
+* Reads UTF-8 text while limiting bytes received from the body stream.
+* Fetch responses are already decompressed, so the stream count is authoritative.
+* @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 decoded body text.
+* @throws {BodyTooLargeError} If the body exceeds the limit.
+* @internal
+*/
+async function readBoundedText(message, maxBytes, url) {
+	validateBodySizeLimit(maxBytes);
+	const reader = message.body?.getReader();
+	const tooLarge = () => {
+		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 "";
+		let size = 0;
+		const textReader = new ReadableStream({ async pull(controller) {
+			const { done, value } = await reader.read();
+			if (done) {
+				controller.close();
+				return;
+			}
+			size += value.byteLength;
+			if (size > maxBytes) tooLarge();
+			controller.enqueue(value);
+		} }, { highWaterMark: 0 }).pipeThrough(new TextDecoderStream()).getReader();
+		try {
+			const chunks = [];
+			while (true) {
+				const { done, value } = await textReader.read();
+				if (done) break;
+				chunks.push(value);
+			}
+			return chunks.join("");
+		} finally {
+			textReader.releaseLock();
+		}
+	} catch (error) {
+		if (reader != null) reader.cancel(error).catch(() => {});
+		throw error;
+	} finally {
+		reader?.releaseLock();
+	}
+}
+//#endregion
+export { MAX_BODY_SIZE as n, readBoundedText as r, BodyTooLargeError as t };

package/dist/tests/body.test.cjs

@@ -0,0 +1,90 @@
+require("./chunk-Do9eywBl.cjs");
+const require_body = require("./body-BM6cz3GR.cjs");
+let node_assert_strict = require("node:assert/strict");
+let node_test = require("node:test");
+let node_zlib = require("node:zlib");
+//#region src/body.test.ts
+const url = "https://example.com/document";
+(0, node_test.test)("readBoundedText handles empty bodies and flushes incomplete UTF-8", async () => {
+	(0, node_assert_strict.deepStrictEqual)(await require_body.readBoundedText(new Response(null), 1, url), "");
+	(0, node_assert_strict.deepStrictEqual)(await require_body.readBoundedText(new Response(""), 1, url), "");
+	(0, node_assert_strict.deepStrictEqual)(await require_body.readBoundedText(new Response(new Uint8Array([226, 130])), 2, url), "�");
+});
+(0, node_test.test)("readBoundedText counts bytes and preserves split UTF-8", async () => {
+	const bytes = new TextEncoder().encode("\"안녕\"");
+	const stream = new ReadableStream({ start(controller) {
+		for (const byte of bytes) controller.enqueue(new Uint8Array([byte]));
+		controller.close();
+	} });
+	(0, node_assert_strict.deepStrictEqual)(await require_body.readBoundedText(new Response(stream), bytes.length, url), "\"안녕\"");
+	await (0, node_assert_strict.rejects)(require_body.readBoundedText(new Response(bytes), bytes.length - 1, url), require_body.BodyTooLargeError);
+});
+(0, node_test.test)("readBoundedText rejects a declared oversized body without pulling", async () => {
+	let pulled = false;
+	let canceled = false;
+	const response = new Response(new ReadableStream({
+		pull() {
+			pulled = true;
+		},
+		cancel() {
+			canceled = true;
+		}
+	}, { highWaterMark: 0 }), { headers: { "Content-Length": "100" } });
+	await (0, node_assert_strict.rejects)(require_body.readBoundedText(response, 10, url), require_body.BodyTooLargeError);
+	(0, node_assert_strict.deepStrictEqual)(pulled, false);
+	(0, node_assert_strict.deepStrictEqual)(canceled, true);
+	(0, node_assert_strict.deepStrictEqual)(response.body?.locked, false);
+});
+(0, node_test.test)("readBoundedText cancels chunked bodies despite absent or false lengths", async () => {
+	for (const length of [
+		void 0,
+		"1",
+		"invalid"
+	]) {
+		let pulls = 0;
+		let canceled = false;
+		const stream = new ReadableStream({
+			pull(controller) {
+				pulls++;
+				controller.enqueue(new Uint8Array(4));
+			},
+			cancel() {
+				canceled = true;
+			}
+		}, { highWaterMark: 0 });
+		const response = new Response(stream, { headers: length == null ? {} : { "Content-Length": length } });
+		await (0, node_assert_strict.rejects)(require_body.readBoundedText(response, 8, url), require_body.BodyTooLargeError);
+		(0, node_assert_strict.deepStrictEqual)(pulls, 3);
+		(0, node_assert_strict.deepStrictEqual)(canceled, true);
+		(0, node_assert_strict.deepStrictEqual)(response.body?.locked, false);
+	}
+});
+(0, node_test.test)("readBoundedText limits decoded gzip bytes, not the compressed length", async () => {
+	const compressed = (0, node_zlib.gzipSync)("\"" + "a".repeat(4096) + "\"");
+	(0, node_assert_strict.ok)(compressed.length < 128);
+	const decoded = (0, node_zlib.gunzipSync)(compressed);
+	await (0, node_assert_strict.rejects)(require_body.readBoundedText(new Response(decoded, { headers: {
+		"Content-Encoding": "gzip",
+		"Content-Length": String(compressed.length)
+	} }), 128, url), require_body.BodyTooLargeError);
+	(0, node_assert_strict.deepStrictEqual)(await require_body.readBoundedText(new Response("{}", { headers: {
+		"Content-Encoding": "gzip",
+		"Content-Length": "22"
+	} }), 2, url), "{}");
+});
+(0, node_test.test)("readBoundedText rejects invalid limits and releases failed streams", async () => {
+	for (const limit of [
+		0,
+		-1,
+		NaN,
+		Infinity,
+		1.5
+	]) await (0, node_assert_strict.rejects)(require_body.readBoundedText(new Response("{}"), limit, url), RangeError);
+	const failure = /* @__PURE__ */ new Error("broken stream");
+	const response = new Response(new ReadableStream({ pull(controller) {
+		controller.error(failure);
+	} }));
+	await (0, node_assert_strict.rejects)(require_body.readBoundedText(response, 10, url), (error) => error === failure);
+	(0, node_assert_strict.deepStrictEqual)(response.body?.locked, false);
+});
+//#endregion

package/dist/tests/body.test.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/tests/body.test.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/tests/body.test.mjs

@@ -0,0 +1,90 @@
+import { r as readBoundedText, t as BodyTooLargeError } from "./body-C6xPNNar.mjs";
+import { deepStrictEqual, ok, rejects } from "node:assert/strict";
+import { test } from "node:test";
+import { gunzipSync, gzipSync } from "node:zlib";
+//#region src/body.test.ts
+const url = "https://example.com/document";
+test("readBoundedText handles empty bodies and flushes incomplete UTF-8", async () => {
+	deepStrictEqual(await readBoundedText(new Response(null), 1, url), "");
+	deepStrictEqual(await readBoundedText(new Response(""), 1, url), "");
+	deepStrictEqual(await readBoundedText(new Response(new Uint8Array([226, 130])), 2, url), "�");
+});
+test("readBoundedText counts bytes and preserves split UTF-8", async () => {
+	const bytes = new TextEncoder().encode("\"안녕\"");
+	const stream = new ReadableStream({ start(controller) {
+		for (const byte of bytes) controller.enqueue(new Uint8Array([byte]));
+		controller.close();
+	} });
+	deepStrictEqual(await readBoundedText(new Response(stream), bytes.length, url), "\"안녕\"");
+	await rejects(readBoundedText(new Response(bytes), bytes.length - 1, url), BodyTooLargeError);
+});
+test("readBoundedText rejects a declared oversized body without pulling", async () => {
+	let pulled = false;
+	let canceled = false;
+	const response = new Response(new ReadableStream({
+		pull() {
+			pulled = true;
+		},
+		cancel() {
+			canceled = true;
+		}
+	}, { highWaterMark: 0 }), { headers: { "Content-Length": "100" } });
+	await rejects(readBoundedText(response, 10, url), BodyTooLargeError);
+	deepStrictEqual(pulled, false);
+	deepStrictEqual(canceled, true);
+	deepStrictEqual(response.body?.locked, false);
+});
+test("readBoundedText cancels chunked bodies despite absent or false lengths", async () => {
+	for (const length of [
+		void 0,
+		"1",
+		"invalid"
+	]) {
+		let pulls = 0;
+		let canceled = false;
+		const stream = new ReadableStream({
+			pull(controller) {
+				pulls++;
+				controller.enqueue(new Uint8Array(4));
+			},
+			cancel() {
+				canceled = true;
+			}
+		}, { highWaterMark: 0 });
+		const response = new Response(stream, { headers: length == null ? {} : { "Content-Length": length } });
+		await rejects(readBoundedText(response, 8, url), BodyTooLargeError);
+		deepStrictEqual(pulls, 3);
+		deepStrictEqual(canceled, true);
+		deepStrictEqual(response.body?.locked, false);
+	}
+});
+test("readBoundedText limits decoded gzip bytes, not the compressed length", async () => {
+	const compressed = gzipSync("\"" + "a".repeat(4096) + "\"");
+	ok(compressed.length < 128);
+	const decoded = gunzipSync(compressed);
+	await rejects(readBoundedText(new Response(decoded, { headers: {
+		"Content-Encoding": "gzip",
+		"Content-Length": String(compressed.length)
+	} }), 128, url), BodyTooLargeError);
+	deepStrictEqual(await readBoundedText(new Response("{}", { headers: {
+		"Content-Encoding": "gzip",
+		"Content-Length": "22"
+	} }), 2, url), "{}");
+});
+test("readBoundedText rejects invalid limits and releases failed streams", async () => {
+	for (const limit of [
+		0,
+		-1,
+		NaN,
+		Infinity,
+		1.5
+	]) await rejects(readBoundedText(new Response("{}"), limit, url), RangeError);
+	const failure = /* @__PURE__ */ new Error("broken stream");
+	const response = new Response(new ReadableStream({ pull(controller) {
+		controller.error(failure);
+	} }));
+	await rejects(readBoundedText(response, 10, url), (error) => error === failure);
+	deepStrictEqual(response.body?.locked, false);
+});
+//#endregion
+export {};

package/dist/tests/decimal.test.cjs

@@ -1,11 +1,11 @@
 require("./chunk-Do9eywBl.cjs");
-require("./docloader-CbmcD65r.cjs");
-require("./url-CWU5HT3Y.cjs");
-require("./key-DTTIntwb.cjs");
-require("./multibase-F7LtMMsK.cjs");
-require("./langstr-CbAxaeEZ.cjs");
-let node_assert = require("node:assert");
+require("./docloader-CFFoEaR4.cjs");
+require("./url-CnyF489g.cjs");
+require("./key-BarKGLQz.cjs");
+require("./multibase-8zhYPa7o.cjs");
+require("./langstr-BOQHfJDr.cjs");
 let node_test = require("node:test");
+let node_assert = require("node:assert");
 //#region src/decimal.ts
 const DECIMAL_PATTERN = /^(\+|-)?([0-9]+(\.[0-9]*)?|\.[0-9]+)$/;
 const XML_SCHEMA_WHITESPACE_PATTERN = /[\t\n\r ]+/g;

package/dist/tests/decimal.test.mjs

@@ -1,10 +1,10 @@
-import "./docloader-BMCm9Ko3.mjs";
-import "./url-o0e-aXQY.mjs";
-import "./key-BeTHFQJK.mjs";
-import "./multibase-BgU9XRf7.mjs";
-import "./langstr-Di5AvKpB.mjs";
-import { deepStrictEqual, throws } from "node:assert";
+import "./docloader-VStEAGHN.mjs";
+import "./url-BBfduh6o.mjs";
+import "./key-BDIsC6hV.mjs";
+import "./multibase-Ds75BvXs.mjs";
+import "./langstr-DDLc4833.mjs";
 import { test } from "node:test";
+import { deepStrictEqual, throws } from "node:assert";
 //#region src/decimal.ts
 const DECIMAL_PATTERN = /^(\+|-)?([0-9]+(\.[0-9]*)?|\.[0-9]+)$/;
 const XML_SCHEMA_WHITESPACE_PATTERN = /[\t\n\r ]+/g;

package/dist/tests/{docloader-CbmcD65r.cjs → docloader-CFFoEaR4.cjs}

@@ -1,7 +1,8 @@
 require("./chunk-Do9eywBl.cjs");
-const require_request = require("./request-CRBzJDJb.cjs");
-const require_link = require("./link-FguCydMA.cjs");
-const require_url = require("./url-CWU5HT3Y.cjs");
+const require_request = require("./request-CsYYOooA.cjs");
+const require_body = require("./body-BM6cz3GR.cjs");
+const require_link = require("./link-qDTmjPw_.cjs");
+const require_url = require("./url-CnyF489g.cjs");
 let _logtape_logtape = require("@logtape/logtape");
 let _opentelemetry_api = require("@opentelemetry/api");
 //#region src/contexts/activitystreams.json
@@ -4572,38 +4573,29 @@ async function getRemoteDocument(url, response, fetch) {
 	}
 	let document;
 	if (!jsonLd && (contentType === "text/html" || contentType?.startsWith("text/html;") || contentType === "application/xhtml+xml" || contentType?.startsWith("application/xhtml+xml;"))) {
-		const MAX_HTML_SIZE = 1024 * 1024;
-		const html = await response.text();
-		if (html.length > MAX_HTML_SIZE) {
-			logger.warn("HTML response too large, skipping alternate link discovery: {url}", {
-				url: documentUrl,
-				size: html.length
-			});
-			document = JSON.parse(html);
-		} else {
-			const tagPattern = /<(a|link)\s+([^>]*?)\s*\/?>/gi;
-			const attrPattern = /([a-z][a-z:_-]*)=(?:"([^"]*)"|'([^']*)'|([^\s>]+))/gi;
-			let tagMatch;
-			while ((tagMatch = tagPattern.exec(html)) !== null) {
-				const tagContent = tagMatch[2];
-				let attrMatch;
-				const attribs = {};
-				attrPattern.lastIndex = 0;
-				while ((attrMatch = attrPattern.exec(tagContent)) !== null) {
-					const key = attrMatch[1].toLowerCase();
-					attribs[key] = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4] ?? "";
-				}
-				if (attribs.rel === "alternate" && "type" in attribs && (attribs.type === "application/activity+json" || attribs.type === "application/ld+json" || attribs.type.startsWith("application/ld+json;")) && "href" in attribs && new URL(attribs.href, docUrl).href !== docUrl.href) {
-					logger.debug("Found alternate document: {alternateUrl} from {url}", {
-						alternateUrl: attribs.href,
-						url: documentUrl
-					});
-					return await fetch(new URL(attribs.href, docUrl).href);
-				}
+		const html = await require_body.readBoundedText(response, 1024 * 1024, documentUrl);
+		const tagPattern = /<(a|link)\s+([^>]*?)\s*\/?>/gi;
+		const attrPattern = /([a-z][a-z:_-]*)=(?:"([^"]*)"|'([^']*)'|([^\s>]+))/gi;
+		let tagMatch;
+		while ((tagMatch = tagPattern.exec(html)) !== null) {
+			const tagContent = tagMatch[2];
+			let attrMatch;
+			const attribs = {};
+			attrPattern.lastIndex = 0;
+			while ((attrMatch = attrPattern.exec(tagContent)) !== null) {
+				const key = attrMatch[1].toLowerCase();
+				attribs[key] = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4] ?? "";
+			}
+			if (attribs.rel === "alternate" && "type" in attribs && (attribs.type === "application/activity+json" || attribs.type === "application/ld+json" || attribs.type.startsWith("application/ld+json;")) && "href" in attribs && new URL(attribs.href, docUrl).href !== docUrl.href) {
+				logger.debug("Found alternate document: {alternateUrl} from {url}", {
+					alternateUrl: attribs.href,
+					url: documentUrl
+				});
+				return await fetch(new URL(attribs.href, docUrl).href);
 			}
-			document = JSON.parse(html);
 		}
-	} else document = await response.json();
+		document = JSON.parse(html);
+	} else document = JSON.parse(await require_body.readBoundedText(response, require_body.MAX_BODY_SIZE, documentUrl));
 	logger.debug("Fetched document: {status} {url} {headers}", {
 		status: response.status,
 		url: documentUrl,
@@ -4720,6 +4712,12 @@ Object.defineProperty(exports, "getDocumentLoader", {
 		return getDocumentLoader;
 	}
 });
+Object.defineProperty(exports, "getRemoteDocument", {
+	enumerable: true,
+	get: function() {
+		return getRemoteDocument;
+	}
+});
 Object.defineProperty(exports, "preloadedContexts", {
 	enumerable: true,
 	get: function() {

package/dist/tests/{docloader-BMCm9Ko3.mjs → docloader-VStEAGHN.mjs}

@@ -1,6 +1,7 @@
-import { a as name, i as logRequest, n as createActivityPubRequest, o as version, t as FetchError } from "./request-DYbgYXfe.mjs";
-import { t as HttpHeaderLink } from "./link-NUUWCdnK.mjs";
-import { o as validatePublicUrl, t as UrlError } from "./url-o0e-aXQY.mjs";
+import { a as name, i as logRequest, n as createActivityPubRequest, o as version, t as FetchError } from "./request-B6Trcv2U.mjs";
+import { n as MAX_BODY_SIZE, r as readBoundedText } from "./body-C6xPNNar.mjs";
+import { t as HttpHeaderLink } from "./link-CYszIegt.mjs";
+import { o as validatePublicUrl, t as UrlError } from "./url-BBfduh6o.mjs";
 import { getLogger } from "@logtape/logtape";
 import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 //#region src/contexts/activitystreams.json
@@ -4571,38 +4572,29 @@ async function getRemoteDocument(url, response, fetch) {
 	}
 	let document;
 	if (!jsonLd && (contentType === "text/html" || contentType?.startsWith("text/html;") || contentType === "application/xhtml+xml" || contentType?.startsWith("application/xhtml+xml;"))) {
-		const MAX_HTML_SIZE = 1024 * 1024;
-		const html = await response.text();
-		if (html.length > MAX_HTML_SIZE) {
-			logger.warn("HTML response too large, skipping alternate link discovery: {url}", {
-				url: documentUrl,
-				size: html.length
-			});
-			document = JSON.parse(html);
-		} else {
-			const tagPattern = /<(a|link)\s+([^>]*?)\s*\/?>/gi;
-			const attrPattern = /([a-z][a-z:_-]*)=(?:"([^"]*)"|'([^']*)'|([^\s>]+))/gi;
-			let tagMatch;
-			while ((tagMatch = tagPattern.exec(html)) !== null) {
-				const tagContent = tagMatch[2];
-				let attrMatch;
-				const attribs = {};
-				attrPattern.lastIndex = 0;
-				while ((attrMatch = attrPattern.exec(tagContent)) !== null) {
-					const key = attrMatch[1].toLowerCase();
-					attribs[key] = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4] ?? "";
-				}
-				if (attribs.rel === "alternate" && "type" in attribs && (attribs.type === "application/activity+json" || attribs.type === "application/ld+json" || attribs.type.startsWith("application/ld+json;")) && "href" in attribs && new URL(attribs.href, docUrl).href !== docUrl.href) {
-					logger.debug("Found alternate document: {alternateUrl} from {url}", {
-						alternateUrl: attribs.href,
-						url: documentUrl
-					});
-					return await fetch(new URL(attribs.href, docUrl).href);
-				}
+		const html = await readBoundedText(response, 1024 * 1024, documentUrl);
+		const tagPattern = /<(a|link)\s+([^>]*?)\s*\/?>/gi;
+		const attrPattern = /([a-z][a-z:_-]*)=(?:"([^"]*)"|'([^']*)'|([^\s>]+))/gi;
+		let tagMatch;
+		while ((tagMatch = tagPattern.exec(html)) !== null) {
+			const tagContent = tagMatch[2];
+			let attrMatch;
+			const attribs = {};
+			attrPattern.lastIndex = 0;
+			while ((attrMatch = attrPattern.exec(tagContent)) !== null) {
+				const key = attrMatch[1].toLowerCase();
+				attribs[key] = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4] ?? "";
+			}
+			if (attribs.rel === "alternate" && "type" in attribs && (attribs.type === "application/activity+json" || attribs.type === "application/ld+json" || attribs.type.startsWith("application/ld+json;")) && "href" in attribs && new URL(attribs.href, docUrl).href !== docUrl.href) {
+				logger.debug("Found alternate document: {alternateUrl} from {url}", {
+					alternateUrl: attribs.href,
+					url: documentUrl
+				});
+				return await fetch(new URL(attribs.href, docUrl).href);
 			}
-			document = JSON.parse(html);
 		}
-	} else document = await response.json();
+		document = JSON.parse(html);
+	} else document = JSON.parse(await readBoundedText(response, MAX_BODY_SIZE, documentUrl));
 	logger.debug("Fetched document: {status} {url} {headers}", {
 		status: response.status,
 		url: documentUrl,
@@ -4707,4 +4699,4 @@ function getDocumentLoader({ allowPrivateAddress, maxRedirection, skipPreloadedC
 	return load;
 }
 //#endregion
-export { preloadedContexts as n, cid_v1_default as r, getDocumentLoader as t };
+export { cid_v1_default as i, getRemoteDocument as n, preloadedContexts as r, getDocumentLoader as t };

package/dist/tests/docloader.test.cjs

@@ -1,9 +1,11 @@
 const require_chunk = require("./chunk-Do9eywBl.cjs");
-const require_docloader = require("./docloader-CbmcD65r.cjs");
-const require_request = require("./request-CRBzJDJb.cjs");
-const require_url = require("./url-CWU5HT3Y.cjs");
-let node_assert = require("node:assert");
+const require_request = require("./request-CsYYOooA.cjs");
+const require_docloader = require("./docloader-CFFoEaR4.cjs");
+const require_url = require("./url-CnyF489g.cjs");
 let node_test = require("node:test");
+let node_zlib = require("node:zlib");
+let node_assert = require("node:assert");
+let node_http = require("node:http");
 //#region ../../node_modules/.pnpm/glob-to-regexp@0.4.1/node_modules/glob-to-regexp/index.js
 var require_glob_to_regexp = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module) => {
 	module.exports = function(glob, opts) {
@@ -1567,4 +1569,81 @@ var esm_default = new class FetchMock {
 	});
 	esm_default.hardReset();
 });
+(0, node_test.test)("getDocumentLoader() bounds JSON, HTML, and alternate documents", async () => {
+	const url = "https://example.com/bounded";
+	esm_default.mockGlobal();
+	let oversized = true;
+	try {
+		esm_default.get(url, () => new Response("{\"name\":\"hello\"}", { headers: {
+			"Content-Type": "application/activity+json",
+			...oversized ? { "Content-Length": String(16777217) } : {}
+		} }));
+		const loader = require_docloader.getDocumentLoader({ allowPrivateAddress: true });
+		await (0, node_assert.rejects)(loader(url), require_request.FetchError);
+		oversized = false;
+		(0, node_assert.deepStrictEqual)((await loader(url)).document, { name: "hello" });
+		oversized = true;
+		esm_default.get(`${url}/html`, () => new Response(" ".repeat(1048577), { headers: { "Content-Type": "text/html" } }));
+		await (0, node_assert.rejects)(require_docloader.getDocumentLoader({ allowPrivateAddress: true })(`${url}/html`), require_request.FetchError);
+		esm_default.get(`${url}/alternate`, () => new Response("", { headers: {
+			"Content-Type": "text/html",
+			Link: `<${url}>; rel="alternate"; type="application/activity+json"`
+		} }));
+		await (0, node_assert.rejects)(loader(`${url}/alternate`), require_request.FetchError);
+		esm_default.get(`${url}/redirect`, {
+			status: 302,
+			headers: { Location: url }
+		});
+		await (0, node_assert.rejects)(loader(`${url}/redirect`), require_request.FetchError);
+	} finally {
+		esm_default.hardReset();
+	}
+});
+(0, node_test.test)("getDocumentLoader() rejects oversized gzip responses from fetch", async () => {
+	const document = { name: "a".repeat(16 * 1024 * 1024) };
+	const compressed = (0, node_zlib.gzipSync)(JSON.stringify(document));
+	(0, node_assert.ok)(compressed.byteLength < 64 * 1024);
+	const server = (0, node_http.createServer)((request, response) => {
+		const body = request.url === "/small" ? (0, node_zlib.gzipSync)("{\"name\":\"hello\"}") : compressed;
+		response.writeHead(200, {
+			"Content-Type": "application/activity+json",
+			"Content-Encoding": "gzip",
+			"Content-Length": body.byteLength
+		});
+		response.end(body);
+	});
+	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");
+		const url = `http://127.0.0.1:${address.port}/document`;
+		await (0, node_assert.rejects)(require_docloader.getDocumentLoader({ allowPrivateAddress: true })(url), require_request.FetchError);
+		(0, node_assert.deepStrictEqual)((await require_docloader.getDocumentLoader({ allowPrivateAddress: true })(new URL("/small", url).href)).document, { name: "hello" });
+	} finally {
+		await new Promise((resolve, reject) => {
+			server.close((error) => error == null ? resolve() : reject(error));
+			server.closeAllConnections();
+		});
+	}
+});
+(0, node_test.test)("getRemoteDocument() bounds JSON by default", async () => {
+	let canceled = false;
+	let pulls = 0;
+	await (0, node_assert.rejects)(require_docloader.getRemoteDocument("https://example.com/document", new Response(new ReadableStream({
+		pull(controller) {
+			pulls++;
+			controller.enqueue(new Uint8Array(64 * 1024).fill(32));
+		},
+		cancel() {
+			canceled = true;
+		}
+	}, { highWaterMark: 0 })), () => {
+		throw new Error("Unexpected alternate document");
+	}), require_request.FetchError);
+	(0, node_assert.deepStrictEqual)(canceled, true);
+	(0, node_assert.deepStrictEqual)(pulls, 257);
+});
 //#endregion

package/dist/tests/docloader.test.mjs

@@ -1,8 +1,10 @@
-import { n as preloadedContexts, r as cid_v1_default, t as getDocumentLoader } from "./docloader-BMCm9Ko3.mjs";
-import { t as FetchError } from "./request-DYbgYXfe.mjs";
-import { t as UrlError } from "./url-o0e-aXQY.mjs";
-import { deepStrictEqual, ok, rejects } from "node:assert";
+import { t as FetchError } from "./request-B6Trcv2U.mjs";
+import { i as cid_v1_default, n as getRemoteDocument, r as preloadedContexts, t as getDocumentLoader } from "./docloader-VStEAGHN.mjs";
+import { t as UrlError } from "./url-BBfduh6o.mjs";
 import { test } from "node:test";
+import { gzipSync } from "node:zlib";
+import { deepStrictEqual, ok, rejects } from "node:assert";
+import { createServer } from "node:http";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -1586,5 +1588,82 @@ test("getDocumentLoader()", async (t) => {
 	});
 	esm_default.hardReset();
 });
+test("getDocumentLoader() bounds JSON, HTML, and alternate documents", async () => {
+	const url = "https://example.com/bounded";
+	esm_default.mockGlobal();
+	let oversized = true;
+	try {
+		esm_default.get(url, () => new Response("{\"name\":\"hello\"}", { headers: {
+			"Content-Type": "application/activity+json",
+			...oversized ? { "Content-Length": String(16777217) } : {}
+		} }));
+		const loader = getDocumentLoader({ allowPrivateAddress: true });
+		await rejects(loader(url), FetchError);
+		oversized = false;
+		deepStrictEqual((await loader(url)).document, { name: "hello" });
+		oversized = true;
+		esm_default.get(`${url}/html`, () => new Response(" ".repeat(1048577), { headers: { "Content-Type": "text/html" } }));
+		await rejects(getDocumentLoader({ allowPrivateAddress: true })(`${url}/html`), FetchError);
+		esm_default.get(`${url}/alternate`, () => new Response("", { headers: {
+			"Content-Type": "text/html",
+			Link: `<${url}>; rel="alternate"; type="application/activity+json"`
+		} }));
+		await rejects(loader(`${url}/alternate`), FetchError);
+		esm_default.get(`${url}/redirect`, {
+			status: 302,
+			headers: { Location: url }
+		});
+		await rejects(loader(`${url}/redirect`), FetchError);
+	} finally {
+		esm_default.hardReset();
+	}
+});
+test("getDocumentLoader() rejects oversized gzip responses from fetch", async () => {
+	const document = { name: "a".repeat(16 * 1024 * 1024) };
+	const compressed = gzipSync(JSON.stringify(document));
+	ok(compressed.byteLength < 64 * 1024);
+	const server = createServer((request, response) => {
+		const body = request.url === "/small" ? gzipSync("{\"name\":\"hello\"}") : compressed;
+		response.writeHead(200, {
+			"Content-Type": "application/activity+json",
+			"Content-Encoding": "gzip",
+			"Content-Length": body.byteLength
+		});
+		response.end(body);
+	});
+	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");
+		const url = `http://127.0.0.1:${address.port}/document`;
+		await rejects(getDocumentLoader({ allowPrivateAddress: true })(url), FetchError);
+		deepStrictEqual((await getDocumentLoader({ allowPrivateAddress: true })(new URL("/small", url).href)).document, { name: "hello" });
+	} finally {
+		await new Promise((resolve, reject) => {
+			server.close((error) => error == null ? resolve() : reject(error));
+			server.closeAllConnections();
+		});
+	}
+});
+test("getRemoteDocument() bounds JSON by default", async () => {
+	let canceled = false;
+	let pulls = 0;
+	await rejects(getRemoteDocument("https://example.com/document", new Response(new ReadableStream({
+		pull(controller) {
+			pulls++;
+			controller.enqueue(new Uint8Array(64 * 1024).fill(32));
+		},
+		cancel() {
+			canceled = true;
+		}
+	}, { highWaterMark: 0 })), () => {
+		throw new Error("Unexpected alternate document");
+	}), FetchError);
+	deepStrictEqual(canceled, true);
+	deepStrictEqual(pulls, 257);
+});
 //#endregion
 export {};