@fedify/vocab-runtime 2.4.0-dev.2256 → 2.4.0-dev.2260

package/dist/{url-Cr9lJ6cD.js → url-Dzyp-NsC.js}

@@ -41,7 +41,14 @@ function assertCompatiblePathCanBeParsed(raw, parsed) {
 	if ((compatiblePath || rawCompatiblePath) && DOT_SEGMENT_PATTERN.test(rawPath)) throw new TypeError("FEP-ef61 compatible identifier paths with dot segments cannot be represented as URLs.");
 }
 /**
-* Parses a JSON-LD `@id` value as an IRI.
+* Parses a JSON-LD `@id` value as an IRI, including FEP-ef61 portable
+* ActivityPub IRIs.  See {@link parseIri} for how IRIs are parsed.
+* @param id The `@id` value.
+* @param base The base IRI to resolve a relative `@id` against.
+* @returns The parsed IRI, or `undefined` if `id` is missing or a blank node
+*          identifier.
+* @throws {TypeError} If `id` is not a valid IRI.
+* @since 2.4.0
 */
 function parseJsonLdId(id, base) {
 	if (id == null || id.startsWith("_:")) return void 0;
@@ -59,6 +66,16 @@ function parseJsonLdId(id, base) {
 * This also applies to compatible identifier strings used as relative bases.
 * A `URL` argument may already have lost such segments before this function
 * receives it.
+*
+* Portable IRIs, e.g., `ap://did:key:z6Mk.../actor`, cannot be represented by
+* JavaScript `URL` as they are, so the returned `URL` keeps the DID authority
+* percent-encoded, e.g., `ap+ef61://did%3Akey%3Az6Mk.../actor`.  Use
+* {@link formatIri} to get the canonical string back.
+* @param iri The IRI to parse.
+* @param base The base IRI to resolve a relative IRI against.
+* @returns The parsed IRI.
+* @throws {TypeError} If the IRI is malformed.
+* @since 2.4.0
 */
 function parseIri(iri, base) {
 	if (iri instanceof URL) return normalizePortableUrl(iri) ?? new URL(iri.href);
@@ -83,6 +100,12 @@ function parseIri(iri, base) {
 * the scheme this function produces.  Do not compare its results as strings to
 * tell whether two portable IRIs identify the same object; use
 * `arePortableUrisEqual()` instead.
+* @param iri The IRI to format.
+* @returns The formatted IRI.  A string that cannot be parsed as a URL at all
+*          is returned unchanged.
+* @throws {TypeError} If the IRI is a malformed portable IRI or FEP-ef61
+*                     compatible identifier, e.g., one with dot segments.
+* @since 2.4.0
 */
 function formatIri(iri) {
 	if (typeof iri === "string") assertPortablePathCanBeParsed(iri);
@@ -185,7 +208,20 @@ function haveSameFe34Origin(left, right) {
 	}
 }
 /**
-* Checks whether two IRIs have the same origin.
+* Checks whether two IRIs have the same origin.  Unlike comparing
+* `URL.origin`, which is `"null"` for URLs with non-special schemes, this
+* compares FEP-ef61 portable ActivityPub IRIs by their schemes and DIDs, so
+* that `ap:` and `ap+ef61:` IRIs of the same DID with decoded or
+* percent-encoded authorities have the same origin.  Other IRIs with
+* a non-special scheme and a host are compared by their schemes and hosts.
+*
+* This is not an FEP-fe34 origin check: an `ap+ef61:` IRI and the `did:key`
+* verification method of the same DID have different origins here.  Use
+* {@link haveSameFe34Origin} for that.
+* @param left The first IRI.
+* @param right The second IRI.
+* @returns `true` if the IRIs have the same origin.
+* @since 2.4.0
 */
 function haveSameIriOrigin(left, right) {
 	return getComparableIriOrigin(left) === getComparableIriOrigin(right);
@@ -273,14 +309,27 @@ function parseAtUri(uri) {
 	return new URL("at://" + encodeURIComponent(authority) + path);
 }
 /**
-* Checks whether the URL is an FEP-ef61 gateway base URI.
+* Checks whether the URL is an FEP-ef61 gateway base URI, i.e., an HTTP(S)
+* URI with no credentials, path, query, or fragment, such as
+* `https://example.com/`.  FEP-ef61 requires every item of a portable actor's
+* `gateways` to be such a URI.  A URI with an empty query or fragment
+* delimiter, such as `https://example.com/?`, is not a gateway base URI.
+*
+* Note that the `URL` class normalizes `https://example.com` to
+* `https://example.com/`, so both are gateway base URIs.
+* @param url The URL to check.
+* @returns `true` if the URL is an FEP-ef61 gateway base URI.
 * @since 2.4.0
 */
 function isGatewayUrl(url) {
 	return (url.protocol === "http:" || url.protocol === "https:") && url.href === `${url.origin}/`;
 }
 /**
-* Parses and validates an FEP-ef61 gateway base URI.
+* Parses and validates an FEP-ef61 gateway base URI, i.e., an HTTP(S) URI with
+* no credentials, path, query, or fragment, such as `https://example.com`.
+* See {@link isGatewayUrl} for the rules.
+* @param url The gateway base URI to parse.
+* @returns The parsed gateway base URI, whose path is `/`.
 * @throws {TypeError} If the URI is malformed, or is not an HTTP(S) base URI
 *                     with no credentials, path, query, or fragment.  In the
 *                     latter case, the message starts with

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/vocab-runtime",
-  "version": "2.4.0-dev.2256+683c50ba",
+  "version": "2.4.0-dev.2260+42356e7d",
   "homepage": "https://fedify.dev/",
   "repository": {
     "type": "git",

package/src/docloader.ts

@@ -62,6 +62,7 @@ export interface DocumentLoaderOptions {
    * 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;
 }

package/src/internal/portable-dereference.test.ts

@@ -6,7 +6,9 @@ import { createScopedContextLoader } from "./jsonld-cache.ts";
 import {
   createSnapshotContextLoader,
   getPortableGatewayCandidates,
+  getReferrerGateways,
   isPortableIri,
+  recordPortableReferrer,
 } from "./portable-dereference.ts";
 
 const hrefs = (urls: URL[]) => urls.map((url) => url.href);
@@ -91,6 +93,66 @@ test("getPortableGatewayCandidates() reads hints from withGatewayHints()", () =>
   );
 });
 
+test("getReferrerGateways() takes gateways from the owner", () => {
+  const actor = {
+    id: parseIri("ap://did:key:z6Mkabc/actor"),
+    gateways: [
+      new URL("https://a.example"),
+      new URL("https://a.example/"),
+      new URL("https://b.example/path"),
+      new URL("https://c.example"),
+    ],
+  };
+  const outbox = { id: parseIri("ap://did:key:z6Mkabc/actor/outbox") };
+  recordPortableReferrer(actor, outbox, "outbox");
+  const page = parseIri("ap://did:key:z6Mkabc/actor/outbox?cursor=1");
+
+  // From the actor itself, and from an object obtained from it; duplicate and
+  // invalid gateways are dropped:
+  deepStrictEqual(
+    hrefs(getReferrerGateways(actor, outbox.id) ?? []),
+    ["https://a.example/", "https://c.example/"],
+  );
+  deepStrictEqual(
+    hrefs(getReferrerGateways(outbox, page) ?? []),
+    ["https://a.example/", "https://c.example/"],
+  );
+
+  // Location hints take precedence:
+  deepStrictEqual(
+    getReferrerGateways(
+      outbox,
+      withGatewayHints(page, [new URL("https://hint.example")]),
+    ),
+    undefined,
+  );
+
+  // A reference under another DID does not belong to the actor:
+  deepStrictEqual(
+    getReferrerGateways(outbox, parseIri("ap://did:key:z6Mkdef/notes/1")),
+    undefined,
+  );
+
+  // An actor with a compatible identifier works the same way:
+  const compatible = {
+    id: new URL(
+      "https://a.example/.well-known/apgateway/did:key:z6Mkabc/actor",
+    ),
+    gateways: [new URL("https://a.example")],
+  };
+  deepStrictEqual(
+    hrefs(getReferrerGateways(compatible, outbox.id) ?? []),
+    ["https://a.example/"],
+  );
+
+  // Objects that no portable actor leads to have no gateways to offer:
+  deepStrictEqual(getReferrerGateways({}, page), undefined);
+  deepStrictEqual(
+    getReferrerGateways({ id: actor.id, gateways: [] }, page),
+    undefined,
+  );
+});
+
 test("createSnapshotContextLoader() does not nest released snapshots", async () => {
   const calls: string[] = [];
   const base: DocumentLoader = (url) => {

package/src/internal/portable-dereference.ts

@@ -538,6 +538,73 @@ export function getPortableGatewayCandidates(
   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.
+ */
+export function getReferrerGateways(
+  object: object,
+  url: URL,
+): URL[] | undefined {
+  if (getPortableGatewayCandidates(url).length > 0) return undefined;
+  const visited = new Set<object>();
+  let current: object | undefined = object;
+  while (current != null && !visited.has(current)) {
+    visited.add(current);
+    const gateways: unknown = "gateways" in current
+      ? current.gateways
+      : undefined;
+    if (Array.isArray(gateways) && gateways.length > 0) {
+      const id = getObjectId(current);
+      const portableId = id == null
+        ? null
+        : isPortableIri(id)
+        ? id
+        : getCompatibleEf61Target(id);
+      if (portableId == null || !haveSameFe34Origin(portableId, url)) {
+        return undefined;
+      }
+      const candidates: URL[] = [];
+      for (const gateway of gateways) {
+        if (candidates.length >= MAX_GATEWAY_HINTS) break;
+        if (typeof gateway !== "string" && !(gateway instanceof URL)) continue;
+        const parsed = parseGatewayOrigin(gateway);
+        if (parsed == null) continue;
+        if (candidates.some((c) => c.href === parsed.href)) continue;
+        candidates.push(parsed);
+      }
+      return candidates.length > 0 ? candidates : undefined;
+    }
+    current = provenances.get(current)?.referrer?.object;
+  }
+  return undefined;
+}
+
+function getCompatibleEf61Target(id: URL): URL | null {
+  try {
+    return 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

package/src/url.ts

@@ -81,7 +81,14 @@ function assertCompatiblePathCanBeParsed(raw: string, parsed: URL): void {
 }
 
 /**
- * Parses a JSON-LD `@id` value as an IRI.
+ * Parses a JSON-LD `@id` value as an IRI, including FEP-ef61 portable
+ * ActivityPub IRIs.  See {@link parseIri} for how IRIs are parsed.
+ * @param id The `@id` value.
+ * @param base The base IRI to resolve a relative `@id` against.
+ * @returns The parsed IRI, or `undefined` if `id` is missing or a blank node
+ *          identifier.
+ * @throws {TypeError} If `id` is not a valid IRI.
+ * @since 2.4.0
  */
 export function parseJsonLdId(
   id: string | undefined,
@@ -103,6 +110,16 @@ export function parseJsonLdId(
  * This also applies to compatible identifier strings used as relative bases.
  * A `URL` argument may already have lost such segments before this function
  * receives it.
+ *
+ * Portable IRIs, e.g., `ap://did:key:z6Mk.../actor`, cannot be represented by
+ * JavaScript `URL` as they are, so the returned `URL` keeps the DID authority
+ * percent-encoded, e.g., `ap+ef61://did%3Akey%3Az6Mk.../actor`.  Use
+ * {@link formatIri} to get the canonical string back.
+ * @param iri The IRI to parse.
+ * @param base The base IRI to resolve a relative IRI against.
+ * @returns The parsed IRI.
+ * @throws {TypeError} If the IRI is malformed.
+ * @since 2.4.0
  */
 export function parseIri(iri: string | URL, base?: string | URL): URL {
   if (iri instanceof URL) {
@@ -132,6 +149,12 @@ export function parseIri(iri: string | URL, base?: string | URL): URL {
  * the scheme this function produces.  Do not compare its results as strings to
  * tell whether two portable IRIs identify the same object; use
  * `arePortableUrisEqual()` instead.
+ * @param iri The IRI to format.
+ * @returns The formatted IRI.  A string that cannot be parsed as a URL at all
+ *          is returned unchanged.
+ * @throws {TypeError} If the IRI is a malformed portable IRI or FEP-ef61
+ *                     compatible identifier, e.g., one with dot segments.
+ * @since 2.4.0
  */
 export function formatIri(iri: string | URL): string {
   if (typeof iri === "string") assertPortablePathCanBeParsed(iri);
@@ -271,7 +294,20 @@ export function haveSameFe34Origin(
 }
 
 /**
- * Checks whether two IRIs have the same origin.
+ * Checks whether two IRIs have the same origin.  Unlike comparing
+ * `URL.origin`, which is `"null"` for URLs with non-special schemes, this
+ * compares FEP-ef61 portable ActivityPub IRIs by their schemes and DIDs, so
+ * that `ap:` and `ap+ef61:` IRIs of the same DID with decoded or
+ * percent-encoded authorities have the same origin.  Other IRIs with
+ * a non-special scheme and a host are compared by their schemes and hosts.
+ *
+ * This is not an FEP-fe34 origin check: an `ap+ef61:` IRI and the `did:key`
+ * verification method of the same DID have different origins here.  Use
+ * {@link haveSameFe34Origin} for that.
+ * @param left The first IRI.
+ * @param right The second IRI.
+ * @returns `true` if the IRIs have the same origin.
+ * @since 2.4.0
  */
 export function haveSameIriOrigin(left: URL, right: URL): boolean {
   return getComparableIriOrigin(left) === getComparableIriOrigin(right);
@@ -417,7 +453,16 @@ function parseAtUri(uri: string): URL {
 }
 
 /**
- * Checks whether the URL is an FEP-ef61 gateway base URI.
+ * Checks whether the URL is an FEP-ef61 gateway base URI, i.e., an HTTP(S)
+ * URI with no credentials, path, query, or fragment, such as
+ * `https://example.com/`.  FEP-ef61 requires every item of a portable actor's
+ * `gateways` to be such a URI.  A URI with an empty query or fragment
+ * delimiter, such as `https://example.com/?`, is not a gateway base URI.
+ *
+ * Note that the `URL` class normalizes `https://example.com` to
+ * `https://example.com/`, so both are gateway base URIs.
+ * @param url The URL to check.
+ * @returns `true` if the URL is an FEP-ef61 gateway base URI.
  * @since 2.4.0
  */
 export function isGatewayUrl(url: URL): boolean {
@@ -426,7 +471,11 @@ export function isGatewayUrl(url: URL): boolean {
 }
 
 /**
- * Parses and validates an FEP-ef61 gateway base URI.
+ * Parses and validates an FEP-ef61 gateway base URI, i.e., an HTTP(S) URI with
+ * no credentials, path, query, or fragment, such as `https://example.com`.
+ * See {@link isGatewayUrl} for the rules.
+ * @param url The gateway base URI to parse.
+ * @returns The parsed gateway base URI, whose path is `/`.
  * @throws {TypeError} If the URI is malformed, or is not an HTTP(S) base URI
  *                     with no credentials, path, query, or fragment.  In the
  *                     latter case, the message starts with

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

@@ -1,149 +0,0 @@
-const require_contexts = require("./contexts-DizzBjz4.cjs");
-const require_url = require("./url-Ddeuv0sE.cjs");
-const require_jsonld_cache = require("./jsonld-cache-CMzevnnN.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"
-]);
-/**
-* 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;
-}
-/**
-* 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, "isPortableIri", {
-	enumerable: true,
-	get: function() {
-		return isPortableIri;
-	}
-});

package/dist/tests/portable-dereference-EAbEhAJ4.mjs

@@ -1,132 +0,0 @@
-import { t as preloadedContexts } from "./contexts-CIKsin4e.mjs";
-import { h as parseGatewayOrigin, o as formatIri, t as GATEWAY_HINT_PARAMETER } from "./url-ClVBNQup.mjs";
-import { c as unwrapReleasedDocumentLoader, s as registerDocumentLoaderWrapper } from "./jsonld-cache-DCh2kTs6.mjs";
-import { getLogger } from "@logtape/logtape";
-import "@opentelemetry/api";
-//#region src/internal/portable-dereference.ts
-const logger = 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"
-]);
-/**
-* 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 = 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(GATEWAY_HINT_PARAMETER)) {
-		if (candidates.length >= MAX_GATEWAY_HINTS) break;
-		const parsed = parseGatewayOrigin(hint);
-		if (parsed == null) {
-			logger.debug("Ignoring an invalid FEP-ef61 gateway hint {hint} in {url}.", {
-				hint,
-				url: formatIri(url)
-			});
-			continue;
-		}
-		add(parsed);
-	}
-	return candidates;
-}
-/**
-* 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 = 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(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
-	};
-	registerDocumentLoaderWrapper(loader, state);
-	return {
-		loader,
-		release
-	};
-}
-//#endregion
-export { getPortableGatewayCandidates as n, isPortableIri as r, createSnapshotContextLoader as t };