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

package/dist/{docloader-D2DTRiyA.d.cts → docloader-CYwqh5Df.d.ts}

@@ -100,6 +100,13 @@ interface DocumentLoaderOptions {
   * @since 1.8.0
   */
   signal?: AbortSignal;
+  /**
+  * Whether to lower error-level logs for recoverable document loading
+  * failures to warning-level logs.  The loader still throws the error.
+  * @default `false`
+  * @since 2.4.0
+  */
+  suppressError?: boolean;
 }
 /**
 * A JSON-LD document loader that fetches documents from the Web.
@@ -140,6 +147,28 @@ interface DocumentLoaderFactoryOptions {
   * @since 2.2.0
   */
   maxRedirection?: number;
+  /**
+  * The timeout in milliseconds for each call of the created document
+  * loader.  The timeout is shared by all the steps of a call, including
+  * URL validation, every HTTP redirect and alternate document link it
+  * follows, retries, and reading the response body; it does not restart
+  * for each of them.  It does not interrupt synchronous work such as
+  * parsing a document that has already been received.
+  *
+  * When a call times out, the loader throws a {@link FetchError} without
+  * a {@link FetchError.response}, whose `cause` is a `DOMException` named
+  * `"TimeoutError"`.  An `AbortSignal` passed through
+  * {@link DocumentLoaderOptions.signal} still cancels a call; in that case
+  * the loader throws the signal's reason as before.
+  *
+  * Fractional values are rounded up.  Set it to `null` to turn off the
+  * timeout.
+  * @default `10000` (10 seconds)
+  * @throws {RangeError} If the value is not a positive finite number or is
+  *                      greater than 2,147,483,647 (about 24.8 days).
+  * @since 2.4.0
+  */
+  timeout?: number | null;
 }
 /**
 * A factory function that creates an authenticated {@link DocumentLoader} for
@@ -160,11 +189,39 @@ type AuthenticatedDocumentLoaderFactory = (identity: {
 * @param url The URL of the document to load.
 * @param response The response to get the document from.
 * @param fetch The function to fetch the document.
+* @param options The options for loading the document.
 * @returns The loaded remote document.
 * @throws {FetchError} If the response is not OK.
 * @internal
 */
-declare function getRemoteDocument(url: string, response: Response, fetch: (url: string, options?: DocumentLoaderOptions) => Promise<RemoteDocument>): Promise<RemoteDocument>;
+declare function getRemoteDocument(url: string, response: Response, fetch: (url: string, options?: DocumentLoaderOptions) => Promise<RemoteDocument>, options?: DocumentLoaderOptions): Promise<RemoteDocument>;
+/**
+* Resolves {@link DocumentLoaderFactoryOptions.timeout} into milliseconds.
+* @param timeout The timeout option.  `undefined` means the default timeout,
+*                and `null` means no timeout.
+* @returns The timeout in milliseconds, or `null` if it is turned off.
+* @throws {RangeError} If the timeout is invalid.
+* @internal
+*/
+declare function resolveDocumentLoaderTimeout(timeout: number | null | undefined): number | null;
+/**
+* Bounds each call of the given document loader by the given timeout.
+* The timeout is combined with the caller's `signal`, and the combined
+* signal is passed to the loader.  The call settles no later than the
+* timeout even if the loader is stuck in a step that cannot be aborted,
+* e.g., a DNS lookup.
+*
+* A timed-out call throws a {@link FetchError} without a response, whose
+* `cause` is a `DOMException` named `"TimeoutError"`.  If the caller's
+* signal is aborted, its reason is thrown instead.
+* @param loader The document loader to bound.
+* @param timeout The timeout in milliseconds, or `null` for no timeout.
+*                It is assumed to have been resolved by
+*                {@link resolveDocumentLoaderTimeout}.
+* @returns The bounded document loader.
+* @internal
+*/
+declare function withDocumentLoaderTimeout(loader: DocumentLoader, timeout: number | null): DocumentLoader;
 /**
 * Options for {@link getDocumentLoader}.
 * @since 1.3.0
@@ -177,6 +234,10 @@ interface GetDocumentLoaderOptions extends DocumentLoaderFactoryOptions {
 }
 /**
 * Creates a JSON-LD document loader that utilizes the browser's `fetch` API.
+* At most 20 HTTP redirects and alternate document links are followed in total
+* per call.  Revisiting a URL within that chain throws a {@link FetchError}.
+* Each call times out after 10 seconds by default; see
+* {@link DocumentLoaderFactoryOptions.timeout}.
 *
 * The created loader preloads the below frequently used contexts by default
 * (unless `options.skipPreloadedContexts` is set to `true`):
@@ -186,8 +247,10 @@ interface GetDocumentLoaderOptions extends DocumentLoaderFactoryOptions {
 * - <https://w3id.org/security/data-integrity/v1>
 * - <https://w3id.org/security/data-integrity/v2>
 * - <https://www.w3.org/ns/did/v1>
+* - <https://www.w3.org/ns/cid/v1>
 * - <https://w3id.org/security/multikey/v1>
 * - <https://w3id.org/fep/ef61>
+* - <https://w3id.org/fep/7aa9>
 * - <https://purl.archive.org/socialweb/webfinger>
 * - <http://schema.org/>
 * @param options Options for the document loader.
@@ -198,7 +261,8 @@ declare function getDocumentLoader({
   allowPrivateAddress,
   maxRedirection,
   skipPreloadedContexts,
+  timeout,
   userAgent
 }?: GetDocumentLoaderOptions): DocumentLoader;
 //#endregion
-export { DocumentLoaderOptions as a, getDocumentLoader as c, FetchError as d, GetUserAgentOptions as f, logRequest as h, DocumentLoaderFactoryOptions as i, getRemoteDocument as l, getUserAgent as m, DocumentLoader as n, GetDocumentLoaderOptions as o, createActivityPubRequest as p, DocumentLoaderFactory as r, RemoteDocument as s, AuthenticatedDocumentLoaderFactory as t, CreateRequestOptions as u };
+export { logRequest as _, DocumentLoaderOptions as a, getDocumentLoader as c, withDocumentLoaderTimeout as d, CreateRequestOptions as f, getUserAgent as g, createActivityPubRequest as h, DocumentLoaderFactoryOptions as i, getRemoteDocument as l, GetUserAgentOptions as m, DocumentLoader as n, GetDocumentLoaderOptions as o, FetchError as p, DocumentLoaderFactory as r, RemoteDocument as s, AuthenticatedDocumentLoaderFactory as t, resolveDocumentLoaderTimeout as u };

package/dist/internal/jsonld-cache.cjs

@@ -1,9 +1,74 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_url = require("../url-DD4F0ULf.cjs");
+const require_url = require("../url-DrGTR8yv.cjs");
 const require_jsonld = require("../jsonld.cjs");
 //#region src/internal/jsonld-cache.ts
+/**
+* Reads expanded gateways, including an unmapped term on portable actors.
+* The original values and their order are preserved for URL validation by
+* the caller.  An explicitly mapped FEP-ef61 property always takes precedence.
+* @internal Used by generated vocabulary classes and portable proof checks.
+*/
+function getPortableActorGateways(node, allowUnmapped = true) {
+	const property = "https://w3id.org/fep/ef61/gateways";
+	if (globalThis.Object.hasOwn(node, property)) return Array.isArray(node[property]) ? node[property] : void 0;
+	if (!allowUnmapped || typeof node["@id"] !== "string" || !("http://www.w3.org/ns/ldp#inbox" in node) || !("https://www.w3.org/ns/activitystreams#outbox" in node)) return void 0;
+	try {
+		if (!require_url.getFe34Origin(require_url.parseIri(require_url.fromCompatibleEf61Id(node["@id"]) ?? node["@id"])).startsWith("did:")) return void 0;
+	} catch (error) {
+		if (error instanceof TypeError) return void 0;
+		throw error;
+	}
+	return Array.isArray(node["_:gateways"]) ? node["_:gateways"] : void 0;
+}
 const noJsonLdContext = Symbol("noJsonLdContext");
+const documentLoaderWrappers = /* @__PURE__ */ new WeakMap();
+/**
+* Registers a loader wrapper with the shared released-wrapper registry.
+* Both suppression and snapshot wrappers must use this registry so mixed
+* chains can be unwrapped.  The caller updates the state on release.
+* @internal Not a public API.
+*/
+function registerDocumentLoaderWrapper(loader, state) {
+	documentLoaderWrappers.set(loader, state);
+}
+/**
+* Removes released loader wrappers, stopping at the first active wrapper.
+* Active wrappers retain their operation's suppression or snapshot cache.
+* @internal Not a public API.
+*/
+function unwrapReleasedDocumentLoader(base) {
+	for (let state = documentLoaderWrappers.get(base); state?.released; state = documentLoaderWrappers.get(base)) base = state.base;
+	return base;
+}
+/**
+* Lowers context loading failure logs for one accessor operation.  Parsed
+* objects retain the loader, so release it before returning to the caller.
+* Released wrappers are unwrapped to avoid accumulating loader chains.
+* @internal Used by generated vocabulary accessors; not a public API.
+*/
+function createScopedContextLoader(base, suppressError) {
+	base = unwrapReleasedDocumentLoader(base);
+	if (!suppressError) return {
+		loader: base,
+		release: () => {}
+	};
+	const state = {
+		base,
+		released: false
+	};
+	const loader = (url, options) => base(url, state.released ? options : {
+		...options,
+		suppressError: true
+	});
+	registerDocumentLoaderWrapper(loader, state);
+	return {
+		loader,
+		release: () => {
+			state.released = true;
+		}
+	};
+}
 /**
 * Checks whether an IRI is trusted relative to another IRI.
 *
@@ -274,6 +339,10 @@ function combineContexts(inheritedContext, ownContext) {
 }
 //#endregion
 exports.compactJsonLdCache = compactJsonLdCache;
+exports.createScopedContextLoader = createScopedContextLoader;
 exports.getJsonLdContext = getJsonLdContext;
+exports.getPortableActorGateways = getPortableActorGateways;
 exports.isTrustedIriOrigin = isTrustedIriOrigin;
 exports.normalizeJsonLdIris = normalizeJsonLdIris;
+exports.registerDocumentLoaderWrapper = registerDocumentLoaderWrapper;
+exports.unwrapReleasedDocumentLoader = unwrapReleasedDocumentLoader;

package/dist/internal/jsonld-cache.d.cts

@@ -1,8 +1,41 @@
 /// <reference lib="esnext.temporal" />
-import { n as DocumentLoader } from "../docloader-D2DTRiyA.cjs";
+import { n as DocumentLoader } from "../docloader-CYwqh5Df.cjs";
 
 //#region src/internal/jsonld-cache.d.ts
 /**
+* Reads expanded gateways, including an unmapped term on portable actors.
+* The original values and their order are preserved for URL validation by
+* the caller.  An explicitly mapped FEP-ef61 property always takes precedence.
+* @internal Used by generated vocabulary classes and portable proof checks.
+*/
+declare function getPortableActorGateways(node: Record<string, unknown>, allowUnmapped?: boolean): unknown[] | undefined;
+/**
+* Registers a loader wrapper with the shared released-wrapper registry.
+* Both suppression and snapshot wrappers must use this registry so mixed
+* chains can be unwrapped.  The caller updates the state on release.
+* @internal Not a public API.
+*/
+declare function registerDocumentLoaderWrapper(loader: DocumentLoader, state: {
+  readonly base: DocumentLoader;
+  released: boolean;
+}): void;
+/**
+* Removes released loader wrappers, stopping at the first active wrapper.
+* Active wrappers retain their operation's suppression or snapshot cache.
+* @internal Not a public API.
+*/
+declare function unwrapReleasedDocumentLoader(base: DocumentLoader): DocumentLoader;
+/**
+* Lowers context loading failure logs for one accessor operation.  Parsed
+* objects retain the loader, so release it before returning to the caller.
+* Released wrappers are unwrapped to avoid accumulating loader chains.
+* @internal Used by generated vocabulary accessors; not a public API.
+*/
+declare function createScopedContextLoader(base: DocumentLoader, suppressError?: boolean): {
+  loader: DocumentLoader;
+  release: () => void;
+};
+/**
 * Options for deciding whether two IRIs should be treated as same-origin.
 *
 * @internal Technically exported for generated vocabulary classes, but not
@@ -45,4 +78,4 @@ declare function getJsonLdContext(value: unknown, depth?: number): unknown;
 */
 declare function compactJsonLdCache(normalized: unknown, original: unknown, documentLoader?: DocumentLoader, depth?: number, inheritedContext?: unknown): Promise<unknown>;
 //#endregion
-export { IriTrustOptions, compactJsonLdCache, getJsonLdContext, isTrustedIriOrigin, normalizeJsonLdIris };
+export { IriTrustOptions, compactJsonLdCache, createScopedContextLoader, getJsonLdContext, getPortableActorGateways, isTrustedIriOrigin, normalizeJsonLdIris, registerDocumentLoaderWrapper, unwrapReleasedDocumentLoader };

package/dist/internal/jsonld-cache.d.ts

@@ -1,8 +1,41 @@
 /// <reference lib="esnext.temporal" />
-import { n as DocumentLoader } from "../docloader-C_dir7Xb.js";
+import { n as DocumentLoader } from "../docloader-CYwqh5Df.js";
 
 //#region src/internal/jsonld-cache.d.ts
 /**
+* Reads expanded gateways, including an unmapped term on portable actors.
+* The original values and their order are preserved for URL validation by
+* the caller.  An explicitly mapped FEP-ef61 property always takes precedence.
+* @internal Used by generated vocabulary classes and portable proof checks.
+*/
+declare function getPortableActorGateways(node: Record<string, unknown>, allowUnmapped?: boolean): unknown[] | undefined;
+/**
+* Registers a loader wrapper with the shared released-wrapper registry.
+* Both suppression and snapshot wrappers must use this registry so mixed
+* chains can be unwrapped.  The caller updates the state on release.
+* @internal Not a public API.
+*/
+declare function registerDocumentLoaderWrapper(loader: DocumentLoader, state: {
+  readonly base: DocumentLoader;
+  released: boolean;
+}): void;
+/**
+* Removes released loader wrappers, stopping at the first active wrapper.
+* Active wrappers retain their operation's suppression or snapshot cache.
+* @internal Not a public API.
+*/
+declare function unwrapReleasedDocumentLoader(base: DocumentLoader): DocumentLoader;
+/**
+* Lowers context loading failure logs for one accessor operation.  Parsed
+* objects retain the loader, so release it before returning to the caller.
+* Released wrappers are unwrapped to avoid accumulating loader chains.
+* @internal Used by generated vocabulary accessors; not a public API.
+*/
+declare function createScopedContextLoader(base: DocumentLoader, suppressError?: boolean): {
+  loader: DocumentLoader;
+  release: () => void;
+};
+/**
 * Options for deciding whether two IRIs should be treated as same-origin.
 *
 * @internal Technically exported for generated vocabulary classes, but not
@@ -45,4 +78,4 @@ declare function getJsonLdContext(value: unknown, depth?: number): unknown;
 */
 declare function compactJsonLdCache(normalized: unknown, original: unknown, documentLoader?: DocumentLoader, depth?: number, inheritedContext?: unknown): Promise<unknown>;
 //#endregion
-export { IriTrustOptions, compactJsonLdCache, getJsonLdContext, isTrustedIriOrigin, normalizeJsonLdIris };
+export { IriTrustOptions, compactJsonLdCache, createScopedContextLoader, getJsonLdContext, getPortableActorGateways, isTrustedIriOrigin, normalizeJsonLdIris, registerDocumentLoaderWrapper, unwrapReleasedDocumentLoader };

package/dist/internal/jsonld-cache.js

@@ -1,8 +1,73 @@
 
-import { a as formatIri, c as haveSameIriOrigin, s as haveSameFe34Origin } from "../url-DGVbSVVi.js";
+import { _ as parseIri, c as getFe34Origin, d as haveSameIriOrigin, o as formatIri, s as fromCompatibleEf61Id, u as haveSameFe34Origin } from "../url-Dzyp-NsC.js";
 import jsonld_default from "../jsonld.js";
 //#region src/internal/jsonld-cache.ts
+/**
+* Reads expanded gateways, including an unmapped term on portable actors.
+* The original values and their order are preserved for URL validation by
+* the caller.  An explicitly mapped FEP-ef61 property always takes precedence.
+* @internal Used by generated vocabulary classes and portable proof checks.
+*/
+function getPortableActorGateways(node, allowUnmapped = true) {
+	const property = "https://w3id.org/fep/ef61/gateways";
+	if (globalThis.Object.hasOwn(node, property)) return Array.isArray(node[property]) ? node[property] : void 0;
+	if (!allowUnmapped || typeof node["@id"] !== "string" || !("http://www.w3.org/ns/ldp#inbox" in node) || !("https://www.w3.org/ns/activitystreams#outbox" in node)) return void 0;
+	try {
+		if (!getFe34Origin(parseIri(fromCompatibleEf61Id(node["@id"]) ?? node["@id"])).startsWith("did:")) return void 0;
+	} catch (error) {
+		if (error instanceof TypeError) return void 0;
+		throw error;
+	}
+	return Array.isArray(node["_:gateways"]) ? node["_:gateways"] : void 0;
+}
 const noJsonLdContext = Symbol("noJsonLdContext");
+const documentLoaderWrappers = /* @__PURE__ */ new WeakMap();
+/**
+* Registers a loader wrapper with the shared released-wrapper registry.
+* Both suppression and snapshot wrappers must use this registry so mixed
+* chains can be unwrapped.  The caller updates the state on release.
+* @internal Not a public API.
+*/
+function registerDocumentLoaderWrapper(loader, state) {
+	documentLoaderWrappers.set(loader, state);
+}
+/**
+* Removes released loader wrappers, stopping at the first active wrapper.
+* Active wrappers retain their operation's suppression or snapshot cache.
+* @internal Not a public API.
+*/
+function unwrapReleasedDocumentLoader(base) {
+	for (let state = documentLoaderWrappers.get(base); state?.released; state = documentLoaderWrappers.get(base)) base = state.base;
+	return base;
+}
+/**
+* Lowers context loading failure logs for one accessor operation.  Parsed
+* objects retain the loader, so release it before returning to the caller.
+* Released wrappers are unwrapped to avoid accumulating loader chains.
+* @internal Used by generated vocabulary accessors; not a public API.
+*/
+function createScopedContextLoader(base, suppressError) {
+	base = unwrapReleasedDocumentLoader(base);
+	if (!suppressError) return {
+		loader: base,
+		release: () => {}
+	};
+	const state = {
+		base,
+		released: false
+	};
+	const loader = (url, options) => base(url, state.released ? options : {
+		...options,
+		suppressError: true
+	});
+	registerDocumentLoaderWrapper(loader, state);
+	return {
+		loader,
+		release: () => {
+			state.released = true;
+		}
+	};
+}
 /**
 * Checks whether an IRI is trusted relative to another IRI.
 *
@@ -272,4 +337,4 @@ function combineContexts(inheritedContext, ownContext) {
 	return [...inherited, ...own];
 }
 //#endregion
-export { compactJsonLdCache, getJsonLdContext, isTrustedIriOrigin, normalizeJsonLdIris };
+export { compactJsonLdCache, createScopedContextLoader, getJsonLdContext, getPortableActorGateways, isTrustedIriOrigin, normalizeJsonLdIris, registerDocumentLoaderWrapper, unwrapReleasedDocumentLoader };