@fedify/vocab-runtime 2.4.0-pr.936.41 → 2.4.1

package/dist/tests/portable-dereference-qTLMqe2_.cjs

@@ -0,0 +1,279 @@
+const require_contexts = require("./contexts-C9Lj11SC.cjs");
+const require_url = require("./url-BNakuZ8k.cjs");
+require("./jsonld-CmDhHNTx.cjs");
+const require_jsonld_cache = require("./jsonld-cache-BEXiiM-V.cjs");
+let _logtape_logtape = require("@logtape/logtape");
+require("@opentelemetry/api");
+//#region src/internal/portable-dereference.ts
+const logger = (0, _logtape_logtape.getLogger)([
+	"fedify",
+	"vocab",
+	"gateway"
+]);
+/**
+* The maximum number of `@gateway` location hints to try for one reference.
+* Hints come from possibly untrusted documents, so they are bounded to keep
+* a single accessor call from fanning out to many servers.
+*/
+const MAX_GATEWAY_HINTS = 5;
+const BASELINE_CONTEXT_URLS = /* @__PURE__ */ new Set([
+	"https://w3id.org/identity/v1",
+	"https://www.w3.org/ns/activitystreams",
+	"https://w3id.org/security/v1",
+	"https://w3id.org/security/data-integrity/v1"
+]);
+const provenances = /* @__PURE__ */ new WeakMap();
+function getObjectId(object) {
+	if (object == null || typeof object !== "object" || !("id" in object)) return null;
+	const id = object.id;
+	return id instanceof URL ? id : null;
+}
+/**
+* Checks whether a vocabulary object is part of a chain of portable objects,
+* i.e., whether it has a portable ID, has an FEP-ef61 compatible identifier
+* as its ID (even a malformed one, so that it fails closed), or was obtained
+* from a portable object.  Accessors of such objects dereference references
+* as portable objects.
+*
+* Being part of a chain does not mean that the object itself is verified:
+* an object parsed from arbitrary JSON-LD is in a chain just because of its
+* ID.  Only {@link dereferencePortableIri} records that an object was
+* accepted by a verifier.
+*
+* @internal Technically exported for generated vocabulary classes, but not
+* part of the public API contract.  This is not considered public API for
+* Semantic Versioning decisions.
+*/
+function isInPortableChain(object) {
+	if (provenances.has(object)) return true;
+	const id = getObjectId(object);
+	return id != null && (isPortableIri(id) || isCompatibleEf61Iri(id));
+}
+/**
+* Checks whether a URL is an FEP-ef61 compatible identifier, i.e., an HTTP(S)
+* URL under a gateway's `/.well-known/apgateway/` path that stands for
+* a portable object.  Malformed compatible identifiers count as compatible
+* identifiers too.
+*
+* @internal Technically exported for generated vocabulary classes, but not
+* part of the public API contract.  This is not considered public API for
+* Semantic Versioning decisions.
+*/
+function isCompatibleEf61Iri(url) {
+	try {
+		return require_url.fromCompatibleEf61Id(url) != null;
+	} catch (error) {
+		if (error instanceof TypeError) return true;
+		throw error;
+	}
+}
+/**
+* Records that a vocabulary object returned by a property accessor was
+* obtained through the given property of a portable object, so that later
+* dereferences from it can tell where it came from.  Nothing is recorded if
+* the parent is not in a portable chain, or if the child already has its
+* provenance.
+*
+* @internal Technically exported for generated vocabulary classes, but not
+* part of the public API contract.  This is not considered public API for
+* Semantic Versioning decisions.
+*/
+function recordPortableReferrer(parent, child, property) {
+	if (child == null || typeof child !== "object") return;
+	if (provenances.has(child) || !isInPortableChain(parent)) return;
+	provenances.set(child, { referrer: {
+		object: parent,
+		property
+	} });
+}
+/**
+* Checks whether a URL is an FEP-ef61 portable ActivityPub IRI.
+*
+* @internal Technically exported for generated vocabulary classes, but not
+* part of the public API contract.  This is not considered public API for
+* Semantic Versioning decisions.
+*/
+function isPortableIri(url) {
+	return url.protocol === "ap+ef61:" || url.protocol === "ap:";
+}
+/**
+* Picks the ordered list of FEP-ef61 gateways to fetch a portable IRI from.
+*
+* If `gateways` is given, it is used as is (even when empty), and `@gateway`
+* location hints in the IRI are ignored.  Otherwise, up to
+* {@link MAX_GATEWAY_HINTS} valid `@gateway` hints are used.  Duplicate
+* gateways are dropped in both cases.
+*
+* @throws {TypeError} If an explicit gateway is not an HTTP(S) origin.
+* @internal
+*/
+function getPortableGatewayCandidates(url, gateways) {
+	const candidates = [];
+	const seen = /* @__PURE__ */ new Set();
+	const add = (gateway) => {
+		if (seen.has(gateway.href)) return;
+		seen.add(gateway.href);
+		candidates.push(gateway);
+	};
+	if (gateways != null) {
+		for (const gateway of gateways) {
+			const parsed = require_url.parseGatewayOrigin(gateway);
+			if (parsed == null) throw new TypeError("FEP-ef61 gateways must be HTTP(S) origins with no credentials, path, query, or fragment: " + String(gateway));
+			add(parsed);
+		}
+		return candidates;
+	}
+	for (const hint of new URLSearchParams(url.search).getAll(require_url.GATEWAY_HINT_PARAMETER)) {
+		if (candidates.length >= MAX_GATEWAY_HINTS) break;
+		const parsed = require_url.parseGatewayOrigin(hint);
+		if (parsed == null) {
+			logger.debug("Ignoring an invalid FEP-ef61 gateway hint {hint} in {url}.", {
+				hint,
+				url: require_url.formatIri(url)
+			});
+			continue;
+		}
+		add(parsed);
+	}
+	return candidates;
+}
+/**
+* Gets the gateways through which a portable reference without location hints
+* can be dereferenced, from the portable actor that the reference belongs to.
+*
+* The references in a portable actor's own document, such as its `outbox`,
+* usually have no `@gateway` hints, as they are not needed there, since
+* the actor's `gateways` already tells where to retrieve them.  So this walks
+* from the object whose property is being dereferenced up through the objects
+* it was obtained from, e.g., from a collection page to the collection and
+* then to the actor, and returns the `gateways` of the first object that has
+* any, but only if that object has the same DID as the reference.  The
+* gateways only tell where to look; whatever they serve is still verified.
+*
+* @param object The object whose property is being dereferenced.
+* @param url The portable IRI to dereference.
+* @returns Up to {@link MAX_GATEWAY_HINTS} valid gateways, or `undefined` if
+*          the IRI has valid `@gateway` hints or no such object is found.
+* @internal Technically exported for generated vocabulary classes, but not
+* part of the public API contract.  This is not considered public API for
+* Semantic Versioning decisions.
+*/
+function getReferrerGateways(object, url) {
+	if (getPortableGatewayCandidates(url).length > 0) return void 0;
+	const visited = /* @__PURE__ */ new Set();
+	let current = object;
+	while (current != null && !visited.has(current)) {
+		visited.add(current);
+		const gateways = "gateways" in current ? current.gateways : void 0;
+		if (Array.isArray(gateways) && gateways.length > 0) {
+			const id = getObjectId(current);
+			const portableId = id == null ? null : isPortableIri(id) ? id : getCompatibleEf61Target(id);
+			if (portableId == null || !require_url.haveSameFe34Origin(portableId, url)) return;
+			const candidates = [];
+			for (const gateway of gateways) {
+				if (candidates.length >= MAX_GATEWAY_HINTS) break;
+				if (typeof gateway !== "string" && !(gateway instanceof URL)) continue;
+				const parsed = require_url.parseGatewayOrigin(gateway);
+				if (parsed == null) continue;
+				if (candidates.some((c) => c.href === parsed.href)) continue;
+				candidates.push(parsed);
+			}
+			return candidates.length > 0 ? candidates : void 0;
+		}
+		current = provenances.get(current)?.referrer?.object;
+	}
+}
+function getCompatibleEf61Target(id) {
+	try {
+		return require_url.fromCompatibleEf61Id(id);
+	} catch {
+		return null;
+	}
+}
+/**
+* Creates a context loader that returns the same context documents for the
+* whole dereference operation, so that the identity check, the proof
+* verifier, and the parser interpret the fetched document identically even
+* if the underlying loader is nondeterministic.  Failed loads are not
+* remembered, so a transient failure does not affect the next gateway.
+*
+* The parsed object keeps the loader for its own later dereferences, so
+* `release()` turns it into a plain pass-through to the underlying loader
+* once the operation is over.
+*
+* @internal Technically exported for generated vocabulary classes, but not
+* part of the public API contract.  This is not considered public API for
+* Semantic Versioning decisions.
+*/
+function createSnapshotContextLoader(contextLoader, suppressError) {
+	contextLoader = require_jsonld_cache.unwrapReleasedDocumentLoader(contextLoader);
+	const cache = /* @__PURE__ */ new Map();
+	let released = false;
+	const release = () => {
+		released = true;
+		state.released = true;
+		cache.clear();
+	};
+	const loader = async (url, options) => {
+		if (released) return await contextLoader(url, options);
+		const key = URL.canParse(url) ? new URL(url).href : url;
+		if (BASELINE_CONTEXT_URLS.has(key)) return {
+			contextUrl: null,
+			document: structuredClone(require_contexts.preloadedContexts[key]),
+			documentUrl: key
+		};
+		let promise = cache.get(key);
+		if (promise == null) {
+			const loading = contextLoader(url, suppressError ? {
+				...options,
+				suppressError: true
+			} : options).then((document) => structuredClone(document));
+			promise = loading;
+			cache.set(key, loading);
+			loading.catch(() => {
+				if (cache.get(key) === loading) cache.delete(key);
+			});
+		}
+		return structuredClone(await promise);
+	};
+	const state = {
+		base: contextLoader,
+		released: false
+	};
+	require_jsonld_cache.registerDocumentLoaderWrapper(loader, state);
+	return {
+		loader,
+		release
+	};
+}
+//#endregion
+Object.defineProperty(exports, "createSnapshotContextLoader", {
+	enumerable: true,
+	get: function() {
+		return createSnapshotContextLoader;
+	}
+});
+Object.defineProperty(exports, "getPortableGatewayCandidates", {
+	enumerable: true,
+	get: function() {
+		return getPortableGatewayCandidates;
+	}
+});
+Object.defineProperty(exports, "getReferrerGateways", {
+	enumerable: true,
+	get: function() {
+		return getReferrerGateways;
+	}
+});
+Object.defineProperty(exports, "isPortableIri", {
+	enumerable: true,
+	get: function() {
+		return isPortableIri;
+	}
+});
+Object.defineProperty(exports, "recordPortableReferrer", {
+	enumerable: true,
+	get: function() {
+		return recordPortableReferrer;
+	}
+});

package/dist/tests/portable-media-5p8azal0.cjs

@@ -0,0 +1,153 @@
+const require_request = require("./request-BgjA9wyl.cjs");
+const require_body = require("./body-cKLBprYm.cjs");
+const require_url = require("./url-BNakuZ8k.cjs");
+const require_digest = require("./digest-3FeH2Y-Q.cjs");
+//#region src/portable-media.ts
+function resolveTimeout(value, fallback) {
+	if (value === null) return null;
+	const result = value ?? fallback;
+	if (!Number.isFinite(result) || result <= 0 || result > 2147483647) throw new RangeError("A media timeout must be a positive finite number of milliseconds.");
+	return Math.ceil(result);
+}
+async function withTimeout(operation, parent, timeout) {
+	parent?.throwIfAborted();
+	const controller = new AbortController();
+	const onParentAbort = () => controller.abort(parent?.reason);
+	parent?.addEventListener("abort", onParentAbort, { once: true });
+	let timer;
+	if (timeout != null) timer = setTimeout(() => controller.abort(new DOMException(`Media retrieval timed out after ${timeout} ms.`, "TimeoutError")), timeout);
+	let onAbort;
+	const aborted = new Promise((_, reject) => {
+		onAbort = () => reject(controller.signal.reason);
+		controller.signal.addEventListener("abort", onAbort, { once: true });
+	});
+	try {
+		return await Promise.race([operation(controller.signal), aborted]);
+	} finally {
+		if (timer != null) clearTimeout(timer);
+		parent?.removeEventListener("abort", onParentAbort);
+		if (onAbort != null) controller.signal.removeEventListener("abort", onAbort);
+	}
+}
+function mediaTarget(media) {
+	if (typeof media === "string" || media instanceof URL) return {
+		url: media.toString(),
+		digestMultibase: void 0
+	};
+	const target = media.href ?? media.url;
+	const url = target instanceof URL ? target.href : target != null && typeof target === "object" && "href" in target ? target.href?.href : void 0;
+	if (url == null) throw new TypeError("Portable media has no URL or href.");
+	const linkDigest = target != null && !(target instanceof URL) && typeof target === "object" && "digestMultibase" in target ? target.digestMultibase : void 0;
+	if (media.digestMultibase != null && linkDigest != null) {
+		const outer = require_digest.parseDigestMultibase(media.digestMultibase).digest;
+		const inner = require_digest.parseDigestMultibase(linkDigest).digest;
+		if (outer.some((byte, i) => byte !== inner[i])) throw new TypeError("Media and linked resource digests disagree.");
+	}
+	return {
+		url,
+		digestMultibase: media.digestMultibase ?? linkDigest
+	};
+}
+async function fetchVerified(url, digestMultibase, options, signal, maxBytes) {
+	const visited = /* @__PURE__ */ new Set();
+	for (let redirects = 0; redirects <= 20; redirects++) {
+		signal.throwIfAborted();
+		if (url.username !== "" || url.password !== "") throw new TypeError("Media URLs must not contain credentials.");
+		if (!options.allowPrivateAddress) await require_url.validatePublicUrl(url.href);
+		else if (url.protocol !== "http:" && url.protocol !== "https:") throw new TypeError("Media URLs must use HTTP(S).");
+		if (visited.has(url.href)) throw new TypeError("Media redirect loop.");
+		visited.add(url.href);
+		const response = await fetch(url, {
+			method: "GET",
+			headers: {
+				Accept: "*/*",
+				"User-Agent": typeof options.userAgent === "string" ? options.userAgent : require_request.getUserAgent(options.userAgent)
+			},
+			redirect: "manual",
+			signal
+		});
+		if ([
+			301,
+			302,
+			303,
+			307,
+			308
+		].includes(response.status)) {
+			const location = response.headers.get("Location");
+			response.body?.cancel().catch(() => {});
+			if (location == null || redirects === 20) throw new TypeError("Invalid or excessive media redirects.");
+			url = new URL(location, url);
+			continue;
+		}
+		if (response.status !== 200) {
+			response.body?.cancel().catch(() => {});
+			throw new Error(`Media request failed with HTTP ${response.status}.`);
+		}
+		const bytes = await require_body.readBoundedBytes(response, maxBytes, url);
+		signal.throwIfAborted();
+		if (!await require_digest.verifyDigestMultibase(bytes, digestMultibase)) throw new Error("Portable media digest does not match.");
+		const headers = new Headers();
+		const contentType = response.headers.get("Content-Type");
+		if (contentType != null) headers.set("Content-Type", contentType);
+		return new Response(bytes, { headers });
+	}
+	throw new TypeError("Too many media redirects.");
+}
+/**
+* Fetches a portable object's external media and returns it only after its
+* SHA-256 `digestMultibase` has been verified.  `hl:` resources are tried at
+* the supplied gateways in order.  The result contains verified body bytes;
+* its `Content-Type` is unverified metadata supplied by the server.
+*
+* @param media A Link, Image, Document, or URL with an external resource.
+* @param options Retrieval, integrity, and network policy options.
+* @returns A response containing only verified bytes.
+* @throws {TypeError} If the media reference or digest is invalid.
+* @throws {Error} If no source supplies a matching bounded resource.
+* @since 2.4.0
+*/
+async function fetchPortableMedia(media, options = {}) {
+	const { url, digestMultibase: propertyDigest } = mediaTarget(media);
+	const digestMultibase = propertyDigest ?? options.digestMultibase;
+	if (digestMultibase == null) throw new TypeError("Portable media requires digestMultibase.");
+	const expected = require_digest.parseDigestMultibase(digestMultibase).digest;
+	const maxBytes = options.maxBytes ?? 16777216;
+	if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0) throw new RangeError("The media size limit must be a positive safe integer.");
+	const timeout = resolveTimeout(options.timeout, 1e4);
+	const gatewayTimeout = resolveTimeout(options.gatewayTimeout, 3e3);
+	let targets;
+	let hashlink = false;
+	if (/^hl:/i.test(url)) {
+		hashlink = true;
+		const hashDigest = require_digest.parseDigestMultibase(require_digest.parseHashlink(url).digestMultibase).digest;
+		if (expected.some((byte, i) => byte !== hashDigest[i])) throw new TypeError("Hashlink and digestMultibase disagree.");
+		const gateways = [...new Set([...options.gateways ?? []].map((gateway) => require_url.parseGatewayUrl(gateway.toString()).origin))];
+		if (gateways.length === 0) throw new TypeError("Hashlink media requires at least one gateway.");
+		targets = gateways.map((gateway) => new URL(`/.well-known/apgateway/${url}`, gateway));
+	} else {
+		const target = new URL(url);
+		if (target.protocol !== "http:" && target.protocol !== "https:") throw new TypeError("Portable media URLs must use HTTP(S) or hl:.");
+		targets = [target];
+	}
+	return await withTimeout(async (signal) => {
+		let lastError;
+		for (const target of targets) {
+			signal.throwIfAborted();
+			try {
+				return await withTimeout((attemptSignal) => fetchVerified(target, digestMultibase, options, attemptSignal, maxBytes), signal, hashlink ? gatewayTimeout : null);
+			} catch (error) {
+				signal.throwIfAborted();
+				if (!hashlink) throw error;
+				lastError = error;
+			}
+		}
+		throw new Error("No gateway returned verified portable media.", { cause: lastError });
+	}, options.signal, timeout);
+}
+//#endregion
+Object.defineProperty(exports, "fetchPortableMedia", {
+	enumerable: true,
+	get: function() {
+		return fetchPortableMedia;
+	}
+});

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

@@ -0,0 +1,148 @@
+import { r as getUserAgent } from "./request-DodZNukP.mjs";
+import { r as readBoundedBytes } from "./body-DpC9p-iG.mjs";
+import { g as parseGatewayUrl, x as validatePublicUrl } from "./url-DMxmp7ZG.mjs";
+import { a as verifyDigestMultibase, i as parseHashlink, r as parseDigestMultibase } from "./digest-COC7xDiQ.mjs";
+//#region src/portable-media.ts
+function resolveTimeout(value, fallback) {
+	if (value === null) return null;
+	const result = value ?? fallback;
+	if (!Number.isFinite(result) || result <= 0 || result > 2147483647) throw new RangeError("A media timeout must be a positive finite number of milliseconds.");
+	return Math.ceil(result);
+}
+async function withTimeout(operation, parent, timeout) {
+	parent?.throwIfAborted();
+	const controller = new AbortController();
+	const onParentAbort = () => controller.abort(parent?.reason);
+	parent?.addEventListener("abort", onParentAbort, { once: true });
+	let timer;
+	if (timeout != null) timer = setTimeout(() => controller.abort(new DOMException(`Media retrieval timed out after ${timeout} ms.`, "TimeoutError")), timeout);
+	let onAbort;
+	const aborted = new Promise((_, reject) => {
+		onAbort = () => reject(controller.signal.reason);
+		controller.signal.addEventListener("abort", onAbort, { once: true });
+	});
+	try {
+		return await Promise.race([operation(controller.signal), aborted]);
+	} finally {
+		if (timer != null) clearTimeout(timer);
+		parent?.removeEventListener("abort", onParentAbort);
+		if (onAbort != null) controller.signal.removeEventListener("abort", onAbort);
+	}
+}
+function mediaTarget(media) {
+	if (typeof media === "string" || media instanceof URL) return {
+		url: media.toString(),
+		digestMultibase: void 0
+	};
+	const target = media.href ?? media.url;
+	const url = target instanceof URL ? target.href : target != null && typeof target === "object" && "href" in target ? target.href?.href : void 0;
+	if (url == null) throw new TypeError("Portable media has no URL or href.");
+	const linkDigest = target != null && !(target instanceof URL) && typeof target === "object" && "digestMultibase" in target ? target.digestMultibase : void 0;
+	if (media.digestMultibase != null && linkDigest != null) {
+		const outer = parseDigestMultibase(media.digestMultibase).digest;
+		const inner = parseDigestMultibase(linkDigest).digest;
+		if (outer.some((byte, i) => byte !== inner[i])) throw new TypeError("Media and linked resource digests disagree.");
+	}
+	return {
+		url,
+		digestMultibase: media.digestMultibase ?? linkDigest
+	};
+}
+async function fetchVerified(url, digestMultibase, options, signal, maxBytes) {
+	const visited = /* @__PURE__ */ new Set();
+	for (let redirects = 0; redirects <= 20; redirects++) {
+		signal.throwIfAborted();
+		if (url.username !== "" || url.password !== "") throw new TypeError("Media URLs must not contain credentials.");
+		if (!options.allowPrivateAddress) await validatePublicUrl(url.href);
+		else if (url.protocol !== "http:" && url.protocol !== "https:") throw new TypeError("Media URLs must use HTTP(S).");
+		if (visited.has(url.href)) throw new TypeError("Media redirect loop.");
+		visited.add(url.href);
+		const response = await fetch(url, {
+			method: "GET",
+			headers: {
+				Accept: "*/*",
+				"User-Agent": typeof options.userAgent === "string" ? options.userAgent : getUserAgent(options.userAgent)
+			},
+			redirect: "manual",
+			signal
+		});
+		if ([
+			301,
+			302,
+			303,
+			307,
+			308
+		].includes(response.status)) {
+			const location = response.headers.get("Location");
+			response.body?.cancel().catch(() => {});
+			if (location == null || redirects === 20) throw new TypeError("Invalid or excessive media redirects.");
+			url = new URL(location, url);
+			continue;
+		}
+		if (response.status !== 200) {
+			response.body?.cancel().catch(() => {});
+			throw new Error(`Media request failed with HTTP ${response.status}.`);
+		}
+		const bytes = await readBoundedBytes(response, maxBytes, url);
+		signal.throwIfAborted();
+		if (!await verifyDigestMultibase(bytes, digestMultibase)) throw new Error("Portable media digest does not match.");
+		const headers = new Headers();
+		const contentType = response.headers.get("Content-Type");
+		if (contentType != null) headers.set("Content-Type", contentType);
+		return new Response(bytes, { headers });
+	}
+	throw new TypeError("Too many media redirects.");
+}
+/**
+* Fetches a portable object's external media and returns it only after its
+* SHA-256 `digestMultibase` has been verified.  `hl:` resources are tried at
+* the supplied gateways in order.  The result contains verified body bytes;
+* its `Content-Type` is unverified metadata supplied by the server.
+*
+* @param media A Link, Image, Document, or URL with an external resource.
+* @param options Retrieval, integrity, and network policy options.
+* @returns A response containing only verified bytes.
+* @throws {TypeError} If the media reference or digest is invalid.
+* @throws {Error} If no source supplies a matching bounded resource.
+* @since 2.4.0
+*/
+async function fetchPortableMedia(media, options = {}) {
+	const { url, digestMultibase: propertyDigest } = mediaTarget(media);
+	const digestMultibase = propertyDigest ?? options.digestMultibase;
+	if (digestMultibase == null) throw new TypeError("Portable media requires digestMultibase.");
+	const expected = parseDigestMultibase(digestMultibase).digest;
+	const maxBytes = options.maxBytes ?? 16777216;
+	if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0) throw new RangeError("The media size limit must be a positive safe integer.");
+	const timeout = resolveTimeout(options.timeout, 1e4);
+	const gatewayTimeout = resolveTimeout(options.gatewayTimeout, 3e3);
+	let targets;
+	let hashlink = false;
+	if (/^hl:/i.test(url)) {
+		hashlink = true;
+		const hashDigest = parseDigestMultibase(parseHashlink(url).digestMultibase).digest;
+		if (expected.some((byte, i) => byte !== hashDigest[i])) throw new TypeError("Hashlink and digestMultibase disagree.");
+		const gateways = [...new Set([...options.gateways ?? []].map((gateway) => parseGatewayUrl(gateway.toString()).origin))];
+		if (gateways.length === 0) throw new TypeError("Hashlink media requires at least one gateway.");
+		targets = gateways.map((gateway) => new URL(`/.well-known/apgateway/${url}`, gateway));
+	} else {
+		const target = new URL(url);
+		if (target.protocol !== "http:" && target.protocol !== "https:") throw new TypeError("Portable media URLs must use HTTP(S) or hl:.");
+		targets = [target];
+	}
+	return await withTimeout(async (signal) => {
+		let lastError;
+		for (const target of targets) {
+			signal.throwIfAborted();
+			try {
+				return await withTimeout((attemptSignal) => fetchVerified(target, digestMultibase, options, attemptSignal, maxBytes), signal, hashlink ? gatewayTimeout : null);
+			} catch (error) {
+				signal.throwIfAborted();
+				if (!hashlink) throw error;
+				lastError = error;
+			}
+		}
+		throw new Error("No gateway returned verified portable media.", { cause: lastError });
+	}, options.signal, timeout);
+}
+//#endregion
+export { fetchPortableMedia as t };