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

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, 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";
@@ -24,6 +24,301 @@ const BASELINE_CONTEXT_URLS = /* @__PURE__ */ new Set([
 	"https://w3id.org/security/data-integrity/v1"
 ]);
 /**
+* The maximum number of links in a referrer chain passed to a
+* {@link PortableObjectVerifier}.  Longer chains are cut off and marked as
+* truncated.
+*/
+const MAX_REFERRER_CHAIN_LENGTH = 32;
+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 or was obtained from a portable object.
+*
+* @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);
+}
+/**
+* Checks whether a vocabulary object was accepted without an integrity
+* proof, e.g., as an unsecured portable collection served by a trusted
+* gateway.  Objects embedded in such an object must not be trusted because
+* of their origin.
+*
+* @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 isUnsecuredPortableObject(object) {
+	return provenances.get(object)?.acceptance === "unsecured";
+}
+/**
+* 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 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
+	} });
+}
+/**
+* Copies the provenance of a vocabulary object to its clone.  The clone
+* keeps where the original came from and the restriction on unsecured
+* objects, but not a positive verification status nor a collection context,
+* since the clone may have different property values.
+*
+* @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 copyPortableProvenance(from, to) {
+	const provenance = provenances.get(from);
+	if (provenance == null) return;
+	provenances.set(to, {
+		referrer: provenance.referrer,
+		...provenance.acceptance === "unsecured" ? { acceptance: "unsecured" } : {}
+	});
+}
+/**
+* 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 options The options of the accessor.
+* @returns Always `null`.
+* @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 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;
+}
+/**
+* Logs that an embedded object without `@id` in an object accepted without
+* an integrity proof is dropped, because it cannot be dereferenced and
+* verified on its own.
+*
+* @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 warnUnverifiableEmbeddedObject(parent, property) {
+	logger.warn("Dropping an embedded object without @id in the {property} property of {parentId}, because the parent was accepted without an integrity proof and the embedded object cannot be verified on its own.", {
+		property,
+		parentId: getObjectId(parent)?.href ?? null
+	});
+}
+function buildReferrerChain(link, depth = 0) {
+	if (link == null) return void 0;
+	const provenance = provenances.get(link.object);
+	const base = {
+		object: link.object,
+		id: getObjectId(link.object),
+		property: link.property,
+		...provenance?.acceptance == null ? {} : { acceptance: provenance.acceptance },
+		...provenance?.collectionContext === void 0 ? {} : { collectionContext: provenance.collectionContext }
+	};
+	if (provenance?.referrer == null) return base;
+	if (depth + 1 >= MAX_REFERRER_CHAIN_LENGTH) return {
+		...base,
+		truncated: true
+	};
+	return {
+		...base,
+		referrer: buildReferrerChain(provenance.referrer, depth + 1)
+	};
+}
+/**
 * Checks whether a URL is an FEP-ef61 portable ActivityPub IRI.
 *
 * @internal Technically exported for generated vocabulary classes, but not
@@ -92,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) => {
@@ -119,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
@@ -150,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
@@ -168,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,
@@ -189,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
 		});
@@ -204,12 +520,14 @@ async function dereferencePortableIri(url, options) {
 	const contextLoader = snapshot.loader;
 	const attempts = [];
 	const { signal } = options;
+	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}", {
@@ -226,12 +544,22 @@ async function dereferencePortableIri(url, options) {
 			const { document } = remoteDocument;
 			try {
 				await checkPortableObjectId(document, expectedId, contextLoader);
+				let documentUrl;
+				try {
+					documentUrl = parseIri(remoteDocument.documentUrl);
+				} catch {
+					documentUrl = void 0;
+				}
 				let result;
 				try {
 					result = await verify(document, {
 						documentLoader: options.documentLoader,
 						contextLoader,
-						tracerProvider: options.tracerProvider
+						tracerProvider: options.tracerProvider,
+						...documentUrl == null ? {} : { documentUrl },
+						...explicitGateways == null ? {} : { gateways: explicitGateways },
+						...gatewayHints == null ? {} : { gatewayHints },
+						...referrer == null ? {} : { referrer }
 					});
 				} catch (error) {
 					throw new PortableObjectRejection("the proof verifier failed: {error}", { error });
@@ -242,6 +570,11 @@ async function dereferencePortableIri(url, options) {
 					baseUrl: url
 				});
 				signal?.throwIfAborted();
+				if (object != null && typeof object === "object") provenances.set(object, {
+					acceptance: result.unsecured === true ? "unsecured" : "verified",
+					...result.collectionContext === void 0 ? {} : { collectionContext: result.collectionContext },
+					...options.referrer == null ? {} : { referrer: options.referrer }
+				});
 				if (gateway != null) span?.setAttribute("activitypub.gateway", gateway.href);
 				return object;
 			} catch (error) {
@@ -308,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, dereferencePortableIri, getPortableGatewayCandidates, isPortableIri };
+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.2056+e6394f3b";
+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 { n as PortableObjectVerifierOptions, t as PortableObjectVerifier } from "./portable-DxF2Ut-Z.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
@@ -547,4 +547,4 @@ declare function isValidPublicIPv4Address(address: string): boolean;
 declare function isValidPublicIPv6Address(address: string): boolean;
 declare function expandIPv6Address(address: string): string;
 //#endregion
-export { type AuthenticatedDocumentLoaderFactory, type CreateRequestOptions, type Decimal, type DidKeyVerificationMethod, type DocumentLoader, type DocumentLoaderFactory, type DocumentLoaderFactoryOptions, type DocumentLoaderOptions, FetchError, type GetDocumentLoaderOptions, type GetUserAgentOptions, type Json, LanguageString, type ParsedDigestMultibase, type ParsedHashlink, type PortableObjectVerifier, type PortableObjectVerifierOptions, type PropertyPreprocessor, type PropertyPreprocessorContext, type RemoteDocument, UrlError, arePortableUrisEqual, canParseDecimal, canonicalizePortableUri, computeDigestMultibase, createActivityPubRequest, createHashlink, decodeMultibase, encodeMultibase, encodingFromBaseData, expandIPv6Address, exportDidKey, exportMultibaseKey, exportSpki, formatIri, fromCompatibleEf61Id, getDocumentLoader, getFe34Origin, getRemoteDocument, getUserAgent, haveSameFe34Origin, haveSameIriOrigin, importDidKey, importMultibaseKey, importPem, importPkcs1, importSpki, isDecimal, isGatewayUrl, isValidPublicIPv4Address, isValidPublicIPv6Address, logRequest, parseDecimal, parseDidKeyVerificationMethod, parseDigestMultibase, parseGatewayUrl, parseHashlink, parseIri, parseJsonLdId, preloadedContexts, toCompatibleEf61Id, validatePublicUrl, verifyDigestMultibase, verifyHashlink };
+export { type AuthenticatedDocumentLoaderFactory, type CreateRequestOptions, type Decimal, type DidKeyVerificationMethod, type DocumentLoader, type DocumentLoaderFactory, type DocumentLoaderFactoryOptions, type DocumentLoaderOptions, FetchError, type GetDocumentLoaderOptions, type GetUserAgentOptions, type Json, LanguageString, type ParsedDigestMultibase, type ParsedHashlink, type PortableObjectReferrer, type PortableObjectVerification, type PortableObjectVerifier, type PortableObjectVerifierOptions, type PropertyPreprocessor, type PropertyPreprocessorContext, type RemoteDocument, UrlError, arePortableUrisEqual, canParseDecimal, canonicalizePortableUri, computeDigestMultibase, createActivityPubRequest, createHashlink, decodeMultibase, encodeMultibase, encodingFromBaseData, expandIPv6Address, exportDidKey, exportMultibaseKey, exportSpki, formatIri, fromCompatibleEf61Id, getDocumentLoader, getFe34Origin, getRemoteDocument, getUserAgent, haveSameFe34Origin, haveSameIriOrigin, importDidKey, importMultibaseKey, importPem, importPkcs1, importSpki, isDecimal, isGatewayUrl, isValidPublicIPv4Address, isValidPublicIPv6Address, logRequest, parseDecimal, parseDidKeyVerificationMethod, parseDigestMultibase, parseGatewayUrl, parseHashlink, parseIri, parseJsonLdId, preloadedContexts, toCompatibleEf61Id, validatePublicUrl, verifyDigestMultibase, verifyHashlink };

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 { n as PortableObjectVerifierOptions, t as PortableObjectVerifier } from "./portable-CduElToy.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>;
@@ -546,4 +546,4 @@ declare function isValidPublicIPv4Address(address: string): boolean;
 declare function isValidPublicIPv6Address(address: string): boolean;
 declare function expandIPv6Address(address: string): string;
 //#endregion
-export { type AuthenticatedDocumentLoaderFactory, type CreateRequestOptions, type Decimal, type DidKeyVerificationMethod, type DocumentLoader, type DocumentLoaderFactory, type DocumentLoaderFactoryOptions, type DocumentLoaderOptions, FetchError, type GetDocumentLoaderOptions, type GetUserAgentOptions, type Json, LanguageString, type ParsedDigestMultibase, type ParsedHashlink, type PortableObjectVerifier, type PortableObjectVerifierOptions, type PropertyPreprocessor, type PropertyPreprocessorContext, type RemoteDocument, UrlError, arePortableUrisEqual, canParseDecimal, canonicalizePortableUri, computeDigestMultibase, createActivityPubRequest, createHashlink, decodeMultibase, encodeMultibase, encodingFromBaseData, expandIPv6Address, exportDidKey, exportMultibaseKey, exportSpki, formatIri, fromCompatibleEf61Id, getDocumentLoader, getFe34Origin, getRemoteDocument, getUserAgent, haveSameFe34Origin, haveSameIriOrigin, importDidKey, importMultibaseKey, importPem, importPkcs1, importSpki, isDecimal, isGatewayUrl, isValidPublicIPv4Address, isValidPublicIPv6Address, logRequest, parseDecimal, parseDidKeyVerificationMethod, parseDigestMultibase, parseGatewayUrl, parseHashlink, parseIri, parseJsonLdId, preloadedContexts, toCompatibleEf61Id, validatePublicUrl, verifyDigestMultibase, verifyHashlink };
+export { type AuthenticatedDocumentLoaderFactory, type CreateRequestOptions, type Decimal, type DidKeyVerificationMethod, type DocumentLoader, type DocumentLoaderFactory, type DocumentLoaderFactoryOptions, type DocumentLoaderOptions, FetchError, type GetDocumentLoaderOptions, type GetUserAgentOptions, type Json, LanguageString, type ParsedDigestMultibase, type ParsedHashlink, type PortableObjectReferrer, type PortableObjectVerification, type PortableObjectVerifier, type PortableObjectVerifierOptions, type PropertyPreprocessor, type PropertyPreprocessorContext, type RemoteDocument, UrlError, arePortableUrisEqual, canParseDecimal, canonicalizePortableUri, computeDigestMultibase, createActivityPubRequest, createHashlink, decodeMultibase, encodeMultibase, encodingFromBaseData, expandIPv6Address, exportDidKey, exportMultibaseKey, exportSpki, formatIri, fromCompatibleEf61Id, getDocumentLoader, getFe34Origin, getRemoteDocument, getUserAgent, haveSameFe34Origin, haveSameIriOrigin, importDidKey, importMultibaseKey, importPem, importPkcs1, importSpki, isDecimal, isGatewayUrl, isValidPublicIPv4Address, isValidPublicIPv6Address, logRequest, parseDecimal, parseDidKeyVerificationMethod, parseDigestMultibase, parseGatewayUrl, parseHashlink, parseIri, parseJsonLdId, preloadedContexts, toCompatibleEf61Id, validatePublicUrl, verifyDigestMultibase, verifyHashlink };

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.2056+e6394f3b";
+var version = "2.4.0-dev.2065+b09fdd33";
 //#endregion
 //#region src/request.ts
 /**

package/dist/portable-DH3947GK.d.ts

@@ -0,0 +1,160 @@
+/// <reference lib="esnext.temporal" />
+import { n as DocumentLoader } from "./docloader-Dr8wEkif.js";
+import { TracerProvider } from "@opentelemetry/api";
+
+//#region src/portable.d.ts
+/**
+* Options passed to a {@link PortableObjectVerifier}.
+* @since 2.4.0
+*/
+interface PortableObjectVerifierOptions {
+  /**
+  * The document loader for fetching remote documents, such as verification
+  * methods that are not `did:key` URLs.
+  */
+  readonly documentLoader?: DocumentLoader;
+  /**
+  * The document loader for fetching remote JSON-LD contexts.  During
+  * gateway dereferencing, this loader returns the same context documents
+  * that the vocabulary parser sees.
+  */
+  readonly contextLoader?: DocumentLoader;
+  /**
+  * The OpenTelemetry tracer provider.
+  */
+  readonly tracerProvider?: TracerProvider;
+  /**
+  * The URL the document was finally retrieved from, i.e., the `documentUrl`
+  * of the document loader's result, which may differ from the requested URL
+  * after redirects.  Trust decisions such as the [FEP-ef61] gateway trust
+  * policy for unsecured collections depend on it, so custom document loaders
+  * must report it truthfully.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  * @since 2.4.0
+  */
+  readonly documentUrl?: URL;
+  /**
+  * The gateways that the caller explicitly passed to the accessor through
+  * its `gateways` option, in order.  It is `undefined` if the caller did not
+  * pass the option, and can be empty.
+  * @since 2.4.0
+  */
+  readonly gateways?: readonly URL[];
+  /**
+  * 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[];
+  /**
+  * The object whose property referred to the document, if the document was
+  * dereferenced through a property accessor.
+  * @since 2.4.0
+  */
+  readonly referrer?: PortableObjectReferrer;
+}
+/**
+* An object whose property referred to a portable object being verified.
+* Referrers form a chain: {@link PortableObjectReferrer.referrer} is the
+* object through which this referrer itself was obtained, and so on.
+* @since 2.4.0
+*/
+interface PortableObjectReferrer {
+  /**
+  * The referring vocabulary object.
+  */
+  readonly object: unknown;
+  /**
+  * The `@id` of the referring object, if any.
+  */
+  readonly id: URL | null;
+  /**
+  * The expanded URI of the property through which the referring object
+  * referred to the next object in the chain, e.g.,
+  * `https://www.w3.org/ns/activitystreams#outbox`.
+  */
+  readonly property: string;
+  /**
+  * How the referring object itself was accepted by a
+  * {@link PortableObjectVerifier} when it was dereferenced through gateways:
+  *
+  * - `"verified"`: accepted as verified, e.g., with a valid integrity proof.
+  * - `"unsecured"`: accepted without an integrity proof, e.g., as an
+  *   unsecured collection served by a trusted gateway.
+  *
+  * It is `undefined` if the referring object was not dereferenced through
+  * gateways, e.g., if it was embedded in another object or constructed by
+  * the application.
+  */
+  readonly acceptance?: "verified" | "unsecured";
+  /**
+  * The opaque collection context that a {@link PortableObjectVerifier}
+  * attached to the referring object when it accepted it.  See
+  * {@link PortableObjectVerification}.
+  */
+  readonly collectionContext?: unknown;
+  /**
+  * The referrer of the referring object, if any.
+  */
+  readonly referrer?: PortableObjectReferrer;
+  /**
+  * Whether the chain was cut off here because it was too long.  If `true`,
+  * the referring object may have a referrer which is not included.
+  */
+  readonly truncated?: boolean;
+}
+/**
+* The result of a {@link PortableObjectVerifier}.
+* @since 2.4.0
+*/
+type PortableObjectVerification = {
+  /** Whether the document is accepted. */readonly verified: false;
+} | {
+  /** Whether the document is accepted. */readonly verified: true;
+  /**
+  * Whether the document was accepted without an integrity proof, e.g., as
+  * an unsecured [FEP-ef61] collection served by a gateway that its owner
+  * lists.  Objects embedded in such a document are not trusted because of
+  * their origin; property accessors dereference and verify them one by
+  * one instead.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  */
+  readonly unsecured?: boolean;
+  /**
+  * An opaque value that the verifier wants to receive again as
+  * {@link PortableObjectReferrer.collectionContext} when objects referred
+  * to by this document, such as collection pages, are verified.
+  */
+  readonly collectionContext?: unknown;
+};
+/**
+* A function that applies the [FEP-ef61] trust policy to a portable object
+* fetched through a gateway.
+*
+* It receives the fetched JSON-LD document as is, and resolves to an object
+* whose `verified` property tells whether the document is acceptable, e.g.,
+* whether it carries a valid [FEP-8b32] Object Integrity Proof made by the
+* DID in its portable ID.  `verifyPortableObject()` and
+* `verifyPortableObjectProof()` from `@fedify/fedify` satisfy this type, so
+* they can be passed as the `verifyPortableObject` option of generated
+* vocabulary accessors such as `Activity.getObject()`.
+*
+* [FEP-ef61]: https://w3id.org/fep/ef61
+* [FEP-8b32]: https://w3id.org/fep/8b32
+*
+* @param document The fetched JSON-LD document.
+* @param options Loaders, tracing options, and where the document came from.
+* @returns An object whose `verified` property is `true` if and only if the
+*          document satisfies the policy.  Other properties, such as
+*          a failure reason, are logged when verification fails.
+* @since 2.4.0
+*/
+type PortableObjectVerifier = (document: unknown, options: PortableObjectVerifierOptions) => Promise<PortableObjectVerification>;
+//#endregion
+export { PortableObjectVerifierOptions as i, PortableObjectVerification as n, PortableObjectVerifier as r, PortableObjectReferrer as t };