@fedify/fedify 2.5.0-dev.2364 → 2.5.0-dev.2378

package/dist/{http-Btzv2JZU.cjs → http-D1RPHoq3.cjs}

@@ -17,7 +17,7 @@ json_canon = require_rolldown_runtime.__toESM(json_canon, 1);
 let _opentelemetry_semantic_conventions = require("@opentelemetry/semantic-conventions");
 //#region deno.json
 var name = "@fedify/fedify";
-var version = "2.5.0-dev.2364+4d9b5f4d";
+var version = "2.5.0-dev.2378+fea9c751";
 //#endregion
 //#region src/sig/portable-key-id.ts
 const COMPATIBLE_KEY_ID_PATH_PATTERN = /^\/\.well-known\/apgateway\/did(?::|%3A)/i;
@@ -4998,6 +4998,65 @@ async function parseKeyOwnerEvidence(evidence, options = {}) {
 //#endregion
 //#region src/sig/key.ts
 const Temporal$2 = Temporal$4;
+/** Classifies decoding failures without hiding unexpected loader errors. */
+function classifyKeyJsonLdError(error, seen = /* @__PURE__ */ new Set()) {
+	if (!(error instanceof Error) || !error.name.startsWith("jsonld.")) return null;
+	if (seen.has(error)) throw error;
+	seen.add(error);
+	const details = error.details;
+	if (typeof details?.code !== "string") return null;
+	if (details.code !== "loading remote context failed" || !("cause" in details) && !("cause" in error)) return "invalid";
+	const cause = "cause" in details ? details.cause : error.cause;
+	const nestedFailure = classifyKeyJsonLdError(cause, seen);
+	if (nestedFailure != null) return nestedFailure;
+	if (cause instanceof SyntaxError) return "invalid";
+	if (cause instanceof _fedify_vocab_runtime.FetchError || cause instanceof _fedify_vocab_runtime.UrlError) return "fetch";
+	if (cause instanceof Error && [
+		"AbortError",
+		"TimeoutError",
+		"NetworkError"
+	].includes(cause.name)) return "fetch";
+	if (cause instanceof TypeError) {
+		const urlCode = cause.code;
+		if (cause.name === "InvalidContextReferenceError") return "invalid";
+		if (urlCode === "ERR_INVALID_URL" || cause.message === "Invalid URL string." || /^Invalid URL(?::|$)/.test(cause.message) || / cannot be parsed as a URL\.?$/.test(cause.message)) return typeof details.url === "string" && /^[A-Za-z][A-Za-z0-9+.-]*:/.test(details.url) && !URL.canParse(details.url) ? "invalid" : "fetch";
+		const networkCause = cause.cause;
+		const code = cause.code ?? networkCause?.code;
+		if (typeof code === "string" && [
+			"ECONNREFUSED",
+			"ECONNRESET",
+			"ECONNABORTED",
+			"ETIMEDOUT",
+			"EHOSTUNREACH",
+			"ENETUNREACH",
+			"ENOTFOUND",
+			"EAI_AGAIN",
+			"UND_ERR_CONNECT_TIMEOUT",
+			"UND_ERR_HEADERS_TIMEOUT",
+			"UND_ERR_BODY_TIMEOUT",
+			"UND_ERR_SOCKET"
+		].includes(code) || /^(fetch failed|Failed to fetch|error sending request|error reading a body from connection|Unable to connect|ConnectionRefused|Network connection lost|The socket connection was closed unexpectedly)/.test(cause.message)) return "fetch";
+	}
+	throw cause;
+}
+/** Carries a context transport failure through the key decoding boundary. */
+var KeyContextFetchError = class extends Error {
+	error;
+	constructor(error) {
+		super("Failed to fetch a key's JSON-LD context.", { cause: error });
+		this.error = error;
+	}
+};
+function contextFetchError(error) {
+	const seen = /* @__PURE__ */ new Set();
+	while (error instanceof Error && !seen.has(error)) {
+		seen.add(error);
+		const details = error.details;
+		if (!error.name.startsWith("jsonld.") || details?.code !== "loading remote context failed") break;
+		error = "cause" in details ? details.cause : error.cause;
+	}
+	return new KeyContextFetchError(error);
+}
 /**
 * Checks if the given key is valid and supported.  No-op if the key is valid,
 * otherwise throws an error.
@@ -5092,6 +5151,9 @@ async function importJwk(jwk, type) {
 * @internal
 */
 async function fetchActorDocument(actorId, options = {}) {
+	return await fetchActorDocumentInternal(actorId, options, false);
+}
+async function fetchActorDocumentInternal(actorId, options, propagateContextFetchErrors) {
 	const logger = (0, _logtape_logtape.getLogger)([
 		"fedify",
 		"sig",
@@ -5126,9 +5188,12 @@ async function fetchActorDocument(actorId, options = {}) {
 			baseUrl: documentUrl
 		});
 	} catch (error) {
-		if (!(error instanceof TypeError)) throw error;
-		logger.debug("The document served at {documentUrl} is not a valid object: {error}", {
+		const failure = classifyKeyJsonLdError(error);
+		if (failure === "fetch" && propagateContextFetchErrors) throw contextFetchError(error);
+		if (failure == null && !(error instanceof TypeError)) throw error;
+		logger.debug("Failed to decode the actor document at {documentUrl}: {error}", {
 			documentUrl: documentUrl.href,
+			failure: failure ?? "invalid",
 			error
 		});
 		return null;
@@ -5174,6 +5239,9 @@ async function fetchActorDocument(actorId, options = {}) {
 * @internal
 */
 async function verifyKeyOwnership(key, options = {}) {
+	return await verifyKeyOwnershipInternal(key, options, false);
+}
+async function verifyKeyOwnershipInternal(key, options, propagateContextFetchErrors) {
 	const logger = (0, _logtape_logtape.getLogger)([
 		"fedify",
 		"sig",
@@ -5183,7 +5251,7 @@ async function verifyKeyOwnership(key, options = {}) {
 	if (keyId == null) return null;
 	const claimedOwnerId = key instanceof _fedify_vocab.CryptographicKey ? key.ownerId : key.controllerId;
 	if (claimedOwnerId == null) return null;
-	const owner = await fetchActorDocument(claimedOwnerId, options);
+	const owner = await fetchActorDocumentInternal(claimedOwnerId, options, propagateContextFetchErrors);
 	if (owner == null) {
 		logger.debug("The owner ({claimedOwnerId}) that key {keyId} claims could not be resolved.", {
 			keyId: keyId.href,
@@ -5509,6 +5577,21 @@ async function resolveFetchedKey(document, cacheKey, documentUrl, keyId, cls, {
 			tracerProvider
 		});
 	} catch (e) {
+		const failure = classifyKeyJsonLdError(e);
+		if (failure === "fetch") throw contextFetchError(e);
+		if (failure != null) {
+			logger.debug("Failed to decode key {keyId}: {error}", {
+				keyId,
+				failure,
+				error: e
+			});
+			await keyCache?.set(cacheKey, null);
+			await clearFetchErrorMetadata(cacheKey, keyCache);
+			return {
+				key: null,
+				cached: false
+			};
+		}
 		if (!(e instanceof TypeError)) throw e;
 		try {
 			object = await cls.fromJsonLd(document, {
@@ -5517,8 +5600,14 @@ async function resolveFetchedKey(document, cacheKey, documentUrl, keyId, cls, {
 				tracerProvider
 			});
 		} catch (e) {
-			if (e instanceof TypeError) {
-				logger.debug("Failed to verify; key {keyId} returned an invalid object.", { keyId });
+			const failure = classifyKeyJsonLdError(e);
+			if (failure === "fetch") throw contextFetchError(e);
+			if (failure != null || e instanceof TypeError) {
+				logger.debug("Failed to decode key {keyId}: {error}", {
+					keyId,
+					failure: failure ?? "invalid",
+					error: e
+				});
 				await keyCache?.set(cacheKey, null);
 				await clearFetchErrorMetadata(cacheKey, keyCache);
 				return {
@@ -5657,16 +5746,17 @@ async function resolveFetchedKey(document, cacheKey, documentUrl, keyId, cls, {
 		}
 		if (ownerDocument != null && claimedOwnerId == null) key = key instanceof _fedify_vocab.CryptographicKey ? key.clone({ owner: ownerDocument.id }) : key.clone({ controller: ownerDocument.id });
 		else if (claimedOwnerId != null && claimedOwnerId.href !== ownerDocument?.id?.href) {
-			if (await verifyKeyOwnership(key, {
+			if (await verifyKeyOwnershipInternal(key, {
 				documentLoader,
 				contextLoader,
 				tracerProvider
-			}) == null) {
+			}, true) == null) {
 				logger.debug("Failed to verify; the owner {claimedOwnerId} that key {keyId} claims does not list the key as its own.", {
 					keyId,
 					claimedOwnerId: claimedOwnerId.href
 				});
 				await keyCache?.set(cacheKey, null);
+				await clearFetchErrorMetadata(cacheKey, keyCache);
 				return {
 					key: null,
 					cached: false
@@ -5743,9 +5833,17 @@ async function fetchKeyWithResult(cacheKey, cls, options, onCachedUnavailable, o
 			outcome = classified;
 			return errored;
 		}
-		const resolved = await resolveFetchedKey(document, cacheKey, documentUrl, keyId, cls, options, logger);
-		outcome = { result: resolved.key != null ? "fetched" : "invalid" };
-		return resolved;
+		try {
+			const resolved = await resolveFetchedKey(document, cacheKey, documentUrl, keyId, cls, options, logger);
+			outcome = { result: resolved.key != null ? "fetched" : "invalid" };
+			return resolved;
+		} catch (error) {
+			if (!(error instanceof KeyContextFetchError)) throw error;
+			const classified = classifyFetchError(error.error);
+			const errored = await onFetchError(error.error, cacheKey, keyId, keyCache, logger);
+			outcome = classified;
+			return errored;
+		}
 	} finally {
 		recordKeyLookup(options.meterProvider, {
 			durationMs: getDurationMs(start),
@@ -7989,34 +8087,68 @@ async function preparePortableObjectProof(jsonLd, options) {
 	};
 }
 /**
-* Applies portable-object proof policy to one map-local cryptographic result.
+* Checks portable-object policy without resolving keys or verifying signatures.
 *
 * @internal
 */
-async function verifyPortableObjectProofPolicy(jsonLd, key, options = {}) {
+async function preparePortableObjectProofPolicy(jsonLd, options = {}) {
 	const policyOptions = {
 		...options,
 		contextLoader: preloadedOnlyDocumentLoader
 	};
 	const prepared = await preparePortableObjectProof(jsonLd, policyOptions);
-	if (!prepared.prepared) return prepared.result;
+	if (!prepared.prepared) return {
+		prepared: false,
+		result: prepared.result
+	};
 	const policyProof = prepared.proofs[0];
 	const literalProof = isJsonLdNode(jsonLd) && isJsonLdNode(jsonLd.proof) ? (await parseRawProofCandidates(jsonLd, [jsonLd.proof], policyOptions, prepared.proofContextLoader))[0]?.proof : null;
 	const verificationMethod = policyProof?.verificationMethodId;
-	if (prepared.proofs.length !== 1 || key == null || policyProof == null || literalProof == null || !sameProof(policyProof, literalProof) || verificationMethod == null || key.id?.href !== verificationMethod.href) return {
+	if (prepared.proofs.length !== 1 || policyProof == null || literalProof == null || !sameProof(policyProof, literalProof) || verificationMethod == null) return {
+		prepared: false,
+		result: {
+			verified: false,
+			reason: {
+				type: "invalidProof",
+				proofIndex: prepared.proofs.length > 1 ? 1 : 0
+			}
+		}
+	};
+	return {
+		prepared: true,
+		verificationMethod,
+		objectId: (0, _fedify_vocab_runtime.formatIri)(prepared.objectId)
+	};
+}
+/**
+* Binds prepared portable-object policy to the map-local verified key.
+*
+* @internal
+*/
+function verifyPreparedPortableObjectProofPolicy(prepared, key) {
+	if (key == null || key.id?.href !== prepared.verificationMethod.href) return {
 		verified: false,
 		reason: {
 			type: "invalidProof",
-			proofIndex: prepared.proofs.length > 1 ? 1 : 0
+			proofIndex: 0
 		}
 	};
 	return {
 		verified: true,
 		keys: [key],
-		objectId: (0, _fedify_vocab_runtime.formatIri)(prepared.objectId)
+		objectId: prepared.objectId
 	};
 }
 /**
+* Applies portable-object proof policy to one map-local cryptographic result.
+*
+* @internal
+*/
+async function verifyPortableObjectProofPolicy(jsonLd, key, options = {}) {
+	const prepared = await preparePortableObjectProofPolicy(jsonLd, options);
+	return prepared.prepared ? verifyPreparedPortableObjectProofPolicy(prepared, key) : prepared.result;
+}
+/**
 * Verifies the FEP-ef61 Object Integrity Proof policy for a portable object.
 *
 * This applies the FEP-2277 core-type classification to the top-level JSON-LD
@@ -10412,6 +10544,12 @@ Object.defineProperty(exports, "preloadedOnlyDocumentLoader", {
 		return preloadedOnlyDocumentLoader;
 	}
 });
+Object.defineProperty(exports, "preparePortableObjectProofPolicy", {
+	enumerable: true,
+	get: function() {
+		return preparePortableObjectProofPolicy;
+	}
+});
 Object.defineProperty(exports, "recordCircuitBreakerStateChange", {
 	enumerable: true,
 	get: function() {
@@ -10592,6 +10730,12 @@ Object.defineProperty(exports, "verifyPortableObjectProofWithRoot", {
 		return verifyPortableObjectProofWithRoot;
 	}
 });
+Object.defineProperty(exports, "verifyPreparedPortableObjectProofPolicy", {
+	enumerable: true,
+	get: function() {
+		return verifyPreparedPortableObjectProofPolicy;
+	}
+});
 Object.defineProperty(exports, "verifyProof", {
 	enumerable: true,
 	get: function() {

package/dist/{key-DYxuyd-s.d.cts → key-DhsBxxZN.d.ts}

@@ -1,7 +1,7 @@
 /// <reference lib="esnext.temporal" />
 import { Actor, CryptographicKey, DataIntegrityProof, Multikey, Object as Object$1 } from "@fedify/vocab";
-import { DocumentLoader, PortableObjectVerifier } from "@fedify/vocab-runtime";
 import { MeterProvider, TracerProvider } from "@opentelemetry/api";
+import { DocumentLoader, PortableObjectVerifier } from "@fedify/vocab-runtime";
 
 //#region src/sig/proof.d.ts
 /**
@@ -272,7 +272,11 @@ type CompoundProofDiscoveryFailureReason = {
 type CompoundProofVerificationFailureReason = {
   /** A nested secured map does not carry its own JSON-LD context. */readonly type: "missingContext";
 } | {
-  /** The direct proof is malformed, unsupported, or invalid. */readonly type: "invalidProof";
+  /**
+  * The direct proof is malformed, unsupported, invalid, or left unverified
+  * because the portable-object policy rejects its map.
+  */
+  readonly type: "invalidProof";
 };
 /** Why one portable map did not pass compound proof policy. */
 type CompoundPortableObjectFailureReason = CompoundProofVerificationFailureReason | VerifyPortableObjectProofFailureReason | {

package/dist/{key-C1nv7_jD.d.ts → key-nYGY4QB9.d.cts}

@@ -1,7 +1,7 @@
 /// <reference lib="esnext.temporal" />
 import { Actor, CryptographicKey, DataIntegrityProof, Multikey, Object as Object$1 } from "@fedify/vocab";
-import { MeterProvider, TracerProvider } from "@opentelemetry/api";
 import { DocumentLoader, PortableObjectVerifier } from "@fedify/vocab-runtime";
+import { MeterProvider, TracerProvider } from "@opentelemetry/api";
 
 //#region src/sig/proof.d.ts
 /**
@@ -272,7 +272,11 @@ type CompoundProofDiscoveryFailureReason = {
 type CompoundProofVerificationFailureReason = {
   /** A nested secured map does not carry its own JSON-LD context. */readonly type: "missingContext";
 } | {
-  /** The direct proof is malformed, unsupported, or invalid. */readonly type: "invalidProof";
+  /**
+  * The direct proof is malformed, unsupported, invalid, or left unverified
+  * because the portable-object policy rejects its map.
+  */
+  readonly type: "invalidProof";
 };
 /** Why one portable map did not pass compound proof policy. */
 type CompoundPortableObjectFailureReason = CompoundProofVerificationFailureReason | VerifyPortableObjectProofFailureReason | {

package/dist/{kv-cache-CamfvHLY.js → kv-cache-C0-HuvwP.js}

@@ -1,6 +1,6 @@
 import { Temporal } from "temporal-polyfill";
 import { URLPattern } from "urlpattern-polyfill";
-import { G as validateCryptoKey, ot as recordDocumentCache, t as doubleKnock } from "./http-Cg5Yj_yk.js";
+import { ct as recordDocumentCache, q as validateCryptoKey, t as doubleKnock } from "./http-Cmz7x6Iw.js";
 import { getLogger } from "@logtape/logtape";
 import { FetchError, UrlError, createActivityPubRequest, getRemoteDocument, logRequest, preloadedContexts, resolveDocumentLoaderTimeout, validatePublicUrl, withDocumentLoaderTimeout } from "@fedify/vocab-runtime";
 import { curry } from "es-toolkit";

package/dist/{kv-cache-0qHe-sN1.cjs → kv-cache-Jym5nP3J.cjs}

@@ -1,5 +1,5 @@
 const { URLPattern } = require("urlpattern-polyfill");
-const require_http = require("./http-Btzv2JZU.cjs");
+const require_http = require("./http-D1RPHoq3.cjs");
 let _logtape_logtape = require("@logtape/logtape");
 let _fedify_vocab_runtime = require("@fedify/vocab-runtime");
 let es_toolkit = require("es-toolkit");

package/dist/{kv-cache-BoekCvYF.mjs → kv-cache-rOQX3I3c.mjs}

@@ -1,7 +1,7 @@
 import { Temporal } from "temporal-polyfill";
 import { URLPattern } from "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { p as recordDocumentCache } from "./metrics-DUdlIyrB.mjs";
+import { p as recordDocumentCache } from "./metrics-Dwgav7s_.mjs";
 import { getLogger } from "@logtape/logtape";
 import { preloadedContexts } from "@fedify/vocab-runtime";
 //#region src/utils/kv-cache.ts