@fedify/vocab-runtime 2.5.0-dev.2448 → 2.5.0-dev.2494

package/dist/tests/{portable-dereference-DaTBBvCj.cjs → portable-dereference-BUoDzMxk.cjs}

@@ -1,7 +1,7 @@
-const require_url = require("./url-BNakuZ8k.cjs");
+const require_url = require("./url-Bdj-rTcC.cjs");
 const require_contexts = require("./contexts-C9Lj11SC.cjs");
 require("./jsonld-CmDhHNTx.cjs");
-const require_jsonld_cache = require("./jsonld-cache-BEXiiM-V.cjs");
+const require_jsonld_cache = require("./jsonld-cache-DKIWKxEX.cjs");
 let _logtape_logtape = require("@logtape/logtape");
 require("@opentelemetry/api");
 //#region src/internal/portable-dereference.ts

package/dist/tests/{portable-dereference-sGRs_qdT.mjs → portable-dereference-Du2k3ngE.mjs}

@@ -1,7 +1,7 @@
-import { h as parseGatewayOrigin, o as formatIri, s as fromCompatibleEf61Id, t as GATEWAY_HINT_PARAMETER, u as haveSameFe34Origin } from "./url-DMxmp7ZG.mjs";
+import { c as fromCompatibleEf61Id, d as haveSameFe34Origin, s as formatIri, t as GATEWAY_HINT_PARAMETER, v as parseGatewayOrigin } from "./url-COj5Q8mb.mjs";
 import { t as preloadedContexts } from "./contexts-duRA_dDC.mjs";
 import "./jsonld-DweIJ07b.mjs";
-import { c as unwrapReleasedDocumentLoader, s as registerDocumentLoaderWrapper } from "./jsonld-cache-DFnWsLuZ.mjs";
+import { c as unwrapReleasedDocumentLoader, s as registerDocumentLoaderWrapper } from "./jsonld-cache-KH40z9_7.mjs";
 import { getLogger } from "@logtape/logtape";
 import "@opentelemetry/api";
 //#region src/internal/portable-dereference.ts

package/dist/tests/{portable-media-B-oCeotd.mjs → portable-media-CqCq3wqj.mjs}

@@ -1,6 +1,6 @@
-import { r as getUserAgent } from "./request-BlLYI4x3.mjs";
-import { g as parseGatewayUrl, x as validatePublicUrl } from "./url-DMxmp7ZG.mjs";
-import { r as readBoundedBytes } from "./body-oV99TVdA.mjs";
+import { r as getUserAgent } from "./request-Bo8cJJhV.mjs";
+import { T as validatePublicUrl, y as parseGatewayUrl } from "./url-COj5Q8mb.mjs";
+import { r as readBoundedBytes } from "./body-DfH6VTh9.mjs";
 import { a as verifyDigestMultibase, i as parseHashlink, r as parseDigestMultibase } from "./digest-COC7xDiQ.mjs";
 //#region src/portable-media.ts
 function resolveTimeout(value, fallback) {

package/dist/tests/{portable-media-D7ClSjFO.cjs → portable-media-Ls_EOkMN.cjs}

@@ -1,6 +1,6 @@
-const require_request = require("./request-B77_oZnk.cjs");
-const require_url = require("./url-BNakuZ8k.cjs");
-const require_body = require("./body-DP2u2wUX.cjs");
+const require_request = require("./request-Cb6h3X72.cjs");
+const require_url = require("./url-Bdj-rTcC.cjs");
+const require_body = require("./body-0Or8U7lA.cjs");
 const require_digest = require("./digest-3FeH2Y-Q.cjs");
 //#region src/portable-media.ts
 function resolveTimeout(value, fallback) {

package/dist/tests/portable-media.test.cjs

@@ -1,5 +1,5 @@
 const require_digest = require("./digest-3FeH2Y-Q.cjs");
-const require_portable_media = require("./portable-media-D7ClSjFO.cjs");
+const require_portable_media = require("./portable-media-Ls_EOkMN.cjs");
 let node_assert_strict = require("node:assert/strict");
 let node_test = require("node:test");
 let node_http = require("node:http");

package/dist/tests/portable-media.test.mjs

@@ -1,5 +1,5 @@
 import { n as createHashlink, t as computeDigestMultibase } from "./digest-COC7xDiQ.mjs";
-import { t as fetchPortableMedia } from "./portable-media-B-oCeotd.mjs";
+import { t as fetchPortableMedia } from "./portable-media-CqCq3wqj.mjs";
 import { deepStrictEqual, equal, rejects } from "node:assert/strict";
 import { test } from "node:test";
 import { createServer } from "node:http";

package/dist/tests/portable-workers.test.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_url = require("./url-BNakuZ8k.cjs");
+const require_url = require("./url-Bdj-rTcC.cjs");
 const require_key = require("./key-C-AYkdJJ.cjs");
 const require_digest = require("./digest-3FeH2Y-Q.cjs");
-const require_portable_dereference = require("./portable-dereference-DaTBBvCj.cjs");
+const require_portable_dereference = require("./portable-dereference-BUoDzMxk.cjs");
 let node_assert_strict = require("node:assert/strict");
 let _fedify_fixture = require("@fedify/fixture");
 //#region src/portable-workers.test.ts

package/dist/tests/portable-workers.test.mjs

@@ -1,7 +1,7 @@
-import { _ as parseIri, i as canonicalizePortableUri, o as formatIri, s as fromCompatibleEf61Id, y as toCompatibleEf61Id } from "./url-DMxmp7ZG.mjs";
+import { C as toCompatibleEf61Id, a as canonicalizePortableUri, b as parseIri, c as fromCompatibleEf61Id, s as formatIri } from "./url-COj5Q8mb.mjs";
 import { i as importDidKey, t as exportDidKey } from "./key-C2Db_TAJ.mjs";
 import { n as createHashlink, o as verifyHashlink, t as computeDigestMultibase } from "./digest-COC7xDiQ.mjs";
-import { n as getPortableGatewayCandidates } from "./portable-dereference-sGRs_qdT.mjs";
+import { n as getPortableGatewayCandidates } from "./portable-dereference-Du2k3ngE.mjs";
 import { deepStrictEqual, equal } from "node:assert/strict";
 import { test, testDefinitions } from "@fedify/fixture";
 //#region src/portable-workers.test.ts

package/dist/tests/public-fetch-BGj5pzUD.cjs

@@ -0,0 +1,186 @@
+const require_url = require("./url-Bdj-rTcC.cjs");
+const require_pin_grant = require("./pin-grant-CPrpk1l4.cjs");
+const require_pinners = require("./pinners-DLH_npLf.cjs");
+//#region src/public-fetch.ts
+const logger = (0, require("@logtape/logtape").getLogger)([
+	"fedify",
+	"runtime",
+	"fetch"
+]);
+/**
+* Creates {@link PublicFetch.openPublicFetch} and
+* {@link PublicFetch.withPublicFetch} bound to the given pinner and lookup.
+* This is exported only for tests; it is not exported from any entry point.
+* @param dependencies The pinner and the default lookup function.
+* @returns The functions.
+*/
+function createPublicFetch(dependencies) {
+	async function openPublicFetch(url, options = {}) {
+		const { url: parsed, hostname, family } = require_url.parsePublicUrl(url);
+		if (parsed.username !== "" || parsed.password !== "") throw new require_url.UrlError("URLs with credentials are not allowed");
+		const lookup = options.lookup ?? dependencies.lookup;
+		let addresses;
+		if (family !== 0) addresses = [{
+			address: hostname,
+			family
+		}];
+		else if (lookup === require_url.lookupAllAddresses && !await canResolve()) return createSession(parsed, globalFetch);
+		else {
+			options.signal?.throwIfAborted();
+			addresses = await require_url.lookupPublicAddresses(hostname, lookup);
+			options.signal?.throwIfAborted();
+		}
+		const pinner = await dependencies.pinner();
+		if (pinner == null || !pinner.supports(parsed)) {
+			logUnpinned(parsed);
+			return createSession(parsed, globalFetch);
+		}
+		const grant = require_pin_grant.issuePinGrant(parsed, addresses);
+		return createSession(parsed, (input, init) => pinner.fetch(grant, new Request(input, init), init.signal ?? void 0), {
+			grant,
+			pinner
+		});
+	}
+	async function withPublicFetch(url, fn, options) {
+		const session = await openPublicFetch(url, options);
+		try {
+			const result = await fn(session.fetch);
+			if (result instanceof Response) throw new TypeError("withPublicFetch() callbacks must not return a Response, since its body is cancelled when the session is closed.");
+			return result;
+		} catch (error) {
+			logger.debug("Failed while fetching {url}; closing the session: {error}", {
+				url: session.url.href,
+				error
+			});
+			throw error;
+		} finally {
+			await session.close();
+		}
+	}
+	return {
+		openPublicFetch,
+		withPublicFetch
+	};
+}
+const runtimePublicFetch = createPublicFetch({
+	pinner: require_pinners.getRuntimePinner,
+	lookup: require_url.lookupAllAddresses
+});
+/**
+* Validates the URL, resolves its hostname, checks that every resolved
+* address is public, and opens a session that connects only to those
+* addresses.  Connections are pinned on Node.js and Bun.  On other runtimes,
+* the session uses the global `fetch()` after the check.
+* @param url The URL to open a session for.
+* @param options The options.
+* @returns The session.  It must be closed.
+* @throws {UrlError} If the URL is not allowed, or its hostname cannot be
+*                    resolved (with `reason: "dns"`).
+*/
+const openPublicFetch = runtimePublicFetch.openPublicFetch;
+runtimePublicFetch.withPublicFetch;
+/**
+* Opens a session that neither validates nor pins addresses, for callers that
+* allow private addresses.  It has the same rules as {@link openPublicFetch}
+* sessions otherwise: requests are limited to the URL's origin, redirects are
+* never followed, and unconsumed response bodies are cancelled on close.
+* It grants nothing beyond calling the global `fetch()` directly.
+* @param url The URL to open a session for.
+* @returns The session.  It must be closed.
+*/
+function openDirectFetch(url) {
+	return Promise.resolve(createSession(new URL(url), globalFetch));
+}
+/**
+* Starts cancelling the body of a response without waiting for it to settle.
+* The cancellation of a branch of a tee (e.g., a body cloned by a fetch mock)
+* settles only after the other branch is cancelled too, per the Streams
+* standard, so awaiting it could block forever.  Failures are only logged.
+*/
+function cancelResponseBody(response, url) {
+	response.body?.cancel().catch((error) => {
+		logger.debug("Failed to cancel a response body from {url}: {error}", {
+			url: url.href,
+			error
+		});
+	});
+}
+function globalFetch(input, init) {
+	return fetch(input, init);
+}
+function createSession(url, send, pin) {
+	const origin = url.origin;
+	const tracked = [];
+	let closed = false;
+	async function sessionFetch(input, init) {
+		if (closed) throw new TypeError("The fetch session is closed.");
+		const target = new URL(input instanceof Request ? input.url : input);
+		if (target.origin !== origin) throw new TypeError(`A fetch session for ${origin} cannot fetch ${target.origin}.`);
+		const response = await send(input, {
+			...init,
+			redirect: "manual"
+		});
+		if (closed) {
+			cancelResponseBody(response, url);
+			throw new TypeError("The fetch session is closed.");
+		}
+		tracked.push(response);
+		return response;
+	}
+	async function close() {
+		if (closed) return;
+		closed = true;
+		for (const response of tracked) {
+			if (response.body == null || response.bodyUsed) continue;
+			if (response.body.locked) {
+				logger.debug("Cannot cancel a locked response body from {url}.", { url: url.href });
+				continue;
+			}
+			cancelResponseBody(response, url);
+		}
+		if (pin == null) return;
+		require_pin_grant.revokePinGrant(pin.grant);
+		await pin.pinner.release(pin.grant);
+	}
+	return {
+		get url() {
+			return new URL(url);
+		},
+		fetch: sessionFetch,
+		close
+	};
+}
+async function canResolve() {
+	if (!("Deno" in globalThis)) return true;
+	return (await Deno.permissions.query({ name: "net" })).state === "granted";
+}
+const loggedUnpinned = /* @__PURE__ */ new Set();
+function logUnpinned(url) {
+	const runtime = require_pinners.detectRuntime();
+	const key = `${runtime} ${url.protocol}`;
+	if (loggedUnpinned.has(key)) return;
+	loggedUnpinned.add(key);
+	logger.debug("Outbound {protocol} connections are not pinned to validated addresses on {runtime}; the hostname is resolved again when connecting.", {
+		runtime,
+		protocol: url.protocol
+	});
+}
+//#endregion
+Object.defineProperty(exports, "createPublicFetch", {
+	enumerable: true,
+	get: function() {
+		return createPublicFetch;
+	}
+});
+Object.defineProperty(exports, "openDirectFetch", {
+	enumerable: true,
+	get: function() {
+		return openDirectFetch;
+	}
+});
+Object.defineProperty(exports, "openPublicFetch", {
+	enumerable: true,
+	get: function() {
+		return openPublicFetch;
+	}
+});

package/dist/tests/public-fetch-Cxo3Yzdf.mjs

@@ -0,0 +1,170 @@
+import { S as parsePublicUrl, _ as lookupPublicAddresses, g as lookupAllAddresses, n as UrlError } from "./url-COj5Q8mb.mjs";
+import { r as revokePinGrant, t as issuePinGrant } from "./pin-grant-H5XhM1Xs.mjs";
+import { n as getRuntimePinner, t as detectRuntime } from "./pinners-tGcl49uF.mjs";
+import { getLogger } from "@logtape/logtape";
+//#region src/public-fetch.ts
+const logger = getLogger([
+	"fedify",
+	"runtime",
+	"fetch"
+]);
+/**
+* Creates {@link PublicFetch.openPublicFetch} and
+* {@link PublicFetch.withPublicFetch} bound to the given pinner and lookup.
+* This is exported only for tests; it is not exported from any entry point.
+* @param dependencies The pinner and the default lookup function.
+* @returns The functions.
+*/
+function createPublicFetch(dependencies) {
+	async function openPublicFetch(url, options = {}) {
+		const { url: parsed, hostname, family } = parsePublicUrl(url);
+		if (parsed.username !== "" || parsed.password !== "") throw new UrlError("URLs with credentials are not allowed");
+		const lookup = options.lookup ?? dependencies.lookup;
+		let addresses;
+		if (family !== 0) addresses = [{
+			address: hostname,
+			family
+		}];
+		else if (lookup === lookupAllAddresses && !await canResolve()) return createSession(parsed, globalFetch);
+		else {
+			options.signal?.throwIfAborted();
+			addresses = await lookupPublicAddresses(hostname, lookup);
+			options.signal?.throwIfAborted();
+		}
+		const pinner = await dependencies.pinner();
+		if (pinner == null || !pinner.supports(parsed)) {
+			logUnpinned(parsed);
+			return createSession(parsed, globalFetch);
+		}
+		const grant = issuePinGrant(parsed, addresses);
+		return createSession(parsed, (input, init) => pinner.fetch(grant, new Request(input, init), init.signal ?? void 0), {
+			grant,
+			pinner
+		});
+	}
+	async function withPublicFetch(url, fn, options) {
+		const session = await openPublicFetch(url, options);
+		try {
+			const result = await fn(session.fetch);
+			if (result instanceof Response) throw new TypeError("withPublicFetch() callbacks must not return a Response, since its body is cancelled when the session is closed.");
+			return result;
+		} catch (error) {
+			logger.debug("Failed while fetching {url}; closing the session: {error}", {
+				url: session.url.href,
+				error
+			});
+			throw error;
+		} finally {
+			await session.close();
+		}
+	}
+	return {
+		openPublicFetch,
+		withPublicFetch
+	};
+}
+const runtimePublicFetch = createPublicFetch({
+	pinner: getRuntimePinner,
+	lookup: lookupAllAddresses
+});
+/**
+* Validates the URL, resolves its hostname, checks that every resolved
+* address is public, and opens a session that connects only to those
+* addresses.  Connections are pinned on Node.js and Bun.  On other runtimes,
+* the session uses the global `fetch()` after the check.
+* @param url The URL to open a session for.
+* @param options The options.
+* @returns The session.  It must be closed.
+* @throws {UrlError} If the URL is not allowed, or its hostname cannot be
+*                    resolved (with `reason: "dns"`).
+*/
+const openPublicFetch = runtimePublicFetch.openPublicFetch;
+runtimePublicFetch.withPublicFetch;
+/**
+* Opens a session that neither validates nor pins addresses, for callers that
+* allow private addresses.  It has the same rules as {@link openPublicFetch}
+* sessions otherwise: requests are limited to the URL's origin, redirects are
+* never followed, and unconsumed response bodies are cancelled on close.
+* It grants nothing beyond calling the global `fetch()` directly.
+* @param url The URL to open a session for.
+* @returns The session.  It must be closed.
+*/
+function openDirectFetch(url) {
+	return Promise.resolve(createSession(new URL(url), globalFetch));
+}
+/**
+* Starts cancelling the body of a response without waiting for it to settle.
+* The cancellation of a branch of a tee (e.g., a body cloned by a fetch mock)
+* settles only after the other branch is cancelled too, per the Streams
+* standard, so awaiting it could block forever.  Failures are only logged.
+*/
+function cancelResponseBody(response, url) {
+	response.body?.cancel().catch((error) => {
+		logger.debug("Failed to cancel a response body from {url}: {error}", {
+			url: url.href,
+			error
+		});
+	});
+}
+function globalFetch(input, init) {
+	return fetch(input, init);
+}
+function createSession(url, send, pin) {
+	const origin = url.origin;
+	const tracked = [];
+	let closed = false;
+	async function sessionFetch(input, init) {
+		if (closed) throw new TypeError("The fetch session is closed.");
+		const target = new URL(input instanceof Request ? input.url : input);
+		if (target.origin !== origin) throw new TypeError(`A fetch session for ${origin} cannot fetch ${target.origin}.`);
+		const response = await send(input, {
+			...init,
+			redirect: "manual"
+		});
+		if (closed) {
+			cancelResponseBody(response, url);
+			throw new TypeError("The fetch session is closed.");
+		}
+		tracked.push(response);
+		return response;
+	}
+	async function close() {
+		if (closed) return;
+		closed = true;
+		for (const response of tracked) {
+			if (response.body == null || response.bodyUsed) continue;
+			if (response.body.locked) {
+				logger.debug("Cannot cancel a locked response body from {url}.", { url: url.href });
+				continue;
+			}
+			cancelResponseBody(response, url);
+		}
+		if (pin == null) return;
+		revokePinGrant(pin.grant);
+		await pin.pinner.release(pin.grant);
+	}
+	return {
+		get url() {
+			return new URL(url);
+		},
+		fetch: sessionFetch,
+		close
+	};
+}
+async function canResolve() {
+	if (!("Deno" in globalThis)) return true;
+	return (await Deno.permissions.query({ name: "net" })).state === "granted";
+}
+const loggedUnpinned = /* @__PURE__ */ new Set();
+function logUnpinned(url) {
+	const runtime = detectRuntime();
+	const key = `${runtime} ${url.protocol}`;
+	if (loggedUnpinned.has(key)) return;
+	loggedUnpinned.add(key);
+	logger.debug("Outbound {protocol} connections are not pinned to validated addresses on {runtime}; the hostname is resolved again when connecting.", {
+		runtime,
+		protocol: url.protocol
+	});
+}
+//#endregion
+export { openDirectFetch as n, openPublicFetch as r, createPublicFetch as t };