@fedify/vocab-runtime 2.4.0-dev.2063 → 2.4.0-dev.2065

package/dist/internal/portable-dereference.d.ts

@@ -1,6 +1,6 @@
 /// <reference lib="esnext.temporal" />
-import { n as DocumentLoader } from "../docloader-Dr8wEkif.js";
-import { r as PortableObjectVerifier } from "../portable--NcyA1R_.js";
+import { n as DocumentLoader, s as RemoteDocument } from "../docloader-Dr8wEkif.js";
+import { r as PortableObjectVerifier } from "../portable-DH3947GK.js";
 import { Span, TracerProvider } from "@opentelemetry/api";
 
 //#region src/internal/portable-dereference.d.ts
@@ -69,22 +69,128 @@ declare function recordPortableReferrer(parent: object, child: unknown, property
 */
 declare function copyPortableProvenance(from: object, to: object): void;
 /**
-* Rejects a reference from a portable object that would be dereferenced as
-* an ordinary HTTP(S) object although it stands for a portable object, i.e.,
-* an FEP-ef61 compatible identifier, or a document whose final URL or `@id`
-* is a compatible identifier or a portable IRI.  Such a document would skip
-* the portable object policy, so it is rejected regardless of the
-* `crossOrigin` option, except that `crossOrigin: "throw"` makes it throw.
+* Recognizes an FEP-ef61 compatible identifier to dereference as a portable
+* object.
+*
+* @returns `undefined` if the URL is not a compatible identifier; `null` if
+*          it is a malformed compatible identifier; otherwise, the portable
+*          ID it stands for and the gateway it names.
+* @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.
+*/
+declare function parseCompatibleEf61Reference(url: URL | string): {
+  readonly id: URL;
+  readonly gateway: URL;
+} | null | undefined;
+/**
+* Checks whether a property accessor call on a vocabulary object applies the
+* FEP-ef61 portable object policy, i.e., whether the `verifyPortableObject`
+* option is given or the object is part of a chain of portable objects.
+* In this mode, compatible identifiers are dereferenced as portable objects,
+* and fetched documents that turn out to stand for portable objects are
+* verified as such.
+*
+* @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.
+*/
+declare function isPortableMode(object: object, options: {
+  readonly verifyPortableObject?: PortableObjectVerifier;
+}): boolean;
+/**
+* Checks whether an object embedded in a property of a vocabulary object has
+* to be dereferenced by its `@id` and verified as a portable object rather
+* than trusted as embedded, even with `crossOrigin: "trust"`.  This is the
+* case in {@link isPortableMode | portable mode} if its `@id` is an FEP-ef61
+* compatible identifier, or a portable IRI whose DID differs from the
+* owner's portable ID.
+*
+* @param parent The object whose property embeds the object.
+* @param ownerId The ID of the object that vouches for embedded objects, or
+*                `null` if embedded objects are not trusted by their owner.
+* @param id The `@id` of the embedded object.
+* @param options The options of the accessor.
+* @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.
+*/
+declare function mustDereferencePortableObject(parent: object, ownerId: URL | null, id: URL, options: {
+  readonly verifyPortableObject?: PortableObjectVerifier;
+}): boolean;
+/**
+* The portable object that a document fetched as an ordinary HTTP(S)
+* document claims to be.
+*
+* @internal
+*/
+interface PortableResponseClaim {
+  /** The portable ID that the document has to have. */
+  readonly id: URL;
+  /**
+  * The gateways inferred from the document's URL or `@id`, which are
+  * reported to the verifier as gateway hints.
+  */
+  readonly inferredGateways: readonly URL[];
+}
+/**
+* Finds out whether a document fetched as an ordinary HTTP(S) document
+* claims to be a portable object: its final URL is a portable IRI or an
+* FEP-ef61 compatible identifier, or else its `@id` is.  The final URL takes
+* precedence, so a document whose `@id` claims another object fails the
+* identity check against the final URL.
+*
+* @param documentUrl The final URL of the document.
+* @param objectId The `@id` of the parsed document.
+* @returns `undefined` if the document does not claim to be a portable
+*          object; `null` if the claim is malformed; otherwise, the claim.
+* @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.
+*/
+declare function getPortableResponseClaim(documentUrl: string, objectId: URL | null): PortableResponseClaim | null | undefined;
+/**
+* Records that an object fetched as an ordinary HTTP(S) object stands for
+* a portable object if its reference, its final URL, or its `@id` is
+* a portable IRI or an FEP-ef61 compatible identifier.  Accessors do not
+* cache such objects in their parents, so that a later call with the
+* `verifyPortableObject` option dereferences and verifies them.
+*
+* @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.
+*/
+declare function markUnverifiedPortableClaim(object: object, reference: URL, documentUrl: string): void;
+/**
+* Checks whether an object was fetched as an ordinary HTTP(S) object although
+* it stands for a portable object.  See {@link markUnverifiedPortableClaim}.
+*
+* @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.
+*/
+declare function isUnverifiedPortableClaim(object: object): boolean;
+/**
+* Rejects a malformed FEP-ef61 compatible identifier found in a reference,
+* the final URL of a fetched document, or its `@id`, when it would be
+* dereferenced as a portable object.  It is rejected without a request (or
+* without returning the fetched document), since it cannot be verified as
+* a portable object, and fetching it as an ordinary HTTP(S) object would
+* skip the portable object policy.
 *
 * @param url The rejected URL, for the log message.
-* @param crossOrigin The `crossOrigin` option of the accessor.
+* @param options The options of the accessor.
 * @returns Always `null`.
-* @throws {Error} If `crossOrigin` is `"throw"`.
+* @throws {Error} If `crossOrigin` is `"throw"` and `suppressError` is not
+*                 set.
 * @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.
 */
-declare function rejectPortableChainReference(url: string, crossOrigin: "ignore" | "throw" | "trust" | undefined): null;
+declare function rejectMalformedCompatibleReference(url: string, options: {
+  readonly crossOrigin?: "ignore" | "throw" | "trust";
+  readonly suppressError?: boolean;
+}): null;
 /**
 * Logs that an embedded object without `@id` in an object accepted without
 * an integrity proof is dropped, because it cannot be dereferenced and
@@ -116,6 +222,25 @@ declare function isPortableIri(url: URL): boolean;
 */
 declare function getPortableGatewayCandidates(url: URL, gateways?: readonly (string | URL)[]): URL[];
 /**
+* 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.
+*/
+declare function createSnapshotContextLoader(contextLoader: DocumentLoader): {
+  loader: DocumentLoader;
+  release: () => void;
+};
+/**
 * Options for {@link dereferencePortableIri}.
 *
 * @internal Technically exported for generated vocabulary classes, but not
@@ -127,6 +252,20 @@ interface DereferencePortableIriOptions<T> {
   contextLoader: DocumentLoader;
   tracerProvider: TracerProvider;
   gateways?: readonly (string | URL)[];
+  /**
+  * The gateways inferred from where the reference came from, e.g., the
+  * gateway of a compatible identifier.  When given, they replace the
+  * `@gateway` location hints of the IRI, are asked before the explicit
+  * `gateways`, and are reported to the verifier as gateway hints unless
+  * `gateways` is given.
+  */
+  inferredGateways?: readonly URL[];
+  /**
+  * An already fetched document to validate instead of fetching the object
+  * from gateways.  It is validated the same way as a gateway's response,
+  * and nothing else is tried if it is rejected.
+  */
+  response?: RemoteDocument;
   verifyPortableObject?: PortableObjectVerifier;
   referrer?: PortableReferrerLink;
   suppressError?: boolean;
@@ -158,9 +297,10 @@ declare class PortableObjectRejectedError extends Error {
 *
 * Gateways are tried one by one until one of them returns a single-node
 * document whose `@id`, if any, canonically matches the requested IRI and
-* which passes `verifyPortableObject`.  When there is no gateway to try, the document
-* loader is asked for the portable IRI itself, and its result is validated
-* the same way.
+* which passes `verifyPortableObject`.  When there is no gateway to try, the
+* document loader is asked for the portable IRI itself, and its result is
+* validated the same way.  If the `response` option is given, only that
+* document is validated, and nothing is fetched.
 *
 * @returns The parsed object, or `null` if no valid object was retrieved and
 *          `suppressError` is set or the failure was a rejected object
@@ -176,4 +316,4 @@ declare function dereferencePortableIri<T extends {
   id: URL | null;
 }>(url: URL, options: DereferencePortableIriOptions<T>): Promise<T | null>;
 //#endregion
-export { DereferencePortableIriOptions, PortableObjectRejectedError, PortableReferrerLink, copyPortableProvenance, dereferencePortableIri, getPortableGatewayCandidates, isCompatibleEf61Iri, isInPortableChain, isPortableIri, isUnsecuredPortableObject, recordPortableReferrer, rejectPortableChainReference, warnUnverifiableEmbeddedObject };
+export { DereferencePortableIriOptions, PortableObjectRejectedError, PortableReferrerLink, PortableResponseClaim, copyPortableProvenance, createSnapshotContextLoader, dereferencePortableIri, getPortableGatewayCandidates, getPortableResponseClaim, isCompatibleEf61Iri, isInPortableChain, isPortableIri, isPortableMode, isUnsecuredPortableObject, isUnverifiedPortableClaim, markUnverifiedPortableClaim, mustDereferencePortableObject, parseCompatibleEf61Reference, recordPortableReferrer, rejectMalformedCompatibleReference, warnUnverifiableEmbeddedObject };

package/dist/internal/portable-dereference.js

@@ -1,6 +1,6 @@
 
 import { t as preloadedContexts } from "../contexts-DoZUIW7y.js";
-import { a as formatIri, g as toCompatibleEf61Id, m as parseIri, o as fromCompatibleEf61Id, r as canonicalizePortableUri } from "../url-CEhi4hb4.js";
+import { a as formatIri, c as haveSameFe34Origin, g as toCompatibleEf61Id, m as parseIri, o as fromCompatibleEf61Id, r as canonicalizePortableUri } from "../url-CEhi4hb4.js";
 import jsonld_default from "../jsonld.js";
 import { getLogger } from "@logtape/logtape";
 import { SpanStatusCode } from "@opentelemetry/api";
@@ -117,24 +117,169 @@ function copyPortableProvenance(from, to) {
 	});
 }
 /**
-* Rejects a reference from a portable object that would be dereferenced as
-* an ordinary HTTP(S) object although it stands for a portable object, i.e.,
-* an FEP-ef61 compatible identifier, or a document whose final URL or `@id`
-* is a compatible identifier or a portable IRI.  Such a document would skip
-* the portable object policy, so it is rejected regardless of the
-* `crossOrigin` option, except that `crossOrigin: "throw"` makes it throw.
+* Recognizes an FEP-ef61 compatible identifier to dereference as a portable
+* object.
+*
+* @returns `undefined` if the URL is not a compatible identifier; `null` if
+*          it is a malformed compatible identifier; otherwise, the portable
+*          ID it stands for and the gateway it names.
+* @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 parseCompatibleEf61Reference(url) {
+	if (typeof url === "string") {
+		if (!URL.canParse(url)) return void 0;
+		url = new URL(url);
+	}
+	try {
+		const id = fromCompatibleEf61Id(url);
+		if (id == null) return void 0;
+		return {
+			id,
+			gateway: new URL(url.origin)
+		};
+	} catch (error) {
+		if (error instanceof TypeError) {
+			logger.debug("Invalid FEP-ef61 compatible identifier {url}: {error}", {
+				url: url.href,
+				error
+			});
+			return null;
+		}
+		throw error;
+	}
+}
+/**
+* Checks whether a property accessor call on a vocabulary object applies the
+* FEP-ef61 portable object policy, i.e., whether the `verifyPortableObject`
+* option is given or the object is part of a chain of portable objects.
+* In this mode, compatible identifiers are dereferenced as portable objects,
+* and fetched documents that turn out to stand for portable objects are
+* verified as such.
+*
+* @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 isPortableMode(object, options) {
+	return options.verifyPortableObject != null || isInPortableChain(object);
+}
+/**
+* Checks whether an object embedded in a property of a vocabulary object has
+* to be dereferenced by its `@id` and verified as a portable object rather
+* than trusted as embedded, even with `crossOrigin: "trust"`.  This is the
+* case in {@link isPortableMode | portable mode} if its `@id` is an FEP-ef61
+* compatible identifier, or a portable IRI whose DID differs from the
+* owner's portable ID.
+*
+* @param parent The object whose property embeds the object.
+* @param ownerId The ID of the object that vouches for embedded objects, or
+*                `null` if embedded objects are not trusted by their owner.
+* @param id The `@id` of the embedded object.
+* @param options The options of the accessor.
+* @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 mustDereferencePortableObject(parent, ownerId, id, options) {
+	if (!isPortableMode(parent, options)) return false;
+	if (isCompatibleEf61Iri(id)) return true;
+	if (!isPortableIri(id)) return false;
+	return ownerId == null || !isPortableIri(ownerId) || !haveSameFe34Origin(ownerId, id);
+}
+const PORTABLE_IRI_PATTERN = /^ap(?:\+ef61)?:/i;
+/**
+* Finds out whether a document fetched as an ordinary HTTP(S) document
+* claims to be a portable object: its final URL is a portable IRI or an
+* FEP-ef61 compatible identifier, or else its `@id` is.  The final URL takes
+* precedence, so a document whose `@id` claims another object fails the
+* identity check against the final URL.
+*
+* @param documentUrl The final URL of the document.
+* @param objectId The `@id` of the parsed document.
+* @returns `undefined` if the document does not claim to be a portable
+*          object; `null` if the claim is malformed; otherwise, the claim.
+* @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 getPortableResponseClaim(documentUrl, objectId) {
+	if (PORTABLE_IRI_PATTERN.test(documentUrl)) {
+		let id;
+		try {
+			id = parseIri(documentUrl);
+			if (canonicalizePortableUri(documentUrl) !== canonicalizePortableUri(formatIri(id))) return null;
+		} catch (error) {
+			if (error instanceof TypeError) return null;
+			throw error;
+		}
+		return {
+			id,
+			inferredGateways: getPortableGatewayCandidates(id)
+		};
+	}
+	for (const url of [documentUrl, objectId]) {
+		if (url == null) continue;
+		const compatible = parseCompatibleEf61Reference(url);
+		if (compatible === null) return null;
+		if (compatible != null) return {
+			id: compatible.id,
+			inferredGateways: [compatible.gateway]
+		};
+		if (url instanceof URL && isPortableIri(url)) return {
+			id: url,
+			inferredGateways: getPortableGatewayCandidates(url)
+		};
+	}
+}
+const unverifiedPortableClaims = /* @__PURE__ */ new WeakSet();
+/**
+* Records that an object fetched as an ordinary HTTP(S) object stands for
+* a portable object if its reference, its final URL, or its `@id` is
+* a portable IRI or an FEP-ef61 compatible identifier.  Accessors do not
+* cache such objects in their parents, so that a later call with the
+* `verifyPortableObject` option dereferences and verifies them.
+*
+* @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 markUnverifiedPortableClaim(object, reference, documentUrl) {
+	const objectId = getObjectId(object);
+	if (isPortableIri(reference) || isCompatibleEf61Iri(reference) || PORTABLE_IRI_PATTERN.test(documentUrl) || isCompatibleEf61Iri(documentUrl) || objectId != null && (isPortableIri(objectId) || isCompatibleEf61Iri(objectId))) unverifiedPortableClaims.add(object);
+}
+/**
+* Checks whether an object was fetched as an ordinary HTTP(S) object although
+* it stands for a portable object.  See {@link markUnverifiedPortableClaim}.
+*
+* @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 isUnverifiedPortableClaim(object) {
+	return unverifiedPortableClaims.has(object);
+}
+/**
+* Rejects a malformed FEP-ef61 compatible identifier found in a reference,
+* the final URL of a fetched document, or its `@id`, when it would be
+* dereferenced as a portable object.  It is rejected without a request (or
+* without returning the fetched document), since it cannot be verified as
+* a portable object, and fetching it as an ordinary HTTP(S) object would
+* skip the portable object policy.
 *
 * @param url The rejected URL, for the log message.
-* @param crossOrigin The `crossOrigin` option of the accessor.
+* @param options The options of the accessor.
 * @returns Always `null`.
-* @throws {Error} If `crossOrigin` is `"throw"`.
+* @throws {Error} If `crossOrigin` is `"throw"` and `suppressError` is not
+*                 set.
 * @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 rejectPortableChainReference(url, crossOrigin) {
-	const message = "Refusing to dereference {url} from a portable object as an ordinary HTTP(S) object, because it stands for an FEP-ef61 portable object that is not verified this way.";
-	if (crossOrigin === "throw") throw new Error(message.replace("{url}", url));
+function rejectMalformedCompatibleReference(url, options) {
+	const message = "Refusing to dereference {url}, because it is a malformed FEP-ef61 compatible identifier, which cannot be verified as a portable object.";
+	if (options.crossOrigin === "throw" && !options.suppressError) throw new PortableObjectRejectedError(message.replace("{url}", url));
 	logger.warn(message, { url });
 	return null;
 }
@@ -242,12 +387,18 @@ function parseGatewayOrigin(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) {
+	for (let wrapped = snapshotLoaders.get(contextLoader); wrapped?.released; wrapped = snapshotLoaders.get(contextLoader)) contextLoader = wrapped.base;
 	const cache = /* @__PURE__ */ new Map();
 	let released = false;
 	const release = () => {
 		released = true;
+		state.released = true;
 		cache.clear();
 	};
 	const loader = async (url, options) => {
@@ -269,11 +420,17 @@ function createSnapshotContextLoader(contextLoader) {
 		}
 		return structuredClone(await promise);
 	};
+	const state = {
+		base: contextLoader,
+		released: false
+	};
+	snapshotLoaders.set(loader, state);
 	return {
 		loader,
 		release
 	};
 }
+const snapshotLoaders = /* @__PURE__ */ new WeakMap();
 /**
 * The error thrown by {@link dereferencePortableIri} under
 * `crossOrigin: "throw"` when gateways returned objects but none of them
@@ -300,9 +457,10 @@ var PortableObjectRejection = class {
 *
 * Gateways are tried one by one until one of them returns a single-node
 * document whose `@id`, if any, canonically matches the requested IRI and
-* which passes `verifyPortableObject`.  When there is no gateway to try, the document
-* loader is asked for the portable IRI itself, and its result is validated
-* the same way.
+* which passes `verifyPortableObject`.  When there is no gateway to try, the
+* document loader is asked for the portable IRI itself, and its result is
+* validated the same way.  If the `response` option is given, only that
+* document is validated, and nothing is fetched.
 *
 * @returns The parsed object, or `null` if no valid object was retrieved and
 *          `suppressError` is set or the failure was a rejected object
@@ -318,7 +476,10 @@ async function dereferencePortableIri(url, options) {
 	url = parseIri(url);
 	const lookupUrl = formatIri(url);
 	const { span } = options;
-	const gateways = getPortableGatewayCandidates(url, options.gateways);
+	const explicitGateways = options.gateways == null ? void 0 : getPortableGatewayCandidates(url, options.gateways);
+	const inferredGateways = options.inferredGateways ?? (explicitGateways == null ? getPortableGatewayCandidates(url) : []);
+	const gateways = [...inferredGateways];
+	for (const gateway of explicitGateways ?? []) if (!gateways.some((g) => g.href === gateway.href)) gateways.push(gateway);
 	const fail = (error) => {
 		span?.setStatus({
 			code: SpanStatusCode.ERROR,
@@ -339,7 +500,12 @@ async function dereferencePortableIri(url, options) {
 	let expectedId;
 	try {
 		expectedId = canonicalizePortableUri(lookupUrl);
-		for (const gateway of gateways) requestUrls.push({
+		if (options.response != null) requestUrls.push({
+			url: options.response.documentUrl,
+			gateway: null,
+			response: options.response
+		});
+		else for (const gateway of gateways) requestUrls.push({
 			url: toCompatibleEf61Id(url, gateway).href,
 			gateway
 		});
@@ -354,15 +520,14 @@ async function dereferencePortableIri(url, options) {
 	const contextLoader = snapshot.loader;
 	const attempts = [];
 	const { signal } = options;
-	const explicitGateways = options.gateways == null ? void 0 : gateways;
-	const gatewayHints = options.gateways == null && gateways.length > 0 ? gateways : void 0;
+	const gatewayHints = explicitGateways == null && inferredGateways.length > 0 ? inferredGateways : void 0;
 	const referrer = buildReferrerChain(options.referrer);
 	try {
-		for (const { url: requestUrl, gateway } of requestUrls) {
+		for (const { url: requestUrl, gateway, response } of requestUrls) {
 			signal?.throwIfAborted();
 			let remoteDocument;
 			try {
-				remoteDocument = await options.documentLoader(requestUrl, signal == null ? void 0 : { signal });
+				remoteDocument = response ?? await options.documentLoader(requestUrl, signal == null ? void 0 : { signal });
 			} catch (error) {
 				signal?.throwIfAborted();
 				logger.debug("Failed to fetch {url} from {requestUrl}: {error}", {
@@ -476,4 +641,4 @@ async function checkPortableObjectId(document, expectedId, contextLoader) {
 	if (actualId !== expectedId) throw new PortableObjectRejection("its @id ({objectId}) does not match the requested portable ID", { objectId: id });
 }
 //#endregion
-export { PortableObjectRejectedError, copyPortableProvenance, dereferencePortableIri, getPortableGatewayCandidates, isCompatibleEf61Iri, isInPortableChain, isPortableIri, isUnsecuredPortableObject, recordPortableReferrer, rejectPortableChainReference, warnUnverifiableEmbeddedObject };
+export { PortableObjectRejectedError, copyPortableProvenance, createSnapshotContextLoader, dereferencePortableIri, getPortableGatewayCandidates, getPortableResponseClaim, isCompatibleEf61Iri, isInPortableChain, isPortableIri, isPortableMode, isUnsecuredPortableObject, isUnverifiedPortableClaim, markUnverifiedPortableClaim, mustDereferencePortableObject, parseCompatibleEf61Reference, recordPortableReferrer, rejectMalformedCompatibleReference, warnUnverifiableEmbeddedObject };

package/dist/mod.cjs

@@ -16,7 +16,7 @@ let _multiformats_base_x = require("@multiformats/base-x");
 _multiformats_base_x = require_rolldown_runtime.__toESM(_multiformats_base_x, 1);
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.4.0-dev.2063+366c0362";
+var version = "2.4.0-dev.2065+b09fdd33";
 //#endregion
 //#region src/request.ts
 /**

package/dist/mod.d.cts

@@ -1,6 +1,6 @@
 /// <reference lib="esnext.temporal" />
 import { a as DocumentLoaderOptions, c as getDocumentLoader, d as FetchError, f as GetUserAgentOptions, h as logRequest, i as DocumentLoaderFactoryOptions, l as getRemoteDocument, m as getUserAgent, n as DocumentLoader, o as GetDocumentLoaderOptions, p as createActivityPubRequest, r as DocumentLoaderFactory, s as RemoteDocument, t as AuthenticatedDocumentLoaderFactory, u as CreateRequestOptions } from "./docloader-Dr8wEkif.cjs";
-import { i as PortableObjectVerifierOptions, n as PortableObjectVerification, r as PortableObjectVerifier, t as PortableObjectReferrer } from "./portable-BykOD45s.cjs";
+import { i as PortableObjectVerifierOptions, n as PortableObjectVerification, r as PortableObjectVerifier, t as PortableObjectReferrer } from "./portable-comBI05Y.cjs";
 import { TracerProvider } from "@opentelemetry/api";
 
 //#region src/contexts.d.ts

package/dist/mod.d.ts

@@ -1,6 +1,6 @@
 /// <reference lib="esnext.temporal" />
 import { a as DocumentLoaderOptions, c as getDocumentLoader, d as FetchError, f as GetUserAgentOptions, h as logRequest, i as DocumentLoaderFactoryOptions, l as getRemoteDocument, m as getUserAgent, n as DocumentLoader, o as GetDocumentLoaderOptions, p as createActivityPubRequest, r as DocumentLoaderFactory, s as RemoteDocument, t as AuthenticatedDocumentLoaderFactory, u as CreateRequestOptions } from "./docloader-Dr8wEkif.js";
-import { i as PortableObjectVerifierOptions, n as PortableObjectVerification, r as PortableObjectVerifier, t as PortableObjectReferrer } from "./portable--NcyA1R_.js";
+import { i as PortableObjectVerifierOptions, n as PortableObjectVerification, r as PortableObjectVerifier, t as PortableObjectReferrer } from "./portable-DH3947GK.js";
 import { TracerProvider } from "@opentelemetry/api";
 //#region src/contexts.d.ts
 declare const preloadedContexts: Record<string, unknown>;

package/dist/mod.js

@@ -12,7 +12,7 @@ import { PublicKeyInfo } from "pkijs";
 import baseX from "@multiformats/base-x";
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.4.0-dev.2063+366c0362";
+var version = "2.4.0-dev.2065+b09fdd33";
 //#endregion
 //#region src/request.ts
 /**

package/dist/{portable--NcyA1R_.d.ts → portable-DH3947GK.d.ts}

@@ -42,8 +42,12 @@ interface PortableObjectVerifierOptions {
   */
   readonly gateways?: readonly URL[];
   /**
-  * The gateways taken from the `@gateway` location hints of the reference,
-  * in order, when the caller did not pass the `gateways` option.
+  * The gateways inferred from the reference, in order, when the caller did
+  * not pass the `gateways` option: the `@gateway` location hints of
+  * a portable IRI, the gateway named by an FEP-ef61 compatible identifier,
+  * or the WebFinger server of a portable actor.  They only tell where the
+  * document and related objects might be retrieved, and must not be
+  * trusted to act for the portable object's DID.
   * @since 2.4.0
   */
   readonly gatewayHints?: readonly URL[];

package/dist/{portable-BykOD45s.d.cts → portable-comBI05Y.d.cts}

@@ -42,8 +42,12 @@ interface PortableObjectVerifierOptions {
   */
   readonly gateways?: readonly URL[];
   /**
-  * The gateways taken from the `@gateway` location hints of the reference,
-  * in order, when the caller did not pass the `gateways` option.
+  * The gateways inferred from the reference, in order, when the caller did
+  * not pass the `gateways` option: the `@gateway` location hints of
+  * a portable IRI, the gateway named by an FEP-ef61 compatible identifier,
+  * or the WebFinger server of a portable actor.  They only tell where the
+  * document and related objects might be retrieved, and must not be
+  * trusted to act for the portable object's DID.
   * @since 2.4.0
   */
   readonly gatewayHints?: readonly URL[];

package/dist/tests/{body-BN5x-zDQ.mjs → body-CNO0jMV8.mjs}

@@ -1,4 +1,4 @@
-import { t as FetchError } from "./request-BT9FBhk6.mjs";
+import { t as FetchError } from "./request-dpFdQKXr.mjs";
 import { getLogger } from "@logtape/logtape";
 //#region src/body.ts
 /** Decoded JSON body limit: 16 MiB.  @internal */

package/dist/tests/{body-CTGqQhNI.cjs → body-DXHOazEl.cjs}

@@ -1,4 +1,4 @@
-const require_request = require("./request-jWhPNG9V.cjs");
+const require_request = require("./request-BOLanqAd.cjs");
 let _logtape_logtape = require("@logtape/logtape");
 //#region src/body.ts
 /** Decoded JSON body limit: 16 MiB.  @internal */

package/dist/tests/body.test.cjs

@@ -1,4 +1,4 @@
-const require_body = require("./body-CTGqQhNI.cjs");
+const require_body = require("./body-DXHOazEl.cjs");
 let node_assert_strict = require("node:assert/strict");
 let node_test = require("node:test");
 let node_zlib = require("node:zlib");

package/dist/tests/body.test.mjs

@@ -1,4 +1,4 @@
-import { r as readBoundedText, t as BodyTooLargeError } from "./body-BN5x-zDQ.mjs";
+import { r as readBoundedText, t as BodyTooLargeError } from "./body-CNO0jMV8.mjs";
 import { deepStrictEqual, ok, rejects } from "node:assert/strict";
 import { test } from "node:test";
 import { gunzipSync, gzipSync } from "node:zlib";

package/dist/tests/decimal.test.cjs

@@ -1,5 +1,5 @@
 require("./url-BqlldzT8.cjs");
-require("./docloader-JGSpG-3l.cjs");
+require("./docloader-4Txefi7y.cjs");
 require("./key-8Qg2SbZi.cjs");
 require("./multibase-B5Mea7Ip.cjs");
 require("./digest-3FeH2Y-Q.cjs");

package/dist/tests/decimal.test.mjs

@@ -1,5 +1,5 @@
 import "./url-DgJM9WJn.mjs";
-import "./docloader-BFxwbqMx.mjs";
+import "./docloader-C-nWtUWo.mjs";
 import "./key-C7MNhlkO.mjs";
 import "./multibase-BPnF_L4e.mjs";
 import "./digest-COC7xDiQ.mjs";

package/dist/tests/{docloader-JGSpG-3l.cjs → docloader-4Txefi7y.cjs}

@@ -1,5 +1,5 @@
-const require_request = require("./request-jWhPNG9V.cjs");
-const require_body = require("./body-CTGqQhNI.cjs");
+const require_request = require("./request-BOLanqAd.cjs");
+const require_body = require("./body-DXHOazEl.cjs");
 const require_contexts = require("./contexts-Ch3v2Cgu.cjs");
 const require_link = require("./link-DlKm8bEr.cjs");
 const require_url = require("./url-BqlldzT8.cjs");

package/dist/tests/{docloader-BFxwbqMx.mjs → docloader-C-nWtUWo.mjs}

@@ -1,5 +1,5 @@
-import { a as name, i as logRequest, n as createActivityPubRequest, o as version, t as FetchError } from "./request-BT9FBhk6.mjs";
-import { n as MAX_BODY_SIZE, r as readBoundedText, t as BodyTooLargeError } from "./body-BN5x-zDQ.mjs";
+import { a as name, i as logRequest, n as createActivityPubRequest, o as version, t as FetchError } from "./request-dpFdQKXr.mjs";
+import { n as MAX_BODY_SIZE, r as readBoundedText, t as BodyTooLargeError } from "./body-CNO0jMV8.mjs";
 import { t as preloadedContexts } from "./contexts-BBX_qhBL.mjs";
 import { t as HttpHeaderLink } from "./link-Cevmc87v.mjs";
 import { t as UrlError, v as validatePublicUrl } from "./url-DgJM9WJn.mjs";

package/dist/tests/docloader.test.cjs

@@ -1,8 +1,8 @@
 const require_rolldown_runtime = require("./rolldown-runtime-emK7D4bc.cjs");
-const require_request = require("./request-jWhPNG9V.cjs");
+const require_request = require("./request-BOLanqAd.cjs");
 const require_contexts = require("./contexts-Ch3v2Cgu.cjs");
 const require_url = require("./url-BqlldzT8.cjs");
-const require_docloader = require("./docloader-JGSpG-3l.cjs");
+const require_docloader = require("./docloader-4Txefi7y.cjs");
 let node_test = require("node:test");
 let node_zlib = require("node:zlib");
 let node_assert = require("node:assert");