@fedify/fedify 2.4.0-dev.2253 → 2.4.0-dev.2259

package/dist/{http-BoGE-nk7.js → http-OMtKlbx1.js}

@@ -9,12 +9,13 @@ import { encodeHex } from "byte-encodings/hex";
 import jsonld from "@fedify/vocab-runtime/jsonld";
 import { Item, decodeDict, encodeDict, encodeItem } from "structured-field-values";
 import { decodeBase64, encodeBase64 } from "byte-encodings/base64";
+import { getPortableActorGateways } from "@fedify/vocab-runtime/internal/jsonld-cache";
 import { isPlainJsonTree, retainSignedRepresentation } from "@fedify/vocab-runtime/internal/signed-representation";
 import serialize from "json-canon";
 import { ATTR_HTTP_REQUEST_HEADER, ATTR_HTTP_REQUEST_METHOD, ATTR_URL_FULL } from "@opentelemetry/semantic-conventions";
 //#region deno.json
 var name = "@fedify/fedify";
-var version = "2.4.0-dev.2253+f5212c33";
+var version = "2.4.0-dev.2259+d9c843fc";
 //#endregion
 //#region src/sig/portable-key-id.ts
 const COMPATIBLE_KEY_ID_PATH_PATTERN = /^\/\.well-known\/apgateway\/did(?::|%3A)/i;
@@ -257,6 +258,106 @@ async function isSamePublicKey(a, b) {
 	return x.kty === y.kty && x.crv === y.crv && x.n === y.n && x.e === y.e && x.x === y.x && x.y === y.y;
 }
 //#endregion
+//#region src/sig/verification.ts
+const verificationObservation = Symbol("verificationObservation");
+function snapshotKey(key) {
+	if (key.publicKey == null) throw new TypeError("Verification key has no public key.");
+	const id = key.id == null ? null : new URL(key.id.href);
+	return key instanceof CryptographicKey ? {
+		type: "cryptographicKey",
+		id,
+		ownerId: key.ownerId == null ? null : new URL(key.ownerId.href),
+		publicKey: key.publicKey
+	} : {
+		type: "multikey",
+		id,
+		controllerId: key.controllerId == null ? null : new URL(key.controllerId.href),
+		publicKey: key.publicKey
+	};
+}
+function triedKey(options, key) {
+	const check = options[verificationObservation]?.check;
+	if (check != null) check.triedKeys.push(snapshotKey(key));
+}
+async function observeCheck(options, identity, declaredKeyId, operation) {
+	const observation = options[verificationObservation];
+	if (observation?.attempt == null) return await operation(observation ?? { attempts: [] });
+	const check = {
+		identity,
+		declaredKeyId,
+		triedKeys: []
+	};
+	const base = {
+		...identity,
+		declaredKeyId,
+		triedKeys: check.triedKeys
+	};
+	try {
+		const key = await operation({
+			...observation,
+			check
+		});
+		observation.attempt.checks.push(key == null ? {
+			...base,
+			status: "rejected",
+			reason: check.reason ?? { type: "invalidSignature" }
+		} : {
+			...base,
+			status: "verified",
+			key: check.triedKeys.at(-1) ?? snapshotKey(key)
+		});
+		return key;
+	} catch (error) {
+		observation.attempt.checks.push({
+			...base,
+			status: "error",
+			error
+		});
+		throw error;
+	}
+}
+async function observeAttempt(options, mechanism, operation, isVerified) {
+	const observation = options[verificationObservation];
+	if (observation == null) return await operation({ attempts: [] });
+	const attempt = { checks: [] };
+	const base = {
+		mechanism,
+		subject: observation.subject == null ? {
+			id: null,
+			pointer: ""
+		} : {
+			id: observation.subject.id == null ? null : new URL(observation.subject.id.href),
+			pointer: observation.subject.pointer
+		},
+		checks: attempt.checks
+	};
+	try {
+		const value = await operation({
+			...observation,
+			subject: base.subject,
+			attempt,
+			check: void 0
+		});
+		observation.attempts.push(isVerified(value) ? {
+			...base,
+			status: "verified",
+			signatures: attempt.checks.filter((check) => check.status === "verified")
+		} : {
+			...base,
+			status: "rejected",
+			reason: attempt.reason ?? { type: "signatureVerificationFailed" }
+		});
+		return value;
+	} catch (error) {
+		observation.attempts.push({
+			...base,
+			status: "error",
+			error
+		});
+		throw error;
+	}
+}
+//#endregion
 //#region src/sig/accept.ts
 /**
 * `Accept-Signature` header parsing, serialization, and validation utilities
@@ -713,6 +814,7 @@ var FederationMetrics = class {
 		};
 		if (extra.algorithm != null) attributes["http_signatures.algorithm"] = extra.algorithm;
 		if (extra.failureReason != null) attributes["http_signatures.failure_reason"] = extra.failureReason;
+		if (extra.verificationFailureReason != null) attributes["activitypub.verification.failure_reason"] = extra.verificationFailureReason;
 		if (extra.ldType != null) attributes["ld_signatures.type"] = extra.ldType;
 		if (extra.cryptosuite != null) attributes["object_integrity_proofs.cryptosuite"] = extra.cryptosuite;
 		this.signatureVerificationDuration.record(durationMs, attributes);
@@ -2216,12 +2318,38 @@ async function fetchPortableActorKey(cacheKey, cls, options, onCachedUnavailable
 	};
 }
 async function fetchKeyInternal(keyId, cls, options = {}) {
-	return await fetchKeyWithResult(typeof keyId === "string" ? parseKeyIdOrThrow(keyId) : keyId, cls, options, (_cacheKey, _keyId, _keyCache, _logger) => {
+	return await fetchKeyWithResult(typeof keyId === "string" ? parseKeyIdOrThrow(keyId) : keyId, cls, options, async (_cacheKey, _keyId, _keyCache, _logger) => {
+		const check = options[verificationObservation]?.check;
+		if (check != null) try {
+			const result = await _keyCache?.getFetchError?.(_cacheKey);
+			if (result != null) check.reason = {
+				type: "keyFetchError",
+				keyId: new URL(_cacheKey.href),
+				result
+			};
+		} catch {}
 		return {
 			key: null,
 			cached: true
 		};
 	}, async (error, cacheKey, keyId, keyCache, logger) => {
+		const check = options[verificationObservation]?.check;
+		if (check != null) {
+			let result;
+			try {
+				result = error instanceof FetchError && error.response != null ? {
+					status: error.response.status,
+					response: error.response.clone()
+				} : { error: error instanceof Error ? error : new Error(String(error)) };
+			} catch {
+				result = { error: error instanceof Error ? error : /* @__PURE__ */ new Error() };
+			}
+			check.reason = {
+				type: "keyFetchError",
+				keyId: new URL(cacheKey.href),
+				result
+			};
+		}
 		logger.debug("Failed to fetch key {keyId}.", {
 			keyId,
 			error
@@ -2678,6 +2806,13 @@ function detachSignature(jsonLd) {
 */
 async function verifySignature(jsonLd, options = {}) {
 	if (!hasSignature(jsonLd)) return null;
+	if (options[verificationObservation]?.attempt != null && options[verificationObservation]?.check == null) {
+		const declared = getLdSignatureObject(jsonLd)?.creator;
+		return await observeCheck(options, { mechanism: "linkedData" }, typeof declared === "string" ? declared : null, (observation) => verifySignature(jsonLd, {
+			...options,
+			[verificationObservation]: observation
+		}));
+	}
 	const sig = jsonLd.signature;
 	let signature;
 	try {
@@ -2723,6 +2858,7 @@ async function verifySignature(jsonLd, options = {}) {
 	const encoder = new TextEncoder();
 	const message = sigOptsHash + docHash;
 	const messageBytes = encoder.encode(message);
+	triedKey(options, key);
 	if (await crypto.subtle.verify("RSASSA-PKCS1-v1_5", key.publicKey, signature.slice(), messageBytes)) return key;
 	if (cached) {
 		logger$4.debug("Failed to verify with the cached key {keyId}; signature {signatureValue} is invalid.  Retrying with the freshly fetched key...", {
@@ -2734,6 +2870,7 @@ async function verifySignature(jsonLd, options = {}) {
 			keyCache: bypassKeyCacheReads(options.keyCache)
 		}));
 		if (key == null) return null;
+		triedKey(options, key);
 		return await crypto.subtle.verify("RSASSA-PKCS1-v1_5", key.publicKey, signature.slice(), messageBytes) ? key : null;
 	}
 	logger$4.debug("Failed to verify with the fetched key {keyId}; signature {signatureValue} is invalid.  Check if the key is correct or if the signed message is correct.  The message to sign is:\n{message}", {
@@ -2787,6 +2924,14 @@ async function verifyCompactJsonLd(jsonLd, options = {}) {
 	return await verifyJsonLdInternal(jsonLd, options, false);
 }
 async function verifyJsonLdInternal(jsonLd, options, compact) {
+	if (options[verificationObservation]?.attempt == null) return await observeAttempt({
+		...options,
+		[verificationObservation]: options[verificationObservation] ?? { attempts: [] }
+	}, "linkedData", (observation) => verifyJsonLdInternal(jsonLd, {
+		...options,
+		[verificationObservation]: observation
+	}, compact), (value) => value);
+	const observation = options[verificationObservation];
 	return await (options.tracerProvider ?? trace.getTracerProvider()).getTracer(name, version).startActiveSpan("ld_signatures.verify", async (span) => {
 		const start = performance.now();
 		let verified = false;
@@ -2799,6 +2944,8 @@ async function verifyJsonLdInternal(jsonLd, options, compact) {
 			} : options;
 			const compacted = compact ? hasSignature(jsonLd) ? await compactJsonLd(jsonLd, options.contextLoader) : jsonLd : jsonLd;
 			const object = await Object$1.fromJsonLd(compacted, verificationOptions);
+			observation?.parsedObject?.(object);
+			if (observation?.subject != null) observation.subject.id = object.id == null ? null : new URL(object.id.href);
 			if (object.id != null) span.setAttribute("activitypub.object.id", object.id.href);
 			span.setAttribute("activitypub.object.type", getTypeId(object).href);
 			const sig = getLdSignatureObject(jsonLd);
@@ -2813,13 +2960,21 @@ async function verifyJsonLdInternal(jsonLd, options, compact) {
 			const attributions = new Set(object.attributionIds.map((uri) => uri.href));
 			if (object instanceof Activity) for (const uri of object.actorIds) attributions.add(uri.href);
 			const key = await verifySignature(compacted, verificationOptions);
-			if (key == null) return false;
+			if (key == null) {
+				if (observation?.attempt != null && !hasLdSignatureProperty(jsonLd)) observation.attempt.reason = { type: "noSignature" };
+				return false;
+			}
 			if (key.ownerId == null) {
+				if (observation?.attempt != null) observation.attempt.reason = { type: "missingOwner" };
 				logger$4.debug("Key {keyId} has no owner.", { keyId: key.id?.href });
 				return false;
 			}
 			attributions.delete(key.ownerId.href);
 			if (attributions.size > 0) {
+				if (observation?.attempt != null) observation.attempt.reason = {
+					type: "uncoveredAttribution",
+					attributionIds: [...attributions].map((id) => new URL(id))
+				};
 				logger$4.debug("Some attributions are not authenticated by the Linked Data Signatures: {attributions}.", { attributions: [...attributions] });
 				return false;
 			}
@@ -2833,8 +2988,15 @@ async function verifyJsonLdInternal(jsonLd, options, compact) {
 			});
 			throw error;
 		} finally {
+			if (observation?.attempt?.reason != null) {
+				span.setAttribute("activitypub.verification.failure_reason", observation.attempt.reason.type);
+				span.setStatus({ code: SpanStatusCode.ERROR });
+			}
 			const classified = threw ? "error" : verified ? "verified" : hasLdSignatureProperty(jsonLd) ? "rejected" : "missing";
-			getFederationMetrics(options.meterProvider).recordSignatureVerificationDuration(getDurationMs(start), "linked_data", classified, { ldType: signatureType });
+			getFederationMetrics(options.meterProvider).recordSignatureVerificationDuration(getDurationMs(start), "linked_data", classified, {
+				ldType: signatureType,
+				verificationFailureReason: verified || threw ? void 0 : observation?.attempt?.reason?.type ?? (hasLdSignatureProperty(jsonLd) ? "signatureVerificationFailed" : "noSignature")
+			});
 			span.end();
 		}
 	});
@@ -3462,19 +3624,50 @@ async function verifyProof(jsonLd, proof, options = {}) {
 */
 async function verifyMapLocalProof(jsonLd, options = {}) {
 	if (!isJsonLdNode(jsonLd) || !globalThis.Object.hasOwn(jsonLd, "proof") || !isJsonLdNode(jsonLd.proof)) return null;
+	const rawProof = jsonLd.proof;
+	const previousChecks = options[verificationObservation]?.attempt?.checks.length;
+	const malformed = () => observeCheck(options, {
+		mechanism: "objectIntegrity",
+		proofId: typeof rawProof.id === "string" ? rawProof.id : typeof rawProof["@id"] === "string" ? rawProof["@id"] : null,
+		proofIndex: previousChecks ?? null
+	}, getDeclaredProofKeyId(rawProof), () => Promise.resolve(null));
 	const proofContextLoader = getNormalizationContextLoader(preloadedOnlyDocumentLoader);
 	try {
 		const [candidate] = await parseRawProofCandidates(jsonLd, [jsonLd.proof], options, proofContextLoader);
-		if (candidate.proof == null) return null;
+		if (candidate.proof == null) return await malformed();
 		return await verifyProofWithMessageDigestCache(jsonLd, candidate.proof, options, {
 			proofContextLoader,
 			proofPropertyMode: "literal"
 		}, candidate);
 	} catch {
+		if (previousChecks != null && options[verificationObservation]?.attempt?.checks.length === previousChecks) return await malformed();
 		return null;
 	}
 }
+function getDeclaredProofKeyId(value, propertyNames = ["verificationMethod", "https://w3id.org/security#verificationMethod"]) {
+	if (!isJsonLdNode(value)) return null;
+	const method = Array.from(propertyNames, (name) => value[name]).find((v) => v != null);
+	const candidate = Array.isArray(method) ? method[0] : method;
+	if (typeof candidate === "string") return candidate;
+	return isJsonLdNode(candidate) && typeof candidate["@id"] === "string" ? candidate["@id"] : null;
+}
 async function verifyProofWithMessageDigestCache(jsonLd, proof, options, messageDigestCache = {}, rawProofCandidate, keyIdBoundByCaller = false) {
+	if (options[verificationObservation] == null) return await verifyProofWithMessageDigestCache(jsonLd, proof, {
+		...options,
+		[verificationObservation]: {
+			attempts: [],
+			attempt: { checks: [] },
+			captureRawKeyIds: false
+		}
+	}, messageDigestCache, rawProofCandidate, keyIdBoundByCaller);
+	if (options[verificationObservation]?.attempt != null && options[verificationObservation]?.check == null) return await observeCheck(options, {
+		mechanism: "objectIntegrity",
+		proofId: proof.id?.href ?? null,
+		proofIndex: options[verificationObservation].attempt.checks.length
+	}, rawProofCandidate?.declaredKeyId ?? getDeclaredProofKeyId(rawProofCandidate?.value) ?? proof.verificationMethodId?.href ?? null, (observation) => verifyProofWithMessageDigestCache(jsonLd, proof, {
+		...options,
+		[verificationObservation]: observation
+	}, messageDigestCache, rawProofCandidate, keyIdBoundByCaller));
 	return await (options.tracerProvider ?? trace.getTracerProvider()).getTracer(name, version).startActiveSpan("object_integrity_proofs.verify", async (span) => {
 		const start = performance.now();
 		let verified = false;
@@ -3487,8 +3680,10 @@ async function verifyProofWithMessageDigestCache(jsonLd, proof, options, message
 		}
 		try {
 			const key = await verifyProofInternal(jsonLd, proof, options, messageDigestCache, rawProofCandidate, keyIdBoundByCaller);
-			if (key == null) span.setStatus({ code: SpanStatusCode.ERROR });
-			else verified = true;
+			if (key == null) {
+				span.setStatus({ code: SpanStatusCode.ERROR });
+				span.setAttribute("activitypub.verification.failure_reason", options[verificationObservation]?.check?.reason?.type ?? "invalidSignature");
+			} else verified = true;
 			return key;
 		} catch (error) {
 			threw = true;
@@ -3499,7 +3694,10 @@ async function verifyProofWithMessageDigestCache(jsonLd, proof, options, message
 			throw error;
 		} finally {
 			const classified = threw ? "error" : verified ? "verified" : "rejected";
-			getFederationMetrics(options.meterProvider).recordSignatureVerificationDuration(getDurationMs(start), "object_integrity", classified, { cryptosuite });
+			getFederationMetrics(options.meterProvider).recordSignatureVerificationDuration(getDurationMs(start), "object_integrity", classified, {
+				cryptosuite,
+				verificationFailureReason: verified || threw ? void 0 : options[verificationObservation]?.check?.reason?.type ?? "invalidSignature"
+			});
 			span.end();
 		}
 	});
@@ -3516,14 +3714,15 @@ function expandContextPropertyIri(activeContext, key) {
 	if (typeof mapping === "object" && mapping != null && mapping._prefix === true && typeof mapping["@id"] === "string") return mapping["@id"] + suffix;
 	return key;
 }
-async function getJsonLdPropertyNames(jsonLd, propertyIri, defaults, documentLoader = preloadedOnlyDocumentLoader, inheritedContext, rejectOnContextError = false) {
+async function getJsonLdPropertyNames(jsonLd, propertyIri, defaults, documentLoader = preloadedOnlyDocumentLoader, inheritedContext, rejectOnContextError = false, contextState) {
 	const names = new Set(defaults);
 	const context = jsonLd["@context"] ?? inheritedContext;
-	if (context == null) return names;
+	if (context == null && contextState?.initial == null) return names;
 	try {
 		const options = { documentLoader };
-		let activeContext = await jsonld.processContext(null, null, options);
-		activeContext = await jsonld.processContext(activeContext, context, options);
+		let activeContext = contextState?.initial ?? await jsonld.processContext(null, null, options);
+		if (contextState?.scoped != null) activeContext = await jsonld.processContext(activeContext, contextState.scoped, options);
+		if (context != null) activeContext = await jsonld.processContext(activeContext, context, options);
 		const typeScopedContext = activeContext;
 		for (const key of globalThis.Object.keys(jsonLd).sort()) {
 			if (key !== "@type" && expandContextPropertyIri(activeContext, key) !== "@type") continue;
@@ -3535,6 +3734,7 @@ async function getJsonLdPropertyNames(jsonLd, propertyIri, defaults, documentLoa
 				if (scopedContext != null) activeContext = await jsonld.processContext(activeContext, scopedContext, options);
 			}
 		}
+		if (contextState != null) contextState.active = activeContext;
 		for (const key of globalThis.Object.keys(jsonLd)) if (expandContextPropertyIri(activeContext, key) === propertyIri) names.add(key);
 	} catch {
 		if (rejectOnContextError) return null;
@@ -3601,6 +3801,36 @@ function sameBytes(left, right) {
 function sameProof(left, right) {
 	return left.cryptosuite === right.cryptosuite && left.verificationMethodId?.href === right.verificationMethodId?.href && left.proofPurpose === right.proofPurpose && sameBytes(left.proofValue, right.proofValue) && left.created?.toString() === right.created?.toString();
 }
+function recordProofContexts(documentLoader) {
+	const documents = /* @__PURE__ */ new Map();
+	return {
+		loader: async (url, options) => {
+			const document = await documentLoader(url, options);
+			documents.set(url, document);
+			return document;
+		},
+		replay: (url, options) => {
+			const document = documents.get(url);
+			return document == null ? preloadedOnlyDocumentLoader(url, options) : Promise.resolve(document);
+		}
+	};
+}
+async function getAliasedDeclaredProofKeyId(value, inheritedContext, contextLoader) {
+	if (!isJsonLdNode(value)) return null;
+	const contextState = {};
+	const names = await getJsonLdPropertyNames(value, "https://w3id.org/security#verificationMethod", ["verificationMethod", "https://w3id.org/security#verificationMethod"], contextLoader, inheritedContext, false, contextState);
+	const methodName = Array.from(names ?? []).find((name) => value[name] != null);
+	const method = methodName == null ? void 0 : value[methodName];
+	const candidate = Array.isArray(method) ? method[0] : method;
+	if (typeof candidate === "string") return candidate;
+	if (!isJsonLdNode(candidate)) return null;
+	const idNames = await getJsonLdPropertyNames(candidate, "@id", ["@id"], contextLoader, void 0, false, {
+		initial: contextState.active,
+		scoped: contextState.active == null || methodName == null ? void 0 : jsonld.getContextValue(contextState.active, methodName, "@context")
+	});
+	for (const name of idNames ?? []) if (typeof candidate[name] === "string") return candidate[name];
+	return null;
+}
 function normalizeDocumentUrl(url) {
 	try {
 		return formatIri(parseIri(url));
@@ -3619,6 +3849,7 @@ async function parseRawProofCandidates(jsonLd, values, options, documentLoader)
 	const candidates = [];
 	for (const value of values) {
 		let parsed = null;
+		const contexts = options[verificationObservation] != null && options[verificationObservation]?.captureRawKeyIds !== false ? recordProofContexts(documentLoader) : void 0;
 		if (isJsonLdNode(value)) {
 			const proofJsonLd = value["@context"] == null && jsonLd["@context"] != null ? {
 				"@context": jsonLd["@context"],
@@ -3627,14 +3858,15 @@ async function parseRawProofCandidates(jsonLd, values, options, documentLoader)
 			try {
 				parsed = await DataIntegrityProof.fromJsonLd(proofJsonLd, {
 					...options,
-					contextLoader: documentLoader
+					contextLoader: contexts?.loader ?? documentLoader
 				});
 			} catch {}
 		}
 		candidates.push({
 			value,
 			proof: parsed,
-			reference: getRawProofReference(value) ?? parsed?.id?.href
+			reference: getRawProofReference(value) ?? parsed?.id?.href,
+			declaredKeyId: contexts == null ? void 0 : await getAliasedDeclaredProofKeyId(value, jsonLd["@context"], contexts.replay)
 		});
 	}
 	return candidates;
@@ -3858,8 +4090,13 @@ async function verifyProofInternal(jsonLd, proof, options, messageDigestCache, r
 	const digest = new Uint8Array(proofDigest.byteLength + 32);
 	digest.set(new Uint8Array(proofDigest), 0);
 	const proofValue = proof.proofValue;
+	let keyTried = false;
 	const verifyCandidate = async (msgDigest) => {
 		digest.set(new Uint8Array(msgDigest), proofDigest.byteLength);
+		if (!keyTried) {
+			triedKey(options, publicKey);
+			keyTried = true;
+		}
 		return await crypto.subtle.verify("Ed25519", publicKey.publicKey, proofValue.slice(), digest);
 	};
 	const messageDigestKey = serialize(proofConfiguration.context ?? null);
@@ -3904,7 +4141,6 @@ const FEP_2277_COLLECTION_PROPERTIES = [
 	"prev",
 	"current"
 ].map((property) => AS_NAMESPACE + property);
-const FEP_EF61_GATEWAYS = "https://w3id.org/fep/ef61/gateways";
 const PORTABLE_OBJECT_ID_PATTERN = /^ap(?:\+ef61)?:\/\//i;
 const FUNCTIONAL_PROOF_PROPERTIES = [
 	`${SECURITY_NAMESPACE}cryptosuite`,
@@ -3935,14 +4171,15 @@ function hasValidPortableProofShape(proofValue) {
 * FEP-ef61 requires: a non-empty list whose items are all HTTP(S) URIs with
 * an empty path, query, and fragment.  Like the generated vocabulary decoder,
 * this also tolerates a plain set of values instead of a `@list`, and gateway
-* strings given as `@value`s instead of `@id`s.
+* strings given as `@value`s instead of `@id`s.  JCS-authenticated actors may
+* also supply an unmapped literal `gateways` list.
 */
-function hasValidPortableActorGateways(node) {
-	const values = node[FEP_EF61_GATEWAYS];
+function hasValidPortableActorGateways(node, allowUnmapped) {
+	const values = getPortableActorGateways(node, allowUnmapped);
 	if (!Array.isArray(values)) return false;
 	let items = values;
 	if (values.some((value) => isJsonLdNode(value) && "@list" in value)) {
-		if (values.length !== 1) return false;
+		if (values.length !== 1 || !isJsonLdNode(values[0])) return false;
 		items = values[0]["@list"];
 	}
 	if (!Array.isArray(items) || items.length < 1) return false;
@@ -4163,7 +4400,7 @@ async function preparePortableObjectProof(jsonLd, options) {
 			}
 		};
 	}
-	if (objectType === "actor" && !hasValidPortableActorGateways(root)) return {
+	if (objectType === "actor" && !hasValidPortableActorGateways(root, proofs.every((proof) => proof.cryptosuite === "eddsa-jcs-2022"))) return {
 		prepared: false,
 		root,
 		objectType,
@@ -4230,6 +4467,8 @@ async function verifyPortableObjectProofPolicy(jsonLd, key, options = {}) {
 * and fragment; otherwise, it is rejected with the `invalidGateways` reason
 * before its proofs are verified.  The proofs are verified over the document as
 * given; a compatible identifier is never rewritten into a portable ID.
+* An unmapped literal `gateways` property is also accepted when every proof
+* uses `eddsa-jcs-2022`, which authenticates the original JSON properties.
 *
 * [FEP-ef61]: https://w3id.org/fep/ef61
 *
@@ -4315,12 +4554,47 @@ async function verifyPreparedPortableObjectProof(jsonLd, prepared, options, mess
 * @since 0.10.0
 */
 async function verifyObject(cls, jsonLd, options = {}) {
+	if (options[verificationObservation]?.attempt == null) {
+		const observedOptions = {
+			...options,
+			[verificationObservation]: options[verificationObservation] ?? {
+				attempts: [],
+				captureRawKeyIds: false
+			}
+		};
+		return await (options.tracerProvider ?? trace.getTracerProvider()).getTracer(name, version).startActiveSpan("object_integrity_proofs.verify_object", async (span) => {
+			try {
+				return await observeAttempt(observedOptions, "objectIntegrity", async (observation) => {
+					const object = await verifyObject(cls, jsonLd, {
+						...options,
+						[verificationObservation]: observation
+					});
+					if (object == null) {
+						span.setStatus({ code: SpanStatusCode.ERROR });
+						span.setAttribute("activitypub.verification.failure_reason", observation.attempt?.reason?.type ?? "signatureVerificationFailed");
+					}
+					return object;
+				}, (value) => value != null);
+			} catch (error) {
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: String(error)
+				});
+				throw error;
+			} finally {
+				span.end();
+			}
+		});
+	}
+	const observation = options[verificationObservation];
 	const logger = getLogger([
 		"fedify",
 		"sig",
 		"proof"
 	]);
 	const object = await cls.fromJsonLd(jsonLd, options);
+	observation?.parsedObject?.(object);
+	if (observation?.subject != null) observation.subject.id = object.id == null ? null : new URL(object.id.href);
 	const defaultDocumentLoader = getDocumentLoader();
 	const proofContextLoader = options.contextLoader ?? defaultDocumentLoader;
 	const attributions = new Set(object.attributionIds.map((uri) => uri.href));
@@ -4347,10 +4621,11 @@ async function verifyObject(cls, jsonLd, options = {}) {
 		if (candidateIndex >= 0) {
 			hydratedCandidates.add(candidateIndex);
 			let parsed = null;
+			const contexts = options[verificationObservation] != null && options[verificationObservation]?.captureRawKeyIds !== false ? recordProofContexts(proofContextLoader) : void 0;
 			try {
 				parsed = await DataIntegrityProof.fromJsonLd(remoteDocument.document, {
 					documentLoader: baseDocumentLoader,
-					contextLoader: proofContextLoader,
+					contextLoader: contexts?.loader ?? proofContextLoader,
 					tracerProvider: options.tracerProvider,
 					baseUrl: parseIri(remoteDocument.documentUrl)
 				});
@@ -4358,7 +4633,8 @@ async function verifyObject(cls, jsonLd, options = {}) {
 			rawProofCandidates[candidateIndex] = {
 				value: structuredClone(remoteDocument.document),
 				proof: parsed,
-				reference
+				reference,
+				declaredKeyId: contexts == null ? void 0 : await getAliasedDeclaredProofKeyId(remoteDocument.document, void 0, contexts.replay)
 			};
 		}
 		return remoteDocument;
@@ -4386,6 +4662,10 @@ async function verifyObject(cls, jsonLd, options = {}) {
 		return null;
 	}
 	if (attributions.size > 0) {
+		if (observation?.attempt != null) observation.attempt.reason = observation.attempt.checks.length === 0 ? { type: "noSignature" } : {
+			type: "uncoveredAttribution",
+			attributionIds: [...attributions].map((id) => new URL(id))
+		};
 		logger.debug("Some attributions are not authenticated by the proofs: {attributions}.", { attributions: [...attributions] });
 		return null;
 	}
@@ -5405,6 +5685,14 @@ async function verifyRequest(request, options = {}) {
 * @since 2.1.0
 */
 async function verifyRequestDetailed(request, options = {}) {
+	if (options[verificationObservation] != null && options[verificationObservation]?.attempt == null) return await observeAttempt(options, "http", async (observation) => {
+		const result = await verifyRequestDetailed(request, {
+			...options,
+			[verificationObservation]: observation
+		});
+		if (!result.verified) observation.attempt.reason = result.reason.type === "noSignature" ? { type: "noSignature" } : { type: "signatureVerificationFailed" };
+		return result;
+	}, (result) => result.verified);
 	if (options.maxSignatures !== void 0) validateMaxSignatures(options.maxSignatures, "maxSignatures");
 	return await (options.tracerProvider ?? trace.getTracerProvider()).getTracer(name, version).startActiveSpan("http_signatures.verify", async (span) => {
 		if (span.isRecording()) {
@@ -5443,7 +5731,27 @@ async function verifyRequestDetailed(request, options = {}) {
 		}
 	});
 }
-async function verifyRequestDraft(request, span, metricsContext, { documentLoader, contextLoader, timeWindow, currentTime, keyCache, meterProvider, tracerProvider } = {}) {
+async function verifyRequestDraft(request, span, metricsContext, options = {}) {
+	if (options[verificationObservation]?.check != null) return await verifyRequestDraftInternal(request, span, metricsContext, options);
+	let result = noSignatureResult();
+	const raw = request.headers.get("Signature");
+	const declared = raw == null ? null : parseDraftSignature(raw)?.keyId ?? null;
+	if (raw == null) return result;
+	await observeCheck(options, {
+		mechanism: "http",
+		spec: "draft-cavage-http-signatures-12",
+		label: null
+	}, declared, async (observation) => {
+		result = await verifyRequestDraftInternal(request, span, metricsContext, {
+			...options,
+			[verificationObservation]: observation
+		});
+		if (!result.verified && result.reason.type === "keyFetchError" && observation.check != null) observation.check.reason = result.reason;
+		return result.verified ? result.key : null;
+	});
+	return result;
+}
+async function verifyRequestDraftInternal(request, span, metricsContext, { documentLoader, contextLoader, timeWindow, currentTime, keyCache, meterProvider, tracerProvider, [verificationObservation]: observation } = {}) {
 	const logger = getLogger([
 		"fedify",
 		"sig",
@@ -5624,6 +5932,7 @@ async function verifyRequestDraft(request, span, metricsContext, { documentLoade
 	const message = headerNames.map((name) => `${name}: ` + (name === "(request-target)" ? `${request.method.toLowerCase()} ${new URL(request.url).pathname}` : name === "(created)" ? sigValues.created ?? "" : name === "(expires)" ? sigValues.expires ?? "" : name === "host" ? request.headers.get("host") ?? new URL(request.url).host : request.headers.get(name))).join("\n");
 	const sig = decodeBase64(signature);
 	span?.setAttribute("http_signatures.signature", encodeHex(sig));
+	triedKey({ [verificationObservation]: observation }, key);
 	if (!await crypto.subtle.verify("RSASSA-PKCS1-v1_5", key.publicKey, sig, new TextEncoder().encode(message))) {
 		if (cached) {
 			logger.debug("Failed to verify with the cached key {keyId}; signature {signature} is invalid.  Retrying with the freshly fetched key...", {
@@ -5638,7 +5947,8 @@ async function verifyRequestDraft(request, span, metricsContext, { documentLoade
 				currentTime,
 				keyCache: bypassKeyCacheReads(keyCache),
 				meterProvider,
-				tracerProvider
+				tracerProvider,
+				[verificationObservation]: observation
 			});
 		}
 		logger.debug("Failed to verify with the fetched key {keyId}; signature {signature} is invalid.  Check if the key is correct or if the signed message is correct.  The message to sign is:\n{message}", {
@@ -5724,7 +6034,7 @@ async function verifyRfc9421ContentDigest(digestHeader, body) {
 * @returns Whether the signature is verified, and the algorithm of the
 *          signature if it is supported.
 */
-async function verifyRfc9421SignatureWithKey(request, sigInput, sigBytes, key, span) {
+async function verifyRfc9421SignatureWithKey(request, sigInput, sigBytes, key, span, observationOptions = {}) {
 	const logger = getLogger([
 		"fedify",
 		"sig",
@@ -5780,6 +6090,7 @@ async function verifyRfc9421SignatureWithKey(request, sigInput, sigBytes, key, s
 	}
 	let verified;
 	try {
+		triedKey(observationOptions, key);
 		verified = await crypto.subtle.verify(algorithm, key.publicKey, sigBytes.slice(), signatureBaseBytes);
 	} catch (error) {
 		logger.debug("Error during signature verification: {error}", {
@@ -5807,7 +6118,7 @@ async function verifyRfc9421SignatureWithKey(request, sigInput, sigBytes, key, s
 		mismatched: true
 	};
 }
-async function verifyRequestRfc9421(request, span, metricsContext, { documentLoader, contextLoader, timeWindow, currentTime, keyCache, maxSignatures = 3, meterProvider, tracerProvider } = {}) {
+async function verifyRequestRfc9421(request, span, metricsContext, { documentLoader, contextLoader, timeWindow, currentTime, keyCache, maxSignatures = 3, [verificationObservation]: observation, meterProvider, tracerProvider } = {}) {
 	const logger = getLogger([
 		"fedify",
 		"sig",
@@ -5871,105 +6182,116 @@ async function verifyRequestRfc9421(request, span, metricsContext, { documentLoa
 	let body = null;
 	let digestValid = null;
 	for (const sigName of signatureNames) {
-		if (!signatures[sigName]) {
-			setFailure(invalidSignatureResult(parseKeyId(signatureInputs[sigName]?.keyId)));
-			continue;
-		}
-		const sigInput = signatureInputs[sigName];
-		const sigBytes = signatures[sigName];
-		const keyId = parseKeyId(sigInput.keyId);
-		if (!sigInput.keyId) {
-			logger.debug("Failed to verify; missing keyId in signature {signatureName}.", {
-				signatureName: sigName,
-				signatureInput: signatureInputHeader
-			});
-			setFailure(invalidSignatureResult(null));
-			continue;
-		}
-		if (!sigInput.created) {
-			logger.debug("Failed to verify; missing created timestamp in signature {signatureName}.", {
-				signatureName: sigName,
-				signatureInput: signatureInputHeader
-			});
-			setFailure(invalidSignatureResult(keyId));
-			continue;
-		}
-		const signatureCreated = Temporal.Instant.fromEpochMilliseconds(sigInput.created * 1e3);
-		const now = currentTime ?? Temporal.Now.instant();
-		if (timeWindow !== false) {
-			const tw = timeWindow ?? { hours: 1 };
-			if (Temporal.Instant.compare(signatureCreated, now.add(tw)) > 0) {
-				logger.debug("Failed to verify; signature created time is too far in the future.", {
-					created: signatureCreated.toString(),
-					now: now.toString()
-				});
-				setFailure(invalidSignatureResult(keyId));
-				continue;
-			} else if (Temporal.Instant.compare(signatureCreated, now.subtract(tw)) < 0) {
-				logger.debug("Failed to verify; signature created time is too far in the past.", {
-					created: signatureCreated.toString(),
-					now: now.toString()
-				});
-				setFailure(invalidSignatureResult(keyId));
-				continue;
+		let winning;
+		await observeCheck({ [verificationObservation]: observation }, {
+			mechanism: "http",
+			spec: "rfc9421",
+			label: sigName
+		}, signatureInputs[sigName]?.keyId ?? null, async (candidateObservation) => {
+			if (!signatures[sigName]) {
+				setFailure(invalidSignatureResult(parseKeyId(signatureInputs[sigName]?.keyId)));
+				return null;
 			}
-		}
-		if (request.method !== "GET" && request.method !== "HEAD" && sigInput.components.some((c) => c.value === "content-digest")) {
-			const contentDigestHeader = request.headers.get("Content-Digest");
-			if (!contentDigestHeader) {
-				logger.debug("Failed to verify; Content-Digest header required but not found.", { components: sigInput.components });
-				setFailure(invalidSignatureResult(keyId));
-				continue;
+			const sigInput = signatureInputs[sigName];
+			const sigBytes = signatures[sigName];
+			const keyId = parseKeyId(sigInput.keyId);
+			if (!sigInput.keyId) {
+				logger.debug("Failed to verify; missing keyId in signature {signatureName}.", {
+					signatureName: sigName,
+					signatureInput: signatureInputHeader
+				});
+				setFailure(invalidSignatureResult(null));
+				return null;
 			}
-			body ??= await request.arrayBuffer();
-			digestValid ??= await verifyRfc9421ContentDigest(contentDigestHeader, body);
-			if (!digestValid) {
-				logger.debug("Failed to verify; Content-Digest verification failed.", { contentDigest: contentDigestHeader });
+			if (!sigInput.created) {
+				logger.debug("Failed to verify; missing created timestamp in signature {signatureName}.", {
+					signatureName: sigName,
+					signatureInput: signatureInputHeader
+				});
 				setFailure(invalidSignatureResult(keyId));
-				continue;
+				return null;
 			}
-		}
-		span?.setAttribute("http_signatures.key_id", sigInput.keyId);
-		span?.setAttribute("http_signatures.created", sigInput.created.toString());
-		if (keyId == null) {
-			setFailure(invalidSignatureResult(null));
-			continue;
-		}
-		let lookup = keyLookups.get(keyId.href);
-		if (lookup == null) {
-			lookup = await lookUpKey(keyId, keyCache);
-			keyLookups.set(keyId.href, lookup);
-		}
-		while (true) {
-			const { key, cached, fetchError } = lookup;
-			if (fetchError != null) {
-				setFailure(keyFetchErrorResult(keyId, fetchError));
-				break;
+			const signatureCreated = Temporal.Instant.fromEpochMilliseconds(sigInput.created * 1e3);
+			const now = currentTime ?? Temporal.Now.instant();
+			if (timeWindow !== false) {
+				const tw = timeWindow ?? { hours: 1 };
+				if (Temporal.Instant.compare(signatureCreated, now.add(tw)) > 0) {
+					logger.debug("Failed to verify; signature created time is too far in the future.", {
+						created: signatureCreated.toString(),
+						now: now.toString()
+					});
+					setFailure(invalidSignatureResult(keyId));
+					return null;
+				} else if (Temporal.Instant.compare(signatureCreated, now.subtract(tw)) < 0) {
+					logger.debug("Failed to verify; signature created time is too far in the past.", {
+						created: signatureCreated.toString(),
+						now: now.toString()
+					});
+					setFailure(invalidSignatureResult(keyId));
+					return null;
+				}
 			}
-			if (!key) {
-				logger.debug("Failed to fetch key: {keyId}", { keyId: sigInput.keyId });
-				setFailure(invalidSignatureResult(keyId));
-				break;
+			if (request.method !== "GET" && request.method !== "HEAD" && sigInput.components.some((c) => c.value === "content-digest")) {
+				const contentDigestHeader = request.headers.get("Content-Digest");
+				if (!contentDigestHeader) {
+					logger.debug("Failed to verify; Content-Digest header required but not found.", { components: sigInput.components });
+					setFailure(invalidSignatureResult(keyId));
+					return null;
+				}
+				body ??= await request.arrayBuffer();
+				digestValid ??= await verifyRfc9421ContentDigest(contentDigestHeader, body);
+				if (!digestValid) {
+					logger.debug("Failed to verify; Content-Digest verification failed.", { contentDigest: contentDigestHeader });
+					setFailure(invalidSignatureResult(keyId));
+					return null;
+				}
 			}
-			const result = await verifyRfc9421SignatureWithKey(request, sigInput, sigBytes, key, span);
-			if (result.verified) {
-				metricsContext.algorithm = result.algorithm;
-				return {
-					verified: true,
-					key,
-					signatureLabel: sigName
-				};
+			span?.setAttribute("http_signatures.key_id", sigInput.keyId);
+			span?.setAttribute("http_signatures.created", sigInput.created.toString());
+			if (keyId == null) {
+				setFailure(invalidSignatureResult(null));
+				return null;
 			}
-			if (result.mismatched && cached && !refreshedKeyIds.has(keyId.href)) {
-				logger.debug("Failed to verify with cached key {keyId}; retrying with fresh key...", { keyId: sigInput.keyId });
-				refreshedKeyIds.add(keyId.href);
-				lookup = await lookUpKey(keyId, bypassKeyCacheReads(keyCache));
+			let lookup = keyLookups.get(keyId.href);
+			if (lookup == null) {
+				lookup = await lookUpKey(keyId, keyCache);
 				keyLookups.set(keyId.href, lookup);
-				continue;
 			}
-			setFailure(invalidSignatureResult(keyId), result.algorithm);
-			break;
-		}
+			while (true) {
+				const { key, cached, fetchError } = lookup;
+				if (fetchError != null) {
+					setFailure(keyFetchErrorResult(keyId, fetchError));
+					break;
+				}
+				if (!key) {
+					logger.debug("Failed to fetch key: {keyId}", { keyId: sigInput.keyId });
+					setFailure(invalidSignatureResult(keyId));
+					break;
+				}
+				const result = await verifyRfc9421SignatureWithKey(request, sigInput, sigBytes, key, span, { [verificationObservation]: candidateObservation });
+				if (result.verified) {
+					metricsContext.algorithm = result.algorithm;
+					winning = {
+						verified: true,
+						key,
+						signatureLabel: sigName
+					};
+					return key;
+				}
+				if (result.mismatched && cached && !refreshedKeyIds.has(keyId.href)) {
+					logger.debug("Failed to verify with cached key {keyId}; retrying with fresh key...", { keyId: sigInput.keyId });
+					refreshedKeyIds.add(keyId.href);
+					lookup = await lookUpKey(keyId, bypassKeyCacheReads(keyCache));
+					keyLookups.set(keyId.href, lookup);
+					continue;
+				}
+				setFailure(invalidSignatureResult(keyId), result.algorithm);
+				break;
+			}
+			if (!failure.verified && failure.reason.type === "keyFetchError" && candidateObservation.check != null) candidateObservation.check.reason = failure.reason;
+			return null;
+		});
+		if (winning != null) return winning;
 	}
 	metricsContext.algorithm = failureAlgorithm;
 	return failure;
@@ -6202,4 +6524,4 @@ function timingSafeEqual(a, b) {
 	return result === 0;
 }
 //#endregion
-export { instrumentDocumentLoader as $, hasSignature as A, name as At, fetchActorDocument as B, InvalidContextReferenceError as C, hasPortableActor as Ct, createSignature as D, isPortableUri as Dt, compactJsonLd as E, isPortableKeyId as Et, verifyCompactJsonLd as F, validateCryptoKey as G, fetchKeyDetailed as H, verifyJsonLd as I, getVerifiedKeyOwnerEvidence as J, verifyKeyOwnership as K, verifySignature as L, isClearlyMalformedContextReference as M, isInvalidUrlTypeError as N, detachSignature as O, isSameObjectId as Ot, signJsonLd as P, getRemoteHost as Q, wrapContextLoaderForJsonLd as R, normalizeOutgoingActivityJsonLd as S, getRawCanonicalPortableId as St, attachSignature as T, isPortableId as Tt, generateCryptoKeyPair as U, fetchKey as V, importJwk as W, getDurationMs as X, parseKeyOwnerEvidence as Y, getFederationMetrics as Z, verifyObject as _, validateAcceptSignature as _t, signRequest as a, recordCollectionTotalItems as at, verifyPortableObjectProofWithRoot as b, getGatewayKeyBase as bt, verifyRequestDetailed as c, recordInboxActivity as ct, InvalidPortableObjectIdError as d, recordWebFingerHandle as dt, isAbortError$1 as et, classifyFep2277CoreType as f, registerQueueDepthGauge as ft, verifyMapLocalProof as g, parseAcceptSignature as gt, signObject as h, fulfillAcceptSignature as ht, selectRequestSignature as i, recordCollectionRequest as it, hasSignatureLike as j, version as jt, getNormalizationContextLoader as k, isSamePublicKey as kt, fetchPortableGatewayKey as l, recordOutboxActivity as lt, hasProofLike as m, formatAcceptSignature as mt, listRequestSignatures as n, recordCollectionDispatchDuration as nt, validateMaxSignatures as o, recordDocumentCache as ot, createProof as p, preloadedOnlyDocumentLoader as pt, MAX_PORTABLE_KEY_TTL as q, parseRfc9421SignatureInput as r, recordCollectionPageItems as rt, verifyRequest as s, recordFanoutRecipients as st, doubleKnock as t, recordCircuitBreakerStateChange as tt, resolvePortableActorKey as u, recordOutboxEnqueue as ut, verifyPortableObjectProof as v, getAuthenticationOrigin as vt, assertSafeJsonLd as w, isCompatibleKeyId as wt, verifyProof as x, getPortableDid as xt, verifyPortableObjectProofPolicy as y, getCanonicalPortableId as yt, exportJwk as z };
+export { instrumentDocumentLoader as $, hasSignature as A, isPortableUri as At, fetchActorDocument as B, InvalidContextReferenceError as C, getGatewayKeyBase as Ct, createSignature as D, isCompatibleKeyId as Dt, compactJsonLd as E, hasPortableActor as Et, verifyCompactJsonLd as F, validateCryptoKey as G, fetchKeyDetailed as H, verifyJsonLd as I, getVerifiedKeyOwnerEvidence as J, verifyKeyOwnership as K, verifySignature as L, isClearlyMalformedContextReference as M, isSamePublicKey as Mt, isInvalidUrlTypeError as N, name as Nt, detachSignature as O, isPortableId as Ot, signJsonLd as P, version as Pt, getRemoteHost as Q, wrapContextLoaderForJsonLd as R, normalizeOutgoingActivityJsonLd as S, getCanonicalPortableId as St, attachSignature as T, getRawCanonicalPortableId as Tt, generateCryptoKeyPair as U, fetchKey as V, importJwk as W, getDurationMs as X, parseKeyOwnerEvidence as Y, getFederationMetrics as Z, verifyObject as _, validateAcceptSignature as _t, signRequest as a, recordCollectionTotalItems as at, verifyPortableObjectProofWithRoot as b, verificationObservation as bt, verifyRequestDetailed as c, recordInboxActivity as ct, InvalidPortableObjectIdError as d, recordWebFingerHandle as dt, isAbortError$1 as et, classifyFep2277CoreType as f, registerQueueDepthGauge as ft, verifyMapLocalProof as g, parseAcceptSignature as gt, signObject as h, fulfillAcceptSignature as ht, selectRequestSignature as i, recordCollectionRequest as it, hasSignatureLike as j, isSameObjectId as jt, getNormalizationContextLoader as k, isPortableKeyId as kt, fetchPortableGatewayKey as l, recordOutboxActivity as lt, hasProofLike as m, formatAcceptSignature as mt, listRequestSignatures as n, recordCollectionDispatchDuration as nt, validateMaxSignatures as o, recordDocumentCache as ot, createProof as p, preloadedOnlyDocumentLoader as pt, MAX_PORTABLE_KEY_TTL as q, parseRfc9421SignatureInput as r, recordCollectionPageItems as rt, verifyRequest as s, recordFanoutRecipients as st, doubleKnock as t, recordCircuitBreakerStateChange as tt, resolvePortableActorKey as u, recordOutboxEnqueue as ut, verifyPortableObjectProof as v, observeAttempt as vt, assertSafeJsonLd as w, getPortableDid as wt, verifyProof as x, getAuthenticationOrigin as xt, verifyPortableObjectProofPolicy as y, snapshotKey as yt, exportJwk as z };