@fedify/fedify 2.4.0-dev.2027 → 2.4.0-dev.2030

package/dist/{middleware-BsYD_ufs.mjs → middleware-C7_hqDnl.mjs}

@@ -1,27 +1,27 @@
 import { Temporal } from "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as version, t as name } from "./deno-BcZNXlJn.mjs";
-import { a as instrumentDocumentLoader, b as recordWebFingerHandle, c as recordCircuitBreakerStateChange, d as recordCollectionRequest, f as recordCollectionTotalItems, g as recordInboxActivity, h as recordFanoutRecipients, i as getRemoteHost, l as recordCollectionDispatchDuration, n as getDurationMs, o as isAbortError, r as getFederationMetrics, u as recordCollectionPageItems, v as recordOutboxActivity, x as registerQueueDepthGauge, y as recordOutboxEnqueue } from "./metrics-D7RydU_p.mjs";
+import { n as version, t as name } from "./deno-Vj_9wePq.mjs";
+import { a as instrumentDocumentLoader, b as recordWebFingerHandle, c as recordCircuitBreakerStateChange, d as recordCollectionRequest, f as recordCollectionTotalItems, g as recordInboxActivity, h as recordFanoutRecipients, i as getRemoteHost, l as recordCollectionDispatchDuration, n as getDurationMs, o as isAbortError, r as getFederationMetrics, u as recordCollectionPageItems, v as recordOutboxActivity, x as registerQueueDepthGauge, y as recordOutboxEnqueue } from "./metrics-DpQqUAmh.mjs";
 import { t as formatAcceptSignature } from "./accept-CPVqki78.mjs";
-import { o as importJwk, s as validateCryptoKey, t as exportJwk } from "./key-Xb1hVVZO.mjs";
-import { l as verifyRequest, o as parseRfc9421SignatureInput, u as verifyRequestDetailed } from "./http-fIK5D83n.mjs";
-import { t as getAuthenticatedDocumentLoader } from "./docloader-iHi0-9mK.mjs";
-import { n as kvCache } from "./kv-cache-CU1rmQFB.mjs";
+import { o as importJwk, s as validateCryptoKey, t as exportJwk } from "./key-B_Zc5Jbd.mjs";
+import { l as verifyRequest, o as parseRfc9421SignatureInput, u as verifyRequestDetailed } from "./http-D4WPcJUe.mjs";
+import { t as getAuthenticatedDocumentLoader } from "./docloader-qUudHZVH.mjs";
+import { n as kvCache } from "./kv-cache-BXdT7pJQ.mjs";
 import { r as normalizeOutgoingActivityJsonLd } from "./outgoing-jsonld-4IJqPYos.mjs";
 import { d as readBoundedText, l as BodyTooLargeError, t as getNodeInfo, u as MAX_BODY_SIZE } from "./client-DpnpgjyX.mjs";
 import { t as nodeInfoToJson } from "./types-DE_LV1JB.mjs";
-import { _ as wrapContextLoaderForJsonLd, a as compactJsonLd, c as getNormalizationContextLoader, d as isClearlyMalformedContextReference, f as isInvalidUrlTypeError, l as hasSignature, m as verifyCompactJsonLd, p as signJsonLd, r as assertSafeJsonLd, s as detachSignature, t as InvalidContextReferenceError, u as hasSignatureLike } from "./ld-DFHvxLtx.mjs";
-import { n as getKeyOwner, t as doesActorOwnKey } from "./owner-D53bUI-n.mjs";
-import { a as verifyObject, n as hasProofLike, r as signObject } from "./proof-4ADU3qy0.mjs";
-import { n as extractInboxes, r as sendActivity, t as SendActivityError } from "./send-n-W6bG7y.mjs";
-import { n as FederationBuilderImpl, t as ACTOR_ALIAS_PREFIX } from "./builder-BM255b90.mjs";
+import { _ as wrapContextLoaderForJsonLd, a as compactJsonLd, c as getNormalizationContextLoader, d as isClearlyMalformedContextReference, f as isInvalidUrlTypeError, l as hasSignature, m as verifyCompactJsonLd, p as signJsonLd, r as assertSafeJsonLd, s as detachSignature, t as InvalidContextReferenceError, u as hasSignatureLike } from "./ld-B16KUSIQ.mjs";
+import { n as getKeyOwner, t as doesActorOwnKey } from "./owner-BIOIhZoM.mjs";
+import { a as verifyObject, n as hasProofLike, r as signObject } from "./proof-BVxJu5vv.mjs";
+import { n as extractInboxes, r as sendActivity, t as SendActivityError } from "./send-Cr5FJ7iu.mjs";
+import { n as FederationBuilderImpl, t as ACTOR_ALIAS_PREFIX } from "./builder-BYJ5otJa.mjs";
 import { t as CircuitBreaker } from "./circuit-breaker-C5NqoLBJ.mjs";
 import { t as buildCollectionSynchronizationHeader } from "./collection-CnnP1UAv.mjs";
-import { n as inspectCompoundPortableObjectApplicability, r as verifyCompoundPortableObjectProofs } from "./compound-proof-CPvNisT2.mjs";
+import { a as verifyCompoundPortableObjectProofs, i as inspectCompoundPortableObjectApplicability, r as findUnsupportedCompoundProofShape, t as containsCompoundPortableObject } from "./compound-proof-BIvUoJxm.mjs";
 import { t as KvKeyCache } from "./keycache-BUDHB5rY.mjs";
 import { t as acceptsJsonLd } from "./negotiation-CCocWT_N.mjs";
-import { t as hasMalformedKnownTemporalLiteral } from "./temporal-BFUyXrYg.mjs";
+import { t as hasMalformedKnownTemporalLiteral } from "./temporal-CCf0lZV3.mjs";
 import { t as createExponentialBackoffPolicy } from "./retry-zX5xw5e0.mjs";
 import { t as TaskCodec } from "./codec-C6rTrpIp.mjs";
 import { getLogger, withContext } from "@logtape/logtape";
@@ -30,7 +30,7 @@ import { Activity, Collection, CollectionPage, CryptographicKey, Link, Multikey,
 import { lookupWebFinger } from "@fedify/webfinger";
 import { SpanKind, SpanStatusCode, context, metrics, propagation, trace } from "@opentelemetry/api";
 import { uniq } from "es-toolkit";
-import { FetchError, getDocumentLoader } from "@fedify/vocab-runtime";
+import { FetchError, getDocumentLoader, getFe34Origin, haveSameFe34Origin } from "@fedify/vocab-runtime";
 import { ATTR_HTTP_REQUEST_HEADER, ATTR_HTTP_REQUEST_METHOD, ATTR_HTTP_RESPONSE_HEADER, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_URL_FULL } from "@opentelemetry/semantic-conventions";
 import { DataPointType, MeterProvider as MeterProvider$1, MetricReader } from "@opentelemetry/sdk-metrics";
 import { domainToASCII } from "node:url";
@@ -2326,6 +2326,102 @@ const MIN_COMPONENTS = [
 	"@authority"
 ];
 //#endregion
+//#region src/federation/outgoing-proof.ts
+function isPortableUrl(url) {
+	return url.protocol === "ap:" || url.protocol === "ap+ef61:";
+}
+function formatKeyIds(candidates) {
+	return candidates.map((c) => c.verificationMethod.href).join(", ");
+}
+/**
+* Creates the Object Integrity Proofs Fedify attaches to an outgoing activity.
+*
+* Outside the map-local compound-proof profile, i.e., when the activity
+* embeds no portable object, every Ed25519 key signs the activity, as it
+* always has.  Inside the profile, which accepts exactly one direct proof per
+* map, Fedify creates at most one proof:
+*
+*  -  An activity that already carries a proof is kept as is.
+*  -  A single Ed25519 key signs the activity.
+*  -  With several Ed25519 keys, a portable activity is signed by the one key
+*     whose verification method is a DID URL for the activity's DID, the only
+*     proof the FEP-ef61 policy can accept.  If no key or more than one key
+*     qualifies, or the activity is not portable itself, the choice is
+*     ambiguous and this function throws.
+*
+* @throws {TypeError} If a single proof key cannot be chosen.
+* @internal
+*/
+async function signOutgoingActivity(activity, candidates, options) {
+	const { contextLoader, tracerProvider } = options;
+	let hasProof = false;
+	for await (const _ of activity.getProofs({ contextLoader })) {
+		hasProof = true;
+		break;
+	}
+	const keys = candidates.filter((c) => c.privateKey.algorithm.name === "Ed25519");
+	if (keys.length < 1 || hasProof && !options.appendToExistingProofs) return {
+		activity,
+		hasProof,
+		proofCreated: false
+	};
+	const sign = async (selected) => {
+		for (const { verificationMethod, privateKey } of selected) activity = await signObject(activity, privateKey, verificationMethod, {
+			contextLoader,
+			tracerProvider
+		});
+		return {
+			activity,
+			hasProof: true,
+			proofCreated: true
+		};
+	};
+	if (keys.length < 2 && !hasProof) return await sign(keys);
+	if (!containsCompoundPortableObject(await activity.toJsonLd({
+		format: "compact",
+		contextLoader
+	}))) return await sign(keys);
+	const logger = getLogger([
+		"fedify",
+		"federation",
+		"outbox"
+	]);
+	const activityId = activity.id?.href;
+	if (hasProof) {
+		logger.debug("The activity {activityId} embeds portable objects and already carries a proof, so no further proof is added; the map-local compound-proof profile accepts exactly one direct proof per map.", { activityId });
+		return {
+			activity,
+			hasProof,
+			proofCreated: false
+		};
+	}
+	if (activity.id == null || !isPortableUrl(activity.id)) throw new TypeError(`Cannot choose an Object Integrity Proof key for the activity ${activityId}: it embeds portable objects, so it falls under the map-local compound-proof profile, which accepts exactly one direct proof per map, but ${keys.length} Ed25519 keys were supplied (${formatKeyIds(keys)}).  Send it with explicit sender keys that contain exactly one Ed25519 key (RSA keys for HTTP Signatures may stay), or sign it with signObject() before sending it.`);
+	const activityDid = getFe34Origin(activity.id);
+	const eligible = keys.filter((c) => c.verificationMethod.protocol === "did:" && haveSameFe34Origin(activity.id, c.verificationMethod));
+	if (eligible.length !== 1) throw new TypeError(`Cannot choose an Object Integrity Proof key for the portable activity ${activityId}: ` + (eligible.length < 1 ? `none of its ${keys.length} Ed25519 keys (${formatKeyIds(keys)}) ` : `${eligible.length} of its Ed25519 keys (${formatKeyIds(eligible)}) `) + `${eligible.length < 1 ? "is" : "are"} a DID URL verification method for ${activityDid}.  The map-local compound-proof profile accepts exactly one direct proof per map, and FEP-ef61 requires that proof's verification method to be a DID URL for the activity's DID.  Supply exactly one Ed25519 key whose key ID is a DID URL for ${activityDid}, or sign the activity with signObject() before sending it.`);
+	logger.debug("The portable activity {activityId} is signed only by {keyId}, the one Ed25519 key whose verification method matches its DID; the map-local compound-proof profile accepts exactly one direct proof per map.", {
+		activityId,
+		keyId: eligible[0].verificationMethod.href
+	});
+	return await sign(eligible);
+}
+/**
+* Rejects an outgoing activity whose proofs Fedify's own inbox would reject
+* as unsupported: a document with portable objects in which some map carries
+* a proof set or another value that is not a single proof map.
+*
+* @param jsonLd The compact JSON-LD document about to be delivered.
+* @param activityId The activity ID, for the error message.
+* @throws {TypeError} If the document has an unsupported proof shape.
+* @internal
+*/
+function assertSupportedCompoundProofShape(jsonLd, activityId) {
+	if (!containsCompoundPortableObject(jsonLd)) return;
+	const path = findUnsupportedCompoundProofShape(jsonLd);
+	if (path == null) return;
+	throw new TypeError(`Cannot send the activity ${activityId}: it embeds portable objects, but its proof at the JSON Pointer ${JSON.stringify(path)} is not a single proof map.  The map-local compound-proof profile accepts exactly one direct proof per map, so Fedify inboxes would reject the activity.  Sign each object with exactly one key.`);
+}
+//#endregion
 //#region src/federation/tasks/enqueue.ts
 /**
 * The enqueue pipeline for custom background tasks.  `ContextImpl.enqueueTask`
@@ -3954,8 +4050,6 @@ var FederationImpl = class extends FederationBuilderImpl {
 		else if (keys.length < 1) throw new TypeError("The keys must not be empty.");
 		const contextLoader = this.contextLoaderFactory(this.#getLoaderOptions(ctx.origin));
 		const activityId = activity.id.href;
-		let hasProof = false;
-		let proofCreated = false;
 		let rsaKey = null;
 		for (const { keyId, privateKey } of keys) {
 			validateCryptoKey(privateKey, "private");
@@ -3964,25 +4058,22 @@ var FederationImpl = class extends FederationBuilderImpl {
 				privateKey
 			};
 		}
-		for await (const _ of activity.getProofs({ contextLoader })) {
-			hasProof = true;
-			break;
-		}
-		if (!hasProof) {
-			for (const { keyId, privateKey } of keys) if (privateKey.algorithm.name === "Ed25519") {
-				activity = await signObject(activity, privateKey, keyId, {
-					contextLoader,
-					tracerProvider: this.tracerProvider
-				});
-				hasProof = true;
-				proofCreated = true;
-			}
-		}
+		const signed = await signOutgoingActivity(activity, keys.map(({ keyId, privateKey }) => ({
+			verificationMethod: keyId,
+			privateKey
+		})), {
+			contextLoader,
+			tracerProvider: this.tracerProvider,
+			appendToExistingProofs: false
+		});
+		activity = signed.activity;
+		const { hasProof, proofCreated } = signed;
 		let jsonLd = !proofCreated && options.activityJsonLd != null ? options.activityJsonLd : await activity.toJsonLd({
 			format: "compact",
 			contextLoader
 		});
 		if (proofCreated || !hasProof || options.normalizeExistingProofs) jsonLd = await normalizeOutgoingActivityJsonLd(jsonLd, contextLoader, { preserveNestedSecuredDocuments: true });
+		assertSupportedCompoundProofShape(jsonLd, activityId);
 		if (rsaKey == null) logger.warn("No supported key found to create a Linked Data signature for the activity {activityId}.  The activity will be sent without a Linked Data signature.  In order to create a Linked Data signature, at least one RSASSA-PKCS1-v1_5 key must be provided.", {
 			activityId,
 			keys: keys.map((pair) => ({
@@ -4954,33 +5045,18 @@ var ContextImpl = class ContextImpl {
 			});
 			throw new TypeError("The activity to send must have at least one actor property.");
 		}
-		let proofCreated = false;
-		if (actorKeyPairs != null) {
-			const contextLoader = this.contextLoader;
-			for (const kp of actorKeyPairs) {
-				if (kp.privateKey.algorithm.name !== "Ed25519" || kp.multikey.id == null) continue;
-				activity = await signObject(activity, kp.privateKey, kp.multikey.id, {
-					contextLoader,
-					tracerProvider: this.tracerProvider
-				});
-				proofCreated = true;
-			}
-		} else {
-			const contextLoader = this.contextLoader;
-			let hasProof = false;
-			for await (const _ of activity.getProofs({ contextLoader })) {
-				hasProof = true;
-				break;
-			}
-			if (!hasProof) for (const { keyId, privateKey } of keys) {
-				if (privateKey.algorithm.name !== "Ed25519") continue;
-				activity = await signObject(activity, privateKey, keyId, {
-					contextLoader,
-					tracerProvider: this.tracerProvider
-				});
-				proofCreated = true;
-			}
-		}
+		const { activity: signedActivity, proofCreated } = await signOutgoingActivity(activity, actorKeyPairs == null ? keys.map(({ keyId, privateKey }) => ({
+			verificationMethod: keyId,
+			privateKey
+		})) : actorKeyPairs.flatMap((kp) => kp.multikey.id == null ? [] : [{
+			verificationMethod: kp.multikey.id,
+			privateKey: kp.privateKey
+		}]), {
+			contextLoader: this.contextLoader,
+			tracerProvider: this.tracerProvider,
+			appendToExistingProofs: actorKeyPairs != null
+		});
+		activity = signedActivity;
 		const inboxes = extractInboxes({
 			recipients: expandedRecipients,
 			preferSharedInbox: options.preferSharedInbox,
@@ -5005,6 +5081,11 @@ var ContextImpl = class ContextImpl {
 			});
 			return true;
 		}
+		const activityJsonLd = await activity.toJsonLd({
+			format: "compact",
+			contextLoader: this.contextLoader
+		});
+		assertSupportedCompoundProofShape(activityJsonLd, activity.id?.href);
 		const keyJwkPairs = await Promise.all(keys.map(async ({ keyId, privateKey }) => ({
 			keyId: keyId.href,
 			privateKey: await exportJwk(privateKey)
@@ -5020,10 +5101,7 @@ var ContextImpl = class ContextImpl {
 				actorIds: [...actorIds],
 				sharedInbox
 			}])),
-			activity: await activity.toJsonLd({
-				format: "compact",
-				contextLoader: this.contextLoader
-			}),
+			activity: activityJsonLd,
 			activityId: activity.id?.href,
 			activityType: getTypeId(activity).href,
 			collectionSync: opts.collectionSync,

package/dist/{middleware-iffqYoTV.js → middleware-Cxto6Bq2.js}

@@ -2,16 +2,16 @@ import { Temporal } from "temporal-polyfill";
 import { URLPattern } from "urlpattern-polyfill";
 import { t as __exportAll } from "./rolldown-runtime-BC-Eo5Mj.js";
 import { r as getDefaultActivityTransformers } from "./transformers-DAtXl_Kc.js";
-import { A as recordWebFingerHandle, C as recordCollectionRequest, D as recordInboxActivity, E as recordFanoutRecipients, I as name, L as version, M as formatAcceptSignature, O as recordOutboxActivity, S as recordCollectionPageItems, _ as instrumentDocumentLoader, a as verifyRequestDetailed, b as recordCircuitBreakerStateChange, d as importJwk, f as validateCryptoKey, g as getRemoteHost, h as getFederationMetrics, i as verifyRequest, j as registerQueueDepthGauge, k as recordOutboxEnqueue, m as getDurationMs, n as parseRfc9421SignatureInput, o as exportJwk, t as doubleKnock, v as isAbortError, w as recordCollectionTotalItems, x as recordCollectionDispatchDuration } from "./http-KZWtR1H8.js";
+import { A as recordWebFingerHandle, C as recordCollectionRequest, D as recordInboxActivity, E as recordFanoutRecipients, I as name, L as version, M as formatAcceptSignature, O as recordOutboxActivity, S as recordCollectionPageItems, _ as instrumentDocumentLoader, a as verifyRequestDetailed, b as recordCircuitBreakerStateChange, d as importJwk, f as validateCryptoKey, g as getRemoteHost, h as getFederationMetrics, i as verifyRequest, j as registerQueueDepthGauge, k as recordOutboxEnqueue, m as getDurationMs, n as parseRfc9421SignatureInput, o as exportJwk, t as doubleKnock, v as isAbortError, w as recordCollectionTotalItems, x as recordCollectionDispatchDuration } from "./http-By8tnmEr.js";
 import { a as MAX_BODY_SIZE, i as BodyTooLargeError, n as getNodeInfo, o as readBoundedText, t as nodeInfoToJson } from "./types-C_cNlNVK.js";
-import { C as verifyCompactJsonLd, D as normalizeOutgoingActivityJsonLd, E as wrapContextLoaderForJsonLd, S as signJsonLd, _ as getNormalizationContextLoader, a as signObject, b as isClearlyMalformedContextReference, d as InvalidContextReferenceError, f as assertSafeJsonLd, g as detachSignature, i as hasProofLike, l as verifyPortableObjectProofPolicy, m as compactJsonLd, n as getKeyOwner, o as verifyMapLocalProof, s as verifyObject, t as doesActorOwnKey, v as hasSignature, x as isInvalidUrlTypeError, y as hasSignatureLike } from "./owner-B7lgRMdU.js";
-import { n as getAuthenticatedDocumentLoader, t as kvCache } from "./kv-cache-HOO6BsuW.js";
+import { C as verifyCompactJsonLd, D as normalizeOutgoingActivityJsonLd, E as wrapContextLoaderForJsonLd, S as signJsonLd, _ as getNormalizationContextLoader, a as signObject, b as isClearlyMalformedContextReference, d as InvalidContextReferenceError, f as assertSafeJsonLd, g as detachSignature, i as hasProofLike, l as verifyPortableObjectProofPolicy, m as compactJsonLd, n as getKeyOwner, o as verifyMapLocalProof, s as verifyObject, t as doesActorOwnKey, v as hasSignature, x as isInvalidUrlTypeError, y as hasSignatureLike } from "./owner-D-E0bT2O.js";
+import { n as getAuthenticatedDocumentLoader, t as kvCache } from "./kv-cache-BswMKQjC.js";
 import { getLogger, withContext } from "@logtape/logtape";
 import { Router, RouterError, assertPath } from "@fedify/uri-template";
 import { Activity, Collection, CollectionPage, CryptographicKey, Link, Multikey, Object as Object$1, OrderedCollection, OrderedCollectionPage, Tombstone, getTypeId, lookupObject, traverseCollection } from "@fedify/vocab";
 import { SpanKind, SpanStatusCode, context, metrics, propagation, trace } from "@opentelemetry/api";
 import { encodeHex } from "byte-encodings/hex";
-import { FetchError, UrlError, getDocumentLoader, validatePublicUrl } from "@fedify/vocab-runtime";
+import { FetchError, UrlError, getDocumentLoader, getFe34Origin, haveSameFe34Origin, validatePublicUrl } from "@fedify/vocab-runtime";
 import { uniq } from "es-toolkit";
 import jsonld from "@fedify/vocab-runtime/jsonld";
 import { ATTR_HTTP_REQUEST_HEADER, ATTR_HTTP_REQUEST_METHOD, ATTR_HTTP_RESPONSE_HEADER, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_URL_FULL } from "@opentelemetry/semantic-conventions";
@@ -1643,6 +1643,78 @@ function inspectCompoundPortableObjectApplicability(json, limits) {
 	return "absent";
 }
 /**
+* Walks every JSON map in a finite, already-materialized JSON tree, depth
+* first in insertion order, skipping the values of `proof` and `@context`
+* members.  A map reached a second time through a repeated reference is not
+* visited again, so a cyclic input terminates.  The walk stops as soon as
+* the visitor returns a value other than `undefined`.
+*/
+function findInJsonMaps(json, visit) {
+	const seen = /* @__PURE__ */ new Set();
+	const pending = [{
+		value: json,
+		path: ""
+	}];
+	while (pending.length > 0) {
+		const { value, path } = pending.pop();
+		if (typeof value !== "object" || value == null || seen.has(value)) continue;
+		seen.add(value);
+		if (Array.isArray(value)) {
+			for (let index = value.length - 1; index >= 0; index--) pending.push({
+				value: value[index],
+				path: childPath(path, String(index))
+			});
+			continue;
+		}
+		const map = value;
+		const result = visit(map, path);
+		if (result !== void 0) return result;
+		const keys = Object.keys(map);
+		for (let index = keys.length - 1; index >= 0; index--) {
+			const key = keys[index];
+			if (key === "proof" || key === "@context") continue;
+			pending.push({
+				value: map[key],
+				path: childPath(path, key)
+			});
+		}
+	}
+}
+/**
+* Determines whether an outgoing JSON tree contains portable content that
+* requires producer-side proof-shape checks: a map, outside proof and context
+* values, whose direct `id` or `@id` is a portable ActivityPub URI.
+*
+* This deliberately differs from
+* {@link inspectCompoundPortableObjectApplicability}: it applies no resource
+* limits, so a portable map or an unsupported proof beyond the inbox limits
+* is still found, and a large document without portable maps stays outside
+* the compound-proof profile.  The input must be a finite JSON tree that has
+* already been materialized, such as a compact JSON-LD document about to be
+* sent.
+*
+* @internal
+*/
+function containsCompoundPortableObject(json) {
+	return findInJsonMaps(json, (map) => [map.id, map["@id"]].some((id) => typeof id === "string" && PORTABLE_OBJECT_ID_PATTERN.test(id)) ? true : void 0) ?? false;
+}
+/**
+* Finds the first direct `proof` member whose value the map-local
+* compound-proof profile does not accept, i.e., anything other than a single
+* JSON map: a proof set, `null`, or a scalar.  Like the inbox discovery, it
+* does not look inside proof or context values.
+*
+* The input must be a finite, already-materialized JSON tree; see
+* {@link containsCompoundPortableObject}.
+*
+* @returns The RFC 6901 JSON Pointer to the unsupported `proof` member, or
+*          `null` if every direct proof is a single JSON map.
+* @internal
+*/
+function findUnsupportedCompoundProofShape(json) {
+	return findInJsonMaps(json, (map, path) => Object.hasOwn(map, "proof") && !isJsonMap(map.proof) ? childPath(path, "proof") : void 0) ?? null;
+}
+/**
 * Discovers direct literal proof-bearing maps in an immutable JSON snapshot.
 *
 * Discovery is bounded and atomic.  Unsupported proof shapes, non-JSON input,
@@ -4535,6 +4607,102 @@ function serializeDataPointType(dataPointType) {
 	}
 }
 //#endregion
+//#region src/federation/outgoing-proof.ts
+function isPortableUrl(url) {
+	return url.protocol === "ap:" || url.protocol === "ap+ef61:";
+}
+function formatKeyIds(candidates) {
+	return candidates.map((c) => c.verificationMethod.href).join(", ");
+}
+/**
+* Creates the Object Integrity Proofs Fedify attaches to an outgoing activity.
+*
+* Outside the map-local compound-proof profile, i.e., when the activity
+* embeds no portable object, every Ed25519 key signs the activity, as it
+* always has.  Inside the profile, which accepts exactly one direct proof per
+* map, Fedify creates at most one proof:
+*
+*  -  An activity that already carries a proof is kept as is.
+*  -  A single Ed25519 key signs the activity.
+*  -  With several Ed25519 keys, a portable activity is signed by the one key
+*     whose verification method is a DID URL for the activity's DID, the only
+*     proof the FEP-ef61 policy can accept.  If no key or more than one key
+*     qualifies, or the activity is not portable itself, the choice is
+*     ambiguous and this function throws.
+*
+* @throws {TypeError} If a single proof key cannot be chosen.
+* @internal
+*/
+async function signOutgoingActivity(activity, candidates, options) {
+	const { contextLoader, tracerProvider } = options;
+	let hasProof = false;
+	for await (const _ of activity.getProofs({ contextLoader })) {
+		hasProof = true;
+		break;
+	}
+	const keys = candidates.filter((c) => c.privateKey.algorithm.name === "Ed25519");
+	if (keys.length < 1 || hasProof && !options.appendToExistingProofs) return {
+		activity,
+		hasProof,
+		proofCreated: false
+	};
+	const sign = async (selected) => {
+		for (const { verificationMethod, privateKey } of selected) activity = await signObject(activity, privateKey, verificationMethod, {
+			contextLoader,
+			tracerProvider
+		});
+		return {
+			activity,
+			hasProof: true,
+			proofCreated: true
+		};
+	};
+	if (keys.length < 2 && !hasProof) return await sign(keys);
+	if (!containsCompoundPortableObject(await activity.toJsonLd({
+		format: "compact",
+		contextLoader
+	}))) return await sign(keys);
+	const logger = getLogger([
+		"fedify",
+		"federation",
+		"outbox"
+	]);
+	const activityId = activity.id?.href;
+	if (hasProof) {
+		logger.debug("The activity {activityId} embeds portable objects and already carries a proof, so no further proof is added; the map-local compound-proof profile accepts exactly one direct proof per map.", { activityId });
+		return {
+			activity,
+			hasProof,
+			proofCreated: false
+		};
+	}
+	if (activity.id == null || !isPortableUrl(activity.id)) throw new TypeError(`Cannot choose an Object Integrity Proof key for the activity ${activityId}: it embeds portable objects, so it falls under the map-local compound-proof profile, which accepts exactly one direct proof per map, but ${keys.length} Ed25519 keys were supplied (${formatKeyIds(keys)}).  Send it with explicit sender keys that contain exactly one Ed25519 key (RSA keys for HTTP Signatures may stay), or sign it with signObject() before sending it.`);
+	const activityDid = getFe34Origin(activity.id);
+	const eligible = keys.filter((c) => c.verificationMethod.protocol === "did:" && haveSameFe34Origin(activity.id, c.verificationMethod));
+	if (eligible.length !== 1) throw new TypeError(`Cannot choose an Object Integrity Proof key for the portable activity ${activityId}: ` + (eligible.length < 1 ? `none of its ${keys.length} Ed25519 keys (${formatKeyIds(keys)}) ` : `${eligible.length} of its Ed25519 keys (${formatKeyIds(eligible)}) `) + `${eligible.length < 1 ? "is" : "are"} a DID URL verification method for ${activityDid}.  The map-local compound-proof profile accepts exactly one direct proof per map, and FEP-ef61 requires that proof's verification method to be a DID URL for the activity's DID.  Supply exactly one Ed25519 key whose key ID is a DID URL for ${activityDid}, or sign the activity with signObject() before sending it.`);
+	logger.debug("The portable activity {activityId} is signed only by {keyId}, the one Ed25519 key whose verification method matches its DID; the map-local compound-proof profile accepts exactly one direct proof per map.", {
+		activityId,
+		keyId: eligible[0].verificationMethod.href
+	});
+	return await sign(eligible);
+}
+/**
+* Rejects an outgoing activity whose proofs Fedify's own inbox would reject
+* as unsupported: a document with portable objects in which some map carries
+* a proof set or another value that is not a single proof map.
+*
+* @param jsonLd The compact JSON-LD document about to be delivered.
+* @param activityId The activity ID, for the error message.
+* @throws {TypeError} If the document has an unsupported proof shape.
+* @internal
+*/
+function assertSupportedCompoundProofShape(jsonLd, activityId) {
+	if (!containsCompoundPortableObject(jsonLd)) return;
+	const path = findUnsupportedCompoundProofShape(jsonLd);
+	if (path == null) return;
+	throw new TypeError(`Cannot send the activity ${activityId}: it embeds portable objects, but its proof at the JSON Pointer ${JSON.stringify(path)} is not a single proof map.  The map-local compound-proof profile accepts exactly one direct proof per map, so Fedify inboxes would reject the activity.  Sign each object with exactly one key.`);
+}
+//#endregion
 //#region src/federation/retry.ts
 /**
 * Creates an exponential backoff retry policy.  The delay between retries
@@ -6342,8 +6510,6 @@ var FederationImpl = class extends FederationBuilderImpl {
 		else if (keys.length < 1) throw new TypeError("The keys must not be empty.");
 		const contextLoader = this.contextLoaderFactory(this.#getLoaderOptions(ctx.origin));
 		const activityId = activity.id.href;
-		let hasProof = false;
-		let proofCreated = false;
 		let rsaKey = null;
 		for (const { keyId, privateKey } of keys) {
 			validateCryptoKey(privateKey, "private");
@@ -6352,25 +6518,22 @@ var FederationImpl = class extends FederationBuilderImpl {
 				privateKey
 			};
 		}
-		for await (const _ of activity.getProofs({ contextLoader })) {
-			hasProof = true;
-			break;
-		}
-		if (!hasProof) {
-			for (const { keyId, privateKey } of keys) if (privateKey.algorithm.name === "Ed25519") {
-				activity = await signObject(activity, privateKey, keyId, {
-					contextLoader,
-					tracerProvider: this.tracerProvider
-				});
-				hasProof = true;
-				proofCreated = true;
-			}
-		}
+		const signed = await signOutgoingActivity(activity, keys.map(({ keyId, privateKey }) => ({
+			verificationMethod: keyId,
+			privateKey
+		})), {
+			contextLoader,
+			tracerProvider: this.tracerProvider,
+			appendToExistingProofs: false
+		});
+		activity = signed.activity;
+		const { hasProof, proofCreated } = signed;
 		let jsonLd = !proofCreated && options.activityJsonLd != null ? options.activityJsonLd : await activity.toJsonLd({
 			format: "compact",
 			contextLoader
 		});
 		if (proofCreated || !hasProof || options.normalizeExistingProofs) jsonLd = await normalizeOutgoingActivityJsonLd(jsonLd, contextLoader, { preserveNestedSecuredDocuments: true });
+		assertSupportedCompoundProofShape(jsonLd, activityId);
 		if (rsaKey == null) logger.warn("No supported key found to create a Linked Data signature for the activity {activityId}.  The activity will be sent without a Linked Data signature.  In order to create a Linked Data signature, at least one RSASSA-PKCS1-v1_5 key must be provided.", {
 			activityId,
 			keys: keys.map((pair) => ({
@@ -7342,33 +7505,18 @@ var ContextImpl = class ContextImpl {
 			});
 			throw new TypeError("The activity to send must have at least one actor property.");
 		}
-		let proofCreated = false;
-		if (actorKeyPairs != null) {
-			const contextLoader = this.contextLoader;
-			for (const kp of actorKeyPairs) {
-				if (kp.privateKey.algorithm.name !== "Ed25519" || kp.multikey.id == null) continue;
-				activity = await signObject(activity, kp.privateKey, kp.multikey.id, {
-					contextLoader,
-					tracerProvider: this.tracerProvider
-				});
-				proofCreated = true;
-			}
-		} else {
-			const contextLoader = this.contextLoader;
-			let hasProof = false;
-			for await (const _ of activity.getProofs({ contextLoader })) {
-				hasProof = true;
-				break;
-			}
-			if (!hasProof) for (const { keyId, privateKey } of keys) {
-				if (privateKey.algorithm.name !== "Ed25519") continue;
-				activity = await signObject(activity, privateKey, keyId, {
-					contextLoader,
-					tracerProvider: this.tracerProvider
-				});
-				proofCreated = true;
-			}
-		}
+		const { activity: signedActivity, proofCreated } = await signOutgoingActivity(activity, actorKeyPairs == null ? keys.map(({ keyId, privateKey }) => ({
+			verificationMethod: keyId,
+			privateKey
+		})) : actorKeyPairs.flatMap((kp) => kp.multikey.id == null ? [] : [{
+			verificationMethod: kp.multikey.id,
+			privateKey: kp.privateKey
+		}]), {
+			contextLoader: this.contextLoader,
+			tracerProvider: this.tracerProvider,
+			appendToExistingProofs: actorKeyPairs != null
+		});
+		activity = signedActivity;
 		const inboxes = extractInboxes({
 			recipients: expandedRecipients,
 			preferSharedInbox: options.preferSharedInbox,
@@ -7393,6 +7541,11 @@ var ContextImpl = class ContextImpl {
 			});
 			return true;
 		}
+		const activityJsonLd = await activity.toJsonLd({
+			format: "compact",
+			contextLoader: this.contextLoader
+		});
+		assertSupportedCompoundProofShape(activityJsonLd, activity.id?.href);
 		const keyJwkPairs = await Promise.all(keys.map(async ({ keyId, privateKey }) => ({
 			keyId: keyId.href,
 			privateKey: await exportJwk(privateKey)
@@ -7408,10 +7561,7 @@ var ContextImpl = class ContextImpl {
 				actorIds: [...actorIds],
 				sharedInbox
 			}])),
-			activity: await activity.toJsonLd({
-				format: "compact",
-				contextLoader: this.contextLoader
-			}),
+			activity: activityJsonLd,
 			activityId: activity.id?.href,
 			activityType: getTypeId(activity).href,
 			collectionSync: opts.collectionSync,

package/dist/mod.cjs

@@ -3,11 +3,11 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("./rolldown-runtime-Dmm3t92W.cjs");
 const require_transformers = require("./transformers-BalCrSsr.cjs");
 require("./compat/mod.cjs");
-const require_http = require("./http-CWXKwHPv.cjs");
-const require_federation = require("./federation-C0ijTwhx.cjs");
+const require_http = require("./http-B5F1JMh0.cjs");
+const require_federation = require("./federation-CTnaljmy.cjs");
 const require_types = require("./types-Be2zbyeG.cjs");
-const require_owner = require("./owner-DffLVeYC.cjs");
-const require_kv_cache = require("./kv-cache-Dos4tOWb.cjs");
+const require_owner = require("./owner-WUYke16i.cjs");
+const require_kv_cache = require("./kv-cache-8K70pjtX.cjs");
 require("./nodeinfo/mod.cjs");
 require("./runtime/mod.cjs");
 require("./sig/mod.cjs");

package/dist/mod.js

@@ -3,11 +3,11 @@ import { URLPattern } from "urlpattern-polyfill";
 import "./rolldown-runtime-BC-Eo5Mj.js";
 import { n as autoIdAssigner, r as getDefaultActivityTransformers, t as actorDehydrator } from "./transformers-DAtXl_Kc.js";
 import "./compat/mod.js";
-import { F as validateAcceptSignature, M as formatAcceptSignature, N as fulfillAcceptSignature, P as parseAcceptSignature, a as verifyRequestDetailed, c as fetchKey, d as importJwk, i as verifyRequest, l as fetchKeyDetailed, o as exportJwk, r as signRequest, u as generateCryptoKeyPair } from "./http-KZWtR1H8.js";
-import { a as respondWithObject, c as digest, d as parseCircuitBreakerKvState, f as createFederationBuilder, i as SendActivityError, l as CircuitBreaker, n as handleWebFinger, o as respondWithObjectIfAcceptable, r as createExponentialBackoffPolicy, s as buildCollectionSynchronizationHeader, t as createFederation, u as normalizeCircuitBreakerOptions } from "./middleware-iffqYoTV.js";
+import { F as validateAcceptSignature, M as formatAcceptSignature, N as fulfillAcceptSignature, P as parseAcceptSignature, a as verifyRequestDetailed, c as fetchKey, d as importJwk, i as verifyRequest, l as fetchKeyDetailed, o as exportJwk, r as signRequest, u as generateCryptoKeyPair } from "./http-By8tnmEr.js";
+import { a as respondWithObject, c as digest, d as parseCircuitBreakerKvState, f as createFederationBuilder, i as SendActivityError, l as CircuitBreaker, n as handleWebFinger, o as respondWithObjectIfAcceptable, r as createExponentialBackoffPolicy, s as buildCollectionSynchronizationHeader, t as createFederation, u as normalizeCircuitBreakerOptions } from "./middleware-Cxto6Bq2.js";
 import { n as getNodeInfo, r as parseNodeInfo, t as nodeInfoToJson } from "./types-C_cNlNVK.js";
-import { S as signJsonLd, T as verifySignature, a as signObject, c as verifyPortableObjectProof, g as detachSignature, h as createSignature, i as hasProofLike, n as getKeyOwner, p as attachSignature, r as createProof, s as verifyObject, t as doesActorOwnKey, u as verifyProof, w as verifyJsonLd, y as hasSignatureLike } from "./owner-B7lgRMdU.js";
-import { n as getAuthenticatedDocumentLoader, t as kvCache } from "./kv-cache-HOO6BsuW.js";
+import { S as signJsonLd, T as verifySignature, a as signObject, c as verifyPortableObjectProof, g as detachSignature, h as createSignature, i as hasProofLike, n as getKeyOwner, p as attachSignature, r as createProof, s as verifyObject, t as doesActorOwnKey, u as verifyProof, w as verifyJsonLd, y as hasSignatureLike } from "./owner-D-E0bT2O.js";
+import { n as getAuthenticatedDocumentLoader, t as kvCache } from "./kv-cache-BswMKQjC.js";
 import { InProcessMessageQueue, MemoryKvStore, ParallelMessageQueue, Router, RouterError } from "./federation/mod.js";
 import "./nodeinfo/mod.js";
 import "./runtime/mod.js";

package/dist/nodeinfo/handler.test.mjs

@@ -5,7 +5,7 @@ import { r as createRequestContext } from "../context-CbS35fLr.mjs";
 import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
 import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
 import "../std__assert-DvMDRPes.mjs";
-import { _ as handleNodeInfo, o as createFederation, v as handleNodeInfoJrd } from "../middleware-BsYD_ufs.mjs";
+import { _ as handleNodeInfo, o as createFederation, v as handleNodeInfoJrd } from "../middleware-C7_hqDnl.mjs";
 import { test } from "@fedify/fixture";
 //#region src/nodeinfo/handler.test.ts
 test("handleNodeInfo()", async () => {

package/dist/{owner-D53bUI-n.mjs → owner-BIOIhZoM.mjs}

@@ -1,8 +1,8 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as version, t as name } from "./deno-BcZNXlJn.mjs";
-import { c as verifyKeyOwnership, n as fetchActorDocument, t as exportJwk } from "./key-Xb1hVVZO.mjs";
+import { n as version, t as name } from "./deno-Vj_9wePq.mjs";
+import { c as verifyKeyOwnership, n as fetchActorDocument, t as exportJwk } from "./key-B_Zc5Jbd.mjs";
 import { getLogger } from "@logtape/logtape";
 import { CryptographicKey, Object as Object$1, isActor } from "@fedify/vocab";
 import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";