@fedify/vocab-runtime 2.4.5-dev.2462 → 2.4.6-dev.2628

package/dist/tests/{request-CgTgsBUA.cjs → request-BDe7VfMX.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.5-dev.2462+46a3f2c5";
+var version = "2.4.6-dev.2628+2a78382f";
 //#endregion
 //#region src/request.ts
 /**

package/dist/tests/{request-C336eT6A.mjs → request-Bj4ZeRfh.mjs}

@@ -1,7 +1,7 @@
 import process from "node:process";
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.4.5-dev.2462+46a3f2c5";
+var version = "2.4.6-dev.2628+2a78382f";
 //#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-CgTgsBUA.cjs");
+const require_request = require("./request-BDe7VfMX.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-C336eT6A.mjs";
+import { n as createActivityPubRequest, o as version, r as getUserAgent } from "./request-Bj4ZeRfh.mjs";
 import { test } from "node:test";
 import process from "node:process";
 import { deepStrictEqual } from "node:assert";

package/dist/tests/support-BmzI3dRJ.cjs

@@ -0,0 +1,363 @@
+const require_rolldown_runtime = require("./rolldown-runtime-emK7D4bc.cjs");
+const require_url = require("./url-Bdj-rTcC.cjs");
+const require_pinners = require("./pinners-CJi9ZkYs.cjs");
+let node_process = require("node:process");
+node_process = require_rolldown_runtime.__toESM(node_process, 1);
+let node_net = require("node:net");
+let node_http = require("node:http");
+let node_fs = require("node:fs");
+let node_child_process = require("node:child_process");
+let node_path = require("node:path");
+let node_url = require("node:url");
+//#region src/pinners/testdata/support.ts
+/**
+* Helpers shared by the pinner tests in *../\*.test.ts*.  They start local
+* servers and proxies, and run child processes.
+* @module
+*/
+const isBun = require_pinners.detectRuntime() === "bun";
+const isNode = require_pinners.detectRuntime() === "node";
+/** Pinner options that allow connecting to any address, e.g., loopback. */
+const allowAll = { verifyAddress() {} };
+const ipv4 = (address) => ({
+	address,
+	family: 4
+});
+const ipv6 = (address) => ({
+	address,
+	family: 6
+});
+/**
+* Whether the error is the rejection of an address by `verifyAddress`.
+* The Bun pinner throws the `UrlError` itself, and the Node.js pinner
+* rejects with the `TypeError` of `fetch()`, caused by the `UrlError` that
+* its lookup failed with.
+*/
+function isAddressRejection(error) {
+	return error instanceof require_url.UrlError || error instanceof TypeError && error.cause instanceof require_url.UrlError;
+}
+function readBody(req) {
+	return new Promise((resolve, reject) => {
+		let body = "";
+		req.setEncoding("utf8");
+		req.on("data", (chunk) => body += chunk);
+		req.on("end", () => resolve(body));
+		req.on("error", reject);
+	});
+}
+async function listen(server, host = "127.0.0.1") {
+	await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(0, host, () => {
+			server.off("error", reject);
+			resolve();
+		});
+	});
+	return server.address().port;
+}
+async function closeServer(server) {
+	server.closeAllConnections?.();
+	await new Promise((resolve) => server.close(() => resolve()));
+}
+function canConnect(host, port) {
+	return new Promise((resolve) => {
+		const socket = (0, node_net.connect)({
+			host,
+			port
+		});
+		const done = (result) => {
+			socket.destroy();
+			resolve(result);
+		};
+		socket.setTimeout(2e3, () => done(false));
+		socket.once("connect", () => done(true));
+		socket.once("error", () => done(false));
+	});
+}
+let loopbackSupport;
+/**
+* Checks which loopback addresses the tests can use.  Only 127.0.0.1 is
+* assumed: other addresses of 127.0.0.0/8 are not configured on macOS, and
+* IPv6 can be disabled.
+*/
+function getLoopbackSupport() {
+	loopbackSupport ??= (async () => {
+		const server = (0, node_net.createServer)((socket) => socket.destroy());
+		let port;
+		try {
+			port = await listen(server, "::");
+		} catch {
+			return {
+				ipv6: false,
+				dualStack: false
+			};
+		}
+		try {
+			const [v4, v6] = await Promise.all([canConnect("127.0.0.1", port), canConnect("::1", port)]);
+			return {
+				ipv6: v6,
+				dualStack: v4 && v6
+			};
+		} finally {
+			await closeServer(server);
+		}
+	})();
+	return loopbackSupport;
+}
+/**
+* Starts an HTTP server that records the requests it receives.
+*/
+async function startRecordingServer(host = "127.0.0.1", respond = (_, res) => res.end("pinned")) {
+	const requests = [];
+	const server = (0, node_http.createServer)(async (req, res) => {
+		const body = await readBody(req);
+		requests.push({
+			method: req.method ?? "",
+			url: req.url ?? "",
+			host: req.headers.host,
+			localAddress: req.socket.localAddress,
+			body
+		});
+		respond(req, res);
+	});
+	return {
+		server,
+		port: await listen(server, host),
+		requests
+	};
+}
+/**
+* Starts a TCP server that only counts the connections it accepts, and drops
+* them right away.  It stands for an HTTPS server without a certificate.
+*/
+async function startCountingServer() {
+	const counter = { connections: 0 };
+	const server = (0, node_net.createServer)((socket) => {
+		counter.connections++;
+		socket.destroy();
+	});
+	return {
+		server,
+		port: await listen(server),
+		counter
+	};
+}
+/**
+* Starts a proxy that records the request targets it is asked for, and never
+* forwards them.  It answers a request in absolute form with `via-proxy`,
+* and drops tunnels (`CONNECT`).  It parses requests by itself since
+* the `connect` event of `node:http` servers is not available on older Bun
+* versions.
+* @param options.refuseTunnels Whether to refuse tunnels with a `403`
+*                              response instead of dropping them.  Some
+*                              clients retry dropped tunnels without end
+*                              (e.g., the `EnvHttpProxyAgent` of Node.js),
+*                              and some take the response of a refused
+*                              tunnel for the response of the request
+*                              (e.g., Bun 1.3.14).
+*/
+async function startRecordingProxy({ refuseTunnels = false } = {}) {
+	const targets = [];
+	const server = (0, node_net.createServer)((socket) => {
+		let head = "";
+		socket.setEncoding("latin1");
+		socket.on("error", () => {});
+		socket.on("data", (chunk) => {
+			if (head.includes("\r\n\r\n")) return;
+			head += chunk;
+			if (!head.includes("\r\n\r\n")) return;
+			const [method, target] = head.slice(0, head.indexOf("\r\n")).split(" ");
+			targets.push(`${method} ${target}`);
+			if (method !== "CONNECT") socket.end("HTTP/1.1 200 OK\r\nContent-Length: 9\r\nConnection: close\r\n\r\nvia-proxy");
+			else if (refuseTunnels) socket.end("HTTP/1.1 403 Forbidden\r\nContent-Length: 0\r\nConnection: close\r\n\r\n");
+			else socket.destroy();
+		});
+	});
+	return {
+		server,
+		port: await listen(server),
+		targets
+	};
+}
+/**
+* Returns the first of the given paths that exists.
+*/
+function findFile(name, candidates) {
+	const found = candidates.find((path) => (0, node_fs.existsSync)(path));
+	if (found == null) throw new Error(`Cannot find ${name} in ${candidates.join(", ")}`);
+	return found;
+}
+function getModuleDirectory(moduleUrl) {
+	return typeof moduleUrl === "string" && moduleUrl.startsWith("file:") ? (0, node_path.dirname)((0, node_url.fileURLToPath)(moduleUrl)) : null;
+}
+const TESTDATA = [
+	"src",
+	"pinners",
+	"testdata"
+];
+/**
+* Finds a source file in *testdata/* (e.g., a child script that Bun runs
+* directly).  When a test runs from the compiled *dist/tests/pinners/*
+* instead of *src/pinners/*, the test data is not compiled with it, so this
+* falls back to the files in the package: first relative to the test module,
+* then relative to the working directory (the package root, where the Bun
+* test script runs), in case `import.meta.url` is unavailable in a CommonJS
+* build.
+* @param name The file name.
+* @param moduleUrl The `import.meta.url` of the test module.
+*/
+function resolveTestdata(name, moduleUrl) {
+	const candidates = [];
+	const here = getModuleDirectory(moduleUrl);
+	if (here != null) candidates.push((0, node_path.join)(here, TESTDATA[2], name), (0, node_path.join)(here, "..", "..", "..", ...TESTDATA, name));
+	candidates.push((0, node_path.join)(node_process.default.cwd(), ...TESTDATA, name));
+	return findFile(name, candidates);
+}
+/**
+* Finds a child script of *testdata/* compiled into
+* *dist/tests/pinners/testdata/* by *tsdown.config.ts*, for Node.js, which
+* cannot run TypeScript sources without flags before 22.6.0.  Node.js tests
+* run only from *dist/tests/* (`cd dist/tests && node --test`), so this looks
+* relative to the test module, then relative to the working directory, in
+* case `import.meta.url` is unavailable in a CommonJS build.
+* @param name The compiled file name, e.g., `node-child.mjs`.
+* @param moduleUrl The `import.meta.url` of the test module.
+*/
+function resolveCompiledTestdata(name, moduleUrl) {
+	const candidates = [];
+	const here = getModuleDirectory(moduleUrl);
+	if (here != null) candidates.push((0, node_path.join)(here, TESTDATA[2], name));
+	candidates.push((0, node_path.join)(node_process.default.cwd(), ...TESTDATA.slice(1), name), (0, node_path.join)(node_process.default.cwd(), "dist", "tests", ...TESTDATA.slice(1), name));
+	return findFile(name, candidates);
+}
+const PROXY_ENV_NAMES = [
+	"HTTP_PROXY",
+	"HTTPS_PROXY",
+	"ALL_PROXY",
+	"NO_PROXY"
+];
+/**
+* Runs a child script in a new process of the current runtime, without proxy
+* environment variables (and `NODE_USE_ENV_PROXY`) but with the given ones,
+* and parses the last line of its output as JSON.
+* @param script The path of the script.
+* @param args The arguments to the script.
+* @param extraEnv The environment variables to set.
+*/
+function runChild(script, args, extraEnv) {
+	const env = { ...node_process.default.env };
+	for (const name of PROXY_ENV_NAMES) {
+		delete env[name];
+		delete env[name.toLowerCase()];
+	}
+	delete env.NODE_USE_ENV_PROXY;
+	Object.assign(env, extraEnv);
+	return new Promise((resolve, reject) => {
+		(0, node_child_process.execFile)(node_process.default.execPath, [script, ...args], {
+			env,
+			timeout: 3e4
+		}, (error, stdout, stderr) => {
+			if (error != null) {
+				reject(new Error(`${script} failed: ${stderr}`, { cause: error }));
+				return;
+			}
+			const line = stdout.trim().split("\n").at(-1) ?? "";
+			try {
+				resolve(JSON.parse(line));
+			} catch (cause) {
+				reject(new Error(`Unexpected output: ${stdout}${stderr}`, { cause }));
+			}
+		});
+	});
+}
+//#endregion
+Object.defineProperty(exports, "allowAll", {
+	enumerable: true,
+	get: function() {
+		return allowAll;
+	}
+});
+Object.defineProperty(exports, "closeServer", {
+	enumerable: true,
+	get: function() {
+		return closeServer;
+	}
+});
+Object.defineProperty(exports, "getLoopbackSupport", {
+	enumerable: true,
+	get: function() {
+		return getLoopbackSupport;
+	}
+});
+Object.defineProperty(exports, "ipv4", {
+	enumerable: true,
+	get: function() {
+		return ipv4;
+	}
+});
+Object.defineProperty(exports, "ipv6", {
+	enumerable: true,
+	get: function() {
+		return ipv6;
+	}
+});
+Object.defineProperty(exports, "isAddressRejection", {
+	enumerable: true,
+	get: function() {
+		return isAddressRejection;
+	}
+});
+Object.defineProperty(exports, "isBun", {
+	enumerable: true,
+	get: function() {
+		return isBun;
+	}
+});
+Object.defineProperty(exports, "isNode", {
+	enumerable: true,
+	get: function() {
+		return isNode;
+	}
+});
+Object.defineProperty(exports, "listen", {
+	enumerable: true,
+	get: function() {
+		return listen;
+	}
+});
+Object.defineProperty(exports, "resolveCompiledTestdata", {
+	enumerable: true,
+	get: function() {
+		return resolveCompiledTestdata;
+	}
+});
+Object.defineProperty(exports, "resolveTestdata", {
+	enumerable: true,
+	get: function() {
+		return resolveTestdata;
+	}
+});
+Object.defineProperty(exports, "runChild", {
+	enumerable: true,
+	get: function() {
+		return runChild;
+	}
+});
+Object.defineProperty(exports, "startCountingServer", {
+	enumerable: true,
+	get: function() {
+		return startCountingServer;
+	}
+});
+Object.defineProperty(exports, "startRecordingProxy", {
+	enumerable: true,
+	get: function() {
+		return startRecordingProxy;
+	}
+});
+Object.defineProperty(exports, "startRecordingServer", {
+	enumerable: true,
+	get: function() {
+		return startRecordingServer;
+	}
+});

package/dist/tests/support-CiHDVJgh.mjs

@@ -0,0 +1,272 @@
+import { n as UrlError } from "./url-COj5Q8mb.mjs";
+import { t as detectRuntime } from "./pinners-zSofbiy2.mjs";
+import process from "node:process";
+import { connect, createServer } from "node:net";
+import { createServer as createServer$1 } from "node:http";
+import { existsSync } from "node:fs";
+import { execFile } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/pinners/testdata/support.ts
+/**
+* Helpers shared by the pinner tests in *../\*.test.ts*.  They start local
+* servers and proxies, and run child processes.
+* @module
+*/
+const isBun = detectRuntime() === "bun";
+const isNode = detectRuntime() === "node";
+/** Pinner options that allow connecting to any address, e.g., loopback. */
+const allowAll = { verifyAddress() {} };
+const ipv4 = (address) => ({
+	address,
+	family: 4
+});
+const ipv6 = (address) => ({
+	address,
+	family: 6
+});
+/**
+* Whether the error is the rejection of an address by `verifyAddress`.
+* The Bun pinner throws the `UrlError` itself, and the Node.js pinner
+* rejects with the `TypeError` of `fetch()`, caused by the `UrlError` that
+* its lookup failed with.
+*/
+function isAddressRejection(error) {
+	return error instanceof UrlError || error instanceof TypeError && error.cause instanceof UrlError;
+}
+function readBody(req) {
+	return new Promise((resolve, reject) => {
+		let body = "";
+		req.setEncoding("utf8");
+		req.on("data", (chunk) => body += chunk);
+		req.on("end", () => resolve(body));
+		req.on("error", reject);
+	});
+}
+async function listen(server, host = "127.0.0.1") {
+	await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(0, host, () => {
+			server.off("error", reject);
+			resolve();
+		});
+	});
+	return server.address().port;
+}
+async function closeServer(server) {
+	server.closeAllConnections?.();
+	await new Promise((resolve) => server.close(() => resolve()));
+}
+function canConnect(host, port) {
+	return new Promise((resolve) => {
+		const socket = connect({
+			host,
+			port
+		});
+		const done = (result) => {
+			socket.destroy();
+			resolve(result);
+		};
+		socket.setTimeout(2e3, () => done(false));
+		socket.once("connect", () => done(true));
+		socket.once("error", () => done(false));
+	});
+}
+let loopbackSupport;
+/**
+* Checks which loopback addresses the tests can use.  Only 127.0.0.1 is
+* assumed: other addresses of 127.0.0.0/8 are not configured on macOS, and
+* IPv6 can be disabled.
+*/
+function getLoopbackSupport() {
+	loopbackSupport ??= (async () => {
+		const server = createServer((socket) => socket.destroy());
+		let port;
+		try {
+			port = await listen(server, "::");
+		} catch {
+			return {
+				ipv6: false,
+				dualStack: false
+			};
+		}
+		try {
+			const [v4, v6] = await Promise.all([canConnect("127.0.0.1", port), canConnect("::1", port)]);
+			return {
+				ipv6: v6,
+				dualStack: v4 && v6
+			};
+		} finally {
+			await closeServer(server);
+		}
+	})();
+	return loopbackSupport;
+}
+/**
+* Starts an HTTP server that records the requests it receives.
+*/
+async function startRecordingServer(host = "127.0.0.1", respond = (_, res) => res.end("pinned")) {
+	const requests = [];
+	const server = createServer$1(async (req, res) => {
+		const body = await readBody(req);
+		requests.push({
+			method: req.method ?? "",
+			url: req.url ?? "",
+			host: req.headers.host,
+			localAddress: req.socket.localAddress,
+			body
+		});
+		respond(req, res);
+	});
+	return {
+		server,
+		port: await listen(server, host),
+		requests
+	};
+}
+/**
+* Starts a TCP server that only counts the connections it accepts, and drops
+* them right away.  It stands for an HTTPS server without a certificate.
+*/
+async function startCountingServer() {
+	const counter = { connections: 0 };
+	const server = createServer((socket) => {
+		counter.connections++;
+		socket.destroy();
+	});
+	return {
+		server,
+		port: await listen(server),
+		counter
+	};
+}
+/**
+* Starts a proxy that records the request targets it is asked for, and never
+* forwards them.  It answers a request in absolute form with `via-proxy`,
+* and drops tunnels (`CONNECT`).  It parses requests by itself since
+* the `connect` event of `node:http` servers is not available on older Bun
+* versions.
+* @param options.refuseTunnels Whether to refuse tunnels with a `403`
+*                              response instead of dropping them.  Some
+*                              clients retry dropped tunnels without end
+*                              (e.g., the `EnvHttpProxyAgent` of Node.js),
+*                              and some take the response of a refused
+*                              tunnel for the response of the request
+*                              (e.g., Bun 1.3.14).
+*/
+async function startRecordingProxy({ refuseTunnels = false } = {}) {
+	const targets = [];
+	const server = createServer((socket) => {
+		let head = "";
+		socket.setEncoding("latin1");
+		socket.on("error", () => {});
+		socket.on("data", (chunk) => {
+			if (head.includes("\r\n\r\n")) return;
+			head += chunk;
+			if (!head.includes("\r\n\r\n")) return;
+			const [method, target] = head.slice(0, head.indexOf("\r\n")).split(" ");
+			targets.push(`${method} ${target}`);
+			if (method !== "CONNECT") socket.end("HTTP/1.1 200 OK\r\nContent-Length: 9\r\nConnection: close\r\n\r\nvia-proxy");
+			else if (refuseTunnels) socket.end("HTTP/1.1 403 Forbidden\r\nContent-Length: 0\r\nConnection: close\r\n\r\n");
+			else socket.destroy();
+		});
+	});
+	return {
+		server,
+		port: await listen(server),
+		targets
+	};
+}
+/**
+* Returns the first of the given paths that exists.
+*/
+function findFile(name, candidates) {
+	const found = candidates.find((path) => existsSync(path));
+	if (found == null) throw new Error(`Cannot find ${name} in ${candidates.join(", ")}`);
+	return found;
+}
+function getModuleDirectory(moduleUrl) {
+	return typeof moduleUrl === "string" && moduleUrl.startsWith("file:") ? dirname(fileURLToPath(moduleUrl)) : null;
+}
+const TESTDATA = [
+	"src",
+	"pinners",
+	"testdata"
+];
+/**
+* Finds a source file in *testdata/* (e.g., a child script that Bun runs
+* directly).  When a test runs from the compiled *dist/tests/pinners/*
+* instead of *src/pinners/*, the test data is not compiled with it, so this
+* falls back to the files in the package: first relative to the test module,
+* then relative to the working directory (the package root, where the Bun
+* test script runs), in case `import.meta.url` is unavailable in a CommonJS
+* build.
+* @param name The file name.
+* @param moduleUrl The `import.meta.url` of the test module.
+*/
+function resolveTestdata(name, moduleUrl) {
+	const candidates = [];
+	const here = getModuleDirectory(moduleUrl);
+	if (here != null) candidates.push(join(here, TESTDATA[2], name), join(here, "..", "..", "..", ...TESTDATA, name));
+	candidates.push(join(process.cwd(), ...TESTDATA, name));
+	return findFile(name, candidates);
+}
+/**
+* Finds a child script of *testdata/* compiled into
+* *dist/tests/pinners/testdata/* by *tsdown.config.ts*, for Node.js, which
+* cannot run TypeScript sources without flags before 22.6.0.  Node.js tests
+* run only from *dist/tests/* (`cd dist/tests && node --test`), so this looks
+* relative to the test module, then relative to the working directory, in
+* case `import.meta.url` is unavailable in a CommonJS build.
+* @param name The compiled file name, e.g., `node-child.mjs`.
+* @param moduleUrl The `import.meta.url` of the test module.
+*/
+function resolveCompiledTestdata(name, moduleUrl) {
+	const candidates = [];
+	const here = getModuleDirectory(moduleUrl);
+	if (here != null) candidates.push(join(here, TESTDATA[2], name));
+	candidates.push(join(process.cwd(), ...TESTDATA.slice(1), name), join(process.cwd(), "dist", "tests", ...TESTDATA.slice(1), name));
+	return findFile(name, candidates);
+}
+const PROXY_ENV_NAMES = [
+	"HTTP_PROXY",
+	"HTTPS_PROXY",
+	"ALL_PROXY",
+	"NO_PROXY"
+];
+/**
+* Runs a child script in a new process of the current runtime, without proxy
+* environment variables (and `NODE_USE_ENV_PROXY`) but with the given ones,
+* and parses the last line of its output as JSON.
+* @param script The path of the script.
+* @param args The arguments to the script.
+* @param extraEnv The environment variables to set.
+*/
+function runChild(script, args, extraEnv) {
+	const env = { ...process.env };
+	for (const name of PROXY_ENV_NAMES) {
+		delete env[name];
+		delete env[name.toLowerCase()];
+	}
+	delete env.NODE_USE_ENV_PROXY;
+	Object.assign(env, extraEnv);
+	return new Promise((resolve, reject) => {
+		execFile(process.execPath, [script, ...args], {
+			env,
+			timeout: 3e4
+		}, (error, stdout, stderr) => {
+			if (error != null) {
+				reject(new Error(`${script} failed: ${stderr}`, { cause: error }));
+				return;
+			}
+			const line = stdout.trim().split("\n").at(-1) ?? "";
+			try {
+				resolve(JSON.parse(line));
+			} catch (cause) {
+				reject(new Error(`Unexpected output: ${stdout}${stderr}`, { cause }));
+			}
+		});
+	});
+}
+//#endregion
+export { ipv6 as a, isNode as c, resolveTestdata as d, runChild as f, startRecordingServer as h, ipv4 as i, listen as l, startRecordingProxy as m, closeServer as n, isAddressRejection as o, startCountingServer as p, getLoopbackSupport as r, isBun as s, allowAll as t, resolveCompiledTestdata as u };