@fedify/fedify 2.4.0-dev.1964 → 2.4.0-dev.1995

package/dist/{middleware-CPTDFMmJ.js → middleware-DsfWajaD.js}

@@ -2,19 +2,19 @@ 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 formatAcceptSignature, D as recordOutboxEnqueue, E as recordOutboxActivity, F as version, O as recordWebFingerHandle, P as name, S as recordCollectionTotalItems, T as recordInboxActivity, a as verifyRequestDetailed, b as recordCollectionPageItems, d as validateCryptoKey, f as getDurationMs, g as isAbortError, h as instrumentDocumentLoader, i as verifyRequest, k as registerQueueDepthGauge, m as getRemoteHost, n as parseRfc9421SignatureInput, o as exportJwk, p as getFederationMetrics, t as doubleKnock, u as importJwk, v as recordCircuitBreakerStateChange, w as recordFanoutRecipients, x as recordCollectionRequest, y as recordCollectionDispatchDuration } from "./http-Dj4s1UQ0.js";
-import { S as verifyCompactJsonLd, T as wrapContextLoaderForJsonLd, _ as hasSignature, b as isInvalidUrlTypeError, c as doesActorOwnKey, d as assertSafeJsonLd, g as getNormalizationContextLoader, h as detachSignature, i as verifyObject, l as getKeyOwner, n as hasProofLike, p as compactJsonLd, r as signObject, s as normalizeOutgoingActivityJsonLd, u as InvalidContextReferenceError, v as hasSignatureLike, x as signJsonLd, y as isClearlyMalformedContextReference } from "./proof-BO_esQii.js";
-import { n as getNodeInfo, t as nodeInfoToJson } from "./types-Dtyf8lVj.js";
-import { n as getAuthenticatedDocumentLoader, t as kvCache } from "./kv-cache-tGNbvDCF.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-9WyuldYh.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-BIPEZGiU.js";
+import { n as getAuthenticatedDocumentLoader, t as kvCache } from "./kv-cache-DtmXhPXG.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 { uniq } from "es-toolkit";
-import { FetchError, getDocumentLoader } 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 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";
 import { lookupWebFinger } from "@fedify/webfinger";
 import { DataPointType, MeterProvider as MeterProvider$1, MetricReader } from "@opentelemetry/sdk-metrics";
 import { parse, stringifyAsync } from "devalue";
@@ -1296,6 +1296,474 @@ async function buildCollectionSynchronizationHeader(collectionId, actorIds) {
 	return `collectionId="${collectionId}", url="${url}", digest="${encodeHex(await digest(actorIds))}"`;
 }
 //#endregion
+//#region src/sig/compound-proof.ts
+const textEncoder = new TextEncoder();
+const PORTABLE_OBJECT_ID_PATTERN = /^ap(?:\+ef61)?:\/\//i;
+function isJsonMap(value) {
+	return typeof value === "object" && value != null && !Array.isArray(value);
+}
+function isCompoundProofJsonObject(value) {
+	return typeof value === "object" && value != null && !Array.isArray(value);
+}
+function hasOnlyDataProperties(value) {
+	try {
+		return Reflect.ownKeys(value).every((key) => {
+			if (typeof key !== "string") return false;
+			const descriptor = Object.getOwnPropertyDescriptor(value, key);
+			return descriptor != null && "value" in descriptor && descriptor.enumerable;
+		});
+	} catch {
+		return false;
+	}
+}
+function hasOnlyJsonArrayProperties(value) {
+	try {
+		const keys = Reflect.ownKeys(value);
+		if (keys.length !== value.length + 1) return false;
+		for (const key of keys) {
+			if (key === "length") continue;
+			if (typeof key !== "string") return false;
+			const index = Number(key);
+			if (!Number.isInteger(index) || index < 0 || index >= value.length || String(index) !== key) return false;
+			const descriptor = Object.getOwnPropertyDescriptor(value, key);
+			if (descriptor == null || !descriptor.enumerable || !("value" in descriptor)) return false;
+		}
+		return true;
+	} catch {
+		return false;
+	}
+}
+function escapeJsonPointerSegment(segment) {
+	return segment.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function childPath(path, segment) {
+	return `${path}/${escapeJsonPointerSegment(segment)}`;
+}
+function comparePaths(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+function encodedLength(value) {
+	return textEncoder.encode(value).byteLength;
+}
+function validateLimits(limits) {
+	for (const [name, value] of Object.entries(limits)) if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`${name} must be a non-negative safe integer.`);
+}
+function limitExceeded(limit, maximum, actual, path) {
+	return {
+		status: "unsupported",
+		reason: {
+			type: "limitExceeded",
+			limit,
+			maximum,
+			actual,
+			path
+		}
+	};
+}
+function addBytes(statistics, bytes, limits, path) {
+	statistics.byteLength += bytes;
+	if (statistics.byteLength > limits.maxBytes) return limitExceeded("bytes", limits.maxBytes, statistics.byteLength, path);
+}
+function inspectJsonTree(root, limits) {
+	if (!isJsonMap(root)) return {
+		status: "unsupported",
+		reason: {
+			type: "invalidJsonTree",
+			path: ""
+		}
+	};
+	const statistics = {
+		byteLength: 0,
+		mapCount: 0,
+		proofCount: 0,
+		maxDepth: 0
+	};
+	const seen = /* @__PURE__ */ new Set();
+	const pending = [{
+		value: root,
+		path: "",
+		depth: 0,
+		insideProof: false,
+		insideContext: false
+	}];
+	while (pending.length > 0) {
+		const current = pending.pop();
+		statistics.maxDepth = Math.max(statistics.maxDepth, current.depth);
+		if (current.depth > limits.maxDepth) return limitExceeded("depth", limits.maxDepth, current.depth, current.path);
+		const value = current.value;
+		if (value === null) {
+			const failure = addBytes(statistics, 4, limits, current.path);
+			if (failure != null) return failure;
+		} else if (typeof value === "boolean") {
+			const failure = addBytes(statistics, value ? 4 : 5, limits, current.path);
+			if (failure != null) return failure;
+		} else if (typeof value === "string") {
+			const failure = addBytes(statistics, encodedLength(JSON.stringify(value)), limits, current.path);
+			if (failure != null) return failure;
+		} else if (typeof value === "number") {
+			if (!Number.isFinite(value)) return {
+				status: "unsupported",
+				reason: {
+					type: "invalidJsonTree",
+					path: current.path
+				}
+			};
+			const failure = addBytes(statistics, encodedLength(JSON.stringify(value)), limits, current.path);
+			if (failure != null) return failure;
+		} else if (Array.isArray(value)) {
+			if (seen.has(value) || !hasOnlyJsonArrayProperties(value)) return {
+				status: "unsupported",
+				reason: {
+					type: "invalidJsonTree",
+					path: current.path
+				}
+			};
+			seen.add(value);
+			const failure = addBytes(statistics, 2 + Math.max(0, value.length - 1), limits, current.path);
+			if (failure != null) return failure;
+			for (let index = value.length - 1; index >= 0; index--) pending.push({
+				value: value[index],
+				path: childPath(current.path, String(index)),
+				depth: current.depth + 1,
+				insideProof: current.insideProof,
+				insideContext: current.insideContext
+			});
+		} else if (isJsonMap(value)) {
+			const prototype = Object.getPrototypeOf(value);
+			if (seen.has(value) || !hasOnlyDataProperties(value) || prototype !== Object.prototype && prototype !== null) return {
+				status: "unsupported",
+				reason: {
+					type: "invalidJsonTree",
+					path: current.path
+				}
+			};
+			seen.add(value);
+			statistics.mapCount++;
+			if (statistics.mapCount > limits.maxMaps) return limitExceeded("maps", limits.maxMaps, statistics.mapCount, current.path);
+			const entries = Object.entries(value).sort(([left], [right]) => comparePaths(left, right));
+			let objectBytes = 2 + Math.max(0, entries.length - 1);
+			for (const [key] of entries) objectBytes += encodedLength(JSON.stringify(key)) + 1;
+			const failure = addBytes(statistics, objectBytes, limits, current.path);
+			if (failure != null) return failure;
+			const hasDirectProof = !current.insideProof && !current.insideContext && Object.hasOwn(value, "proof");
+			if (hasDirectProof) {
+				statistics.proofCount++;
+				if (statistics.proofCount > limits.maxProofs) return limitExceeded("proofs", limits.maxProofs, statistics.proofCount, childPath(current.path, "proof"));
+				if (!isJsonMap(value.proof)) return {
+					status: "unsupported",
+					reason: {
+						type: "unsupportedProofShape",
+						path: childPath(current.path, "proof")
+					}
+				};
+			}
+			for (let index = entries.length - 1; index >= 0; index--) {
+				const [key, child] = entries[index];
+				pending.push({
+					value: child,
+					path: childPath(current.path, key),
+					depth: current.depth + 1,
+					insideProof: current.insideProof || hasDirectProof && key === "proof",
+					insideContext: current.insideContext || key === "@context"
+				});
+			}
+		} else return {
+			status: "unsupported",
+			reason: {
+				type: "invalidJsonTree",
+				path: current.path
+			}
+		};
+	}
+	return statistics;
+}
+function freezeJsonTree(root) {
+	const pending = [root];
+	while (pending.length > 0) {
+		const value = pending.pop();
+		if (typeof value !== "object" || value == null) continue;
+		if (Array.isArray(value)) for (const child of value) pending.push(child);
+		else for (const child of Object.values(value)) pending.push(child);
+		Object.freeze(value);
+	}
+}
+function collectDocuments(snapshot) {
+	const documents = [];
+	const pending = [{
+		value: snapshot,
+		path: "",
+		depth: 0
+	}];
+	while (pending.length > 0) {
+		const current = pending.pop();
+		if (Array.isArray(current.value)) {
+			for (let index = current.value.length - 1; index >= 0; index--) pending.push({
+				value: current.value[index],
+				path: childPath(current.path, String(index)),
+				depth: current.depth + 1
+			});
+			continue;
+		}
+		if (!isCompoundProofJsonObject(current.value)) continue;
+		const document = current.value;
+		if (Object.hasOwn(document, "proof")) {
+			const proof = document.proof;
+			const id = typeof document.id === "string" ? document.id : typeof document["@id"] === "string" ? document["@id"] : void 0;
+			documents.push(Object.freeze({
+				path: current.path,
+				id,
+				depth: current.depth,
+				securedDocument: document,
+				proof
+			}));
+		}
+		const entries = Object.entries(document).sort(([left], [right]) => comparePaths(left, right));
+		for (let index = entries.length - 1; index >= 0; index--) {
+			const [key, value] = entries[index];
+			if (key === "proof" || key === "@context") continue;
+			pending.push({
+				value,
+				path: childPath(current.path, key),
+				depth: current.depth + 1
+			});
+		}
+	}
+	documents.sort((left, right) => right.depth - left.depth || comparePaths(left.path, right.path));
+	return documents;
+}
+function collectPortableObjects(snapshot) {
+	const objects = [];
+	const pending = [{
+		value: snapshot,
+		path: "",
+		depth: 0
+	}];
+	while (pending.length > 0) {
+		const current = pending.pop();
+		if (Array.isArray(current.value)) {
+			for (let index = current.value.length - 1; index >= 0; index--) pending.push({
+				value: current.value[index],
+				path: childPath(current.path, String(index)),
+				depth: current.depth + 1
+			});
+			continue;
+		}
+		if (!isCompoundProofJsonObject(current.value)) continue;
+		const document = current.value;
+		const id = [document.id, document["@id"]].find((value) => typeof value === "string" && PORTABLE_OBJECT_ID_PATTERN.test(value));
+		if (typeof id === "string") objects.push(Object.freeze({
+			path: current.path,
+			id,
+			depth: current.depth,
+			document
+		}));
+		const entries = Object.entries(document).sort(([left], [right]) => comparePaths(left, right));
+		for (let index = entries.length - 1; index >= 0; index--) {
+			const [key, value] = entries[index];
+			if (key === "proof" || key === "@context") continue;
+			pending.push({
+				value,
+				path: childPath(current.path, key),
+				depth: current.depth + 1
+			});
+		}
+	}
+	objects.sort((left, right) => right.depth - left.depth || comparePaths(left.path, right.path));
+	return objects;
+}
+/**
+* Determines whether a received JSON tree contains a portable object ID
+* outside a proof or context definition, without exceeding discovery limits.
+*
+* This is only an applicability check.  It does not authenticate the input;
+* callers must still use {@link verifyCompoundPortableObjectProofs} to obtain
+* an atomic result from an immutable snapshot.  `indeterminate` means the
+* applicability scan itself reached a limit, so a caller must not treat the
+* document as outside the compound profile.
+*
+* @internal
+*/
+function inspectCompoundPortableObjectApplicability(json, limits) {
+	validateLimits(limits);
+	let byteLength = 0;
+	let mapCount = 0;
+	const pending = [{
+		iterator: [json].values(),
+		depth: 0
+	}];
+	const addByteLength = (length) => {
+		byteLength += length;
+		return byteLength <= limits.maxBytes;
+	};
+	while (pending.length > 0) {
+		const frame = pending[pending.length - 1];
+		const next = frame.iterator.next();
+		if (next.done) {
+			pending.pop();
+			if (byteLength > limits.maxBytes) return "indeterminate";
+			continue;
+		}
+		const value = next.value;
+		if (frame.depth > limits.maxDepth) return "indeterminate";
+		if (value === null) {
+			if (!addByteLength(4)) return "indeterminate";
+		} else if (typeof value === "boolean") {
+			if (!addByteLength(value ? 4 : 5)) return "indeterminate";
+		} else if (typeof value === "string" || typeof value === "number") {
+			if (!addByteLength(encodedLength(JSON.stringify(value)))) return "indeterminate";
+		} else if (Array.isArray(value)) {
+			if (!addByteLength(2 + Math.max(0, value.length - 1))) return "indeterminate";
+			pending.push({
+				iterator: value.values(),
+				depth: frame.depth + 1
+			});
+		} else if (isJsonMap(value)) {
+			mapCount++;
+			if (mapCount > limits.maxMaps) return "indeterminate";
+			if ([value.id, value["@id"]].some((id) => typeof id === "string" && PORTABLE_OBJECT_ID_PATTERN.test(id))) return "present";
+			if (!addByteLength(2)) return "indeterminate";
+			const children = function* () {
+				let first = true;
+				for (const key in value) {
+					if (!Object.hasOwn(value, key)) continue;
+					if (key === "proof" || key === "@context") continue;
+					if (!first && !addByteLength(1)) return;
+					first = false;
+					if (!addByteLength(encodedLength(JSON.stringify(key)) + 1)) return;
+					yield value[key];
+				}
+			}();
+			pending.push({
+				iterator: children,
+				depth: frame.depth + 1
+			});
+		}
+		if (byteLength > limits.maxBytes) return "indeterminate";
+	}
+	return "absent";
+}
+/**
+* Discovers direct literal proof-bearing maps in an immutable JSON snapshot.
+*
+* Discovery is bounded and atomic.  Unsupported proof shapes, non-JSON input,
+* or a resource-limit failure return no partial candidate list.  Proof
+* configuration subtrees are validated and counted as JSON, but are not
+* themselves searched for secured documents.
+*/
+function discoverCompoundProofDocuments(json, limits) {
+	validateLimits(limits);
+	let inspected;
+	try {
+		inspected = inspectJsonTree(json, limits);
+	} catch {
+		return {
+			status: "unsupported",
+			reason: {
+				type: "invalidJsonTree",
+				path: ""
+			}
+		};
+	}
+	if ("status" in inspected) return inspected;
+	let snapshot;
+	try {
+		snapshot = structuredClone(json);
+	} catch {
+		return {
+			status: "unsupported",
+			reason: {
+				type: "invalidJsonTree",
+				path: ""
+			}
+		};
+	}
+	freezeJsonTree(snapshot);
+	return {
+		status: "ok",
+		snapshot,
+		documents: Object.freeze(collectDocuments(snapshot)),
+		statistics: Object.freeze({ ...inspected })
+	};
+}
+async function verifyDiscoveredProofDocuments(discovered, options) {
+	const documents = await Promise.all(discovered.documents.map(async (document) => {
+		const metadata = {
+			path: document.path,
+			...document.id == null ? {} : { id: document.id },
+			depth: document.depth
+		};
+		if (document.depth > 0 && !Object.hasOwn(document.securedDocument, "@context")) return Object.freeze({
+			...metadata,
+			verified: false,
+			reason: { type: "missingContext" }
+		});
+		const key = await verifyMapLocalProof(document.securedDocument, options);
+		return key == null ? Object.freeze({
+			...metadata,
+			verified: false,
+			reason: { type: "invalidProof" }
+		}) : Object.freeze({
+			...metadata,
+			verified: true,
+			key
+		});
+	}));
+	return Object.freeze(documents);
+}
+/**
+* Applies FEP-ef61 portable-object policy to every portable map in a compound
+* snapshot without changing the map-local cryptographic inputs.
+*
+* @internal
+*/
+async function verifyCompoundPortableObjectProofs(json, limits, options = {}) {
+	const discovered = discoverCompoundProofDocuments(json, limits);
+	if (discovered.status !== "ok") return discovered;
+	const proofs = await verifyDiscoveredProofDocuments(discovered, options);
+	const proofByPath = new Map(proofs.map((proof) => [proof.path, proof]));
+	const portableObjects = await Promise.all(collectPortableObjects(discovered.snapshot).map(async (object) => {
+		const metadata = {
+			path: object.path,
+			id: object.id,
+			depth: object.depth
+		};
+		if (object.depth > 0 && !Object.hasOwn(object.document, "@context")) return Object.freeze({
+			...metadata,
+			verified: false,
+			reason: { type: "missingContext" }
+		});
+		const proof = proofByPath.get(object.path);
+		const key = proof?.verified === true ? proof.key : null;
+		try {
+			const policy = await verifyPortableObjectProofPolicy(object.document, key, options);
+			return policy.verified ? Object.freeze({
+				...metadata,
+				id: policy.objectId,
+				verified: true,
+				keys: policy.keys
+			}) : Object.freeze({
+				...metadata,
+				verified: false,
+				reason: policy.reason
+			});
+		} catch {
+			return Object.freeze({
+				...metadata,
+				verified: false,
+				reason: { type: "invalidPortableObject" }
+			});
+		}
+	}));
+	return {
+		status: "ok",
+		verified: portableObjects.length > 0 && proofs.every((proof) => proof.verified) && portableObjects.every((object) => object.verified),
+		snapshot: discovered.snapshot,
+		proofs,
+		portableObjects: Object.freeze(portableObjects),
+		statistics: discovered.statistics
+	};
+}
+//#endregion
 //#region src/federation/inbox.ts
 async function routeActivity({ context: ctx, json, originalJson, normalizedActivity, ldSignatureVerified, activity, recipient, inboxListeners, inboxContextFactory, listenerInboxContextFactory, inboxErrorHandler, kv, kvPrefixes, queue, span, meterProvider, tracerProvider, idempotencyStrategy }) {
 	const logger = getLogger([
@@ -1455,6 +1923,7 @@ async function routeActivity({ context: ctx, json, originalJson, normalizedActiv
 }
 //#endregion
 //#region src/federation/keycache.ts
+const KEY_CACHE_GENERATION = "2";
 var KvKeyCache = class {
 	kv;
 	prefix;
@@ -1477,13 +1946,20 @@ var KvKeyCache = class {
 			keyId.href
 		];
 	}
+	#entryKey(keyId) {
+		return [
+			...this.prefix,
+			KEY_CACHE_GENERATION,
+			keyId.href
+		];
+	}
 	async get(keyId) {
 		const negativeExpiration = this.nullKeys.get(keyId.href);
 		if (negativeExpiration != null) {
 			if (Temporal.Now.instant().until(negativeExpiration).sign >= 0) return null;
 			this.nullKeys.delete(keyId.href);
 		}
-		const serialized = await this.kv.get([...this.prefix, keyId.href]);
+		const serialized = await this.kv.get(this.#entryKey(keyId));
 		if (serialized === void 0) return void 0;
 		if (serialized === null) {
 			this.nullKeys.set(keyId.href, Temporal.Now.instant().add(this.unavailableKeyTtl));
@@ -1495,7 +1971,7 @@ var KvKeyCache = class {
 			try {
 				return await Multikey.fromJsonLd(serialized, this.options);
 			} catch {
-				await this.kv.delete([...this.prefix, keyId.href]);
+				await this.kv.delete(this.#entryKey(keyId));
 				return;
 			}
 		}
@@ -1503,12 +1979,12 @@ var KvKeyCache = class {
 	async set(keyId, key) {
 		if (key == null) {
 			this.nullKeys.set(keyId.href, Temporal.Now.instant().add(this.unavailableKeyTtl));
-			await this.kv.set([...this.prefix, keyId.href], null, { ttl: this.unavailableKeyTtl });
+			await this.kv.set(this.#entryKey(keyId), null, { ttl: this.unavailableKeyTtl });
 			return;
 		}
 		this.nullKeys.delete(keyId.href);
 		const serialized = await key.toJsonLd(this.options);
-		await this.kv.set([...this.prefix, keyId.href], serialized, { ttl: this.keyTtl });
+		await this.kv.set(this.#entryKey(keyId), serialized, { ttl: this.keyTtl });
 	}
 	async getFetchError(keyId) {
 		const cached = await this.kv.get(this.#getFetchErrorKey(keyId));
@@ -1731,6 +2207,12 @@ async function hasMalformedKnownTemporalLiteral(value, contextLoader) {
 //#endregion
 //#region src/federation/handler.ts
 const rawInboxContextFactorySymbol = Symbol("fedify.rawInboxContextFactory");
+const INBOX_COMPOUND_PROOF_LIMITS = {
+	maxDepth: 64,
+	maxMaps: 1e4,
+	maxProofs: 32,
+	maxBytes: 10 * 1024 * 1024
+};
 function isRemoteContextLoadingFailure$1(error) {
 	return error instanceof Error && typeof error.details === "object" && error.details != null && error.details.code === "loading remote context failed";
 }
@@ -2511,8 +2993,16 @@ async function handleInboxInternal(request, parameters, span) {
 	}
 	let json;
 	try {
-		json = await request.clone().json();
+		json = JSON.parse(await readBoundedText(request.clone(), MAX_BODY_SIZE, request.url));
 	} catch (error) {
+		if (error instanceof BodyTooLargeError) {
+			request.body?.cancel(error).catch(() => {});
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: String(error)
+			});
+			return new Response("Inbox body too large.", { status: 413 });
+		}
 		logger.error("Failed to parse JSON:\n{error}", {
 			recipient,
 			error
@@ -2844,6 +3334,31 @@ async function handleInboxInternal(request, parameters, span) {
 			headers: { "Content-Type": "text/plain; charset=utf-8" }
 		});
 	}
+	if (!skipSignatureVerification) {
+		if (inspectCompoundPortableObjectApplicability(json, INBOX_COMPOUND_PROOF_LIMITS) !== "absent") {
+			const compoundProof = await verifyCompoundPortableObjectProofs(json, INBOX_COMPOUND_PROOF_LIMITS, {
+				documentLoader: ctx.documentLoader,
+				keyCache,
+				meterProvider,
+				tracerProvider
+			});
+			if (compoundProof.status !== "ok" || !compoundProof.verified) {
+				logger.error("Failed to verify compound portable Object Integrity Proofs.", {
+					recipient,
+					activity: json,
+					reason: compoundProof.status === "unsupported" ? compoundProof.reason.type : "invalidProof"
+				});
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: "Failed to verify compound portable Object Integrity Proofs."
+				});
+				return new Response("Failed to verify compound portable Object Integrity Proofs.", {
+					status: 401,
+					headers: { "Content-Type": "text/plain; charset=utf-8" }
+				});
+			}
+		}
+	}
 	if (pendingNonceLabel != null) {
 		if (!await verifySignatureNonce(request, kv, kvPrefixes.acceptSignatureNonce, pendingNonceLabel)) {
 			getFederationMetrics(parameters.meterProvider).recordSignatureVerificationFailure("invalidNonce", httpSigKey?.id == null ? void 0 : getRemoteHost(httpSigKey.id));
@@ -3644,7 +4159,7 @@ async function readLimitedResponseBody(response, maxBytes) {
 	if (truncated) result += "… (truncated)";
 	return result;
 }
-async function sendActivityInternal({ activity, activityId, activityType, keys, inbox, headers, specDeterminer, meterProvider, tracerProvider }, span) {
+async function sendActivityInternal({ activity, activityId, activityType, keys, inbox, allowPrivateAddress, headers, specDeterminer, meterProvider, tracerProvider }, span) {
 	const logger = getLogger([
 		"fedify",
 		"federation",
@@ -3653,12 +4168,25 @@ async function sendActivityInternal({ activity, activityId, activityType, keys,
 	const federationMetrics = getFederationMetrics(meterProvider);
 	const started = performance.now();
 	let deliverySuccess = false;
+	async function validateUrl(url) {
+		if (!allowPrivateAddress) try {
+			await validatePublicUrl(url);
+		} catch (error) {
+			if (error instanceof UrlError) logger.error("Disallowed private URL: {url}", {
+				url,
+				error
+			});
+			throw error;
+		}
+	}
+	await validateUrl(inbox.href);
 	headers = new Headers(headers);
 	headers.set("Content-Type", "application/activity+json");
 	const request = new Request(inbox, {
 		method: "POST",
 		headers,
-		body: JSON.stringify(activity)
+		body: JSON.stringify(activity),
+		redirect: "manual"
 	});
 	let rsaKey = null;
 	for (const key of keys) if (key.privateKey.algorithm.name === "RSASSA-PKCS1-v1_5") {
@@ -3674,19 +4202,20 @@ async function sendActivityInternal({ activity, activityId, activityType, keys,
 	});
 	let response;
 	try {
-		response = rsaKey == null ? await fetch(request) : await doubleKnock(request, rsaKey, {
+		response = rsaKey == null ? await fetchWithValidatedRedirects(request, validateUrl) : await doubleKnock(request, rsaKey, {
 			tracerProvider,
-			specDeterminer
+			specDeterminer,
+			validateRedirect: validateUrl
 		});
 	} catch (error) {
-		const transportError = error instanceof FetchError ? error : createFetchError(inbox.href, error);
+		const failure = error instanceof FetchError || error instanceof UrlError ? error : createFetchError(inbox.href, error);
 		logger.error("Failed to send activity {activityId} to {inbox}:\n{error}", {
 			activityId,
 			inbox: inbox.href,
-			error: transportError
+			error: failure
 		});
 		federationMetrics.recordDelivery(inbox, getDurationMs(started), false, activityType);
-		throw transportError;
+		throw failure;
 	}
 	try {
 		if (!response.ok) {
@@ -3723,6 +4252,49 @@ function createFetchError(url, cause) {
 	error.cause = cause;
 	return error;
 }
+async function fetchWithValidatedRedirects(request, validateUrl) {
+	let body = await request.clone().text();
+	for (let redirects = 0;; redirects++) {
+		const response = await fetch(request, { redirect: "manual" });
+		const location = response.headers.get("Location");
+		if (![
+			301,
+			302,
+			303,
+			307,
+			308
+		].includes(response.status) || location == null) return response;
+		await response.body?.cancel();
+		if (redirects >= 20) throw new TypeError("Too many redirects");
+		const url = new URL(location, request.url);
+		await validateUrl(url.href);
+		const headers = new Headers(request.headers);
+		if (url.origin !== new URL(request.url).origin) {
+			headers.delete("Authorization");
+			headers.delete("Proxy-Authorization");
+			headers.delete("Cookie");
+			headers.delete("Host");
+		}
+		let method = request.method;
+		if ((response.status === 301 || response.status === 302) && method === "POST" || response.status === 303 && method !== "GET" && method !== "HEAD") {
+			method = "GET";
+			body = void 0;
+			for (const name of [
+				"Content-Encoding",
+				"Content-Language",
+				"Content-Length",
+				"Content-Location",
+				"Content-Type"
+			]) headers.delete(name);
+		}
+		request = new Request(url, {
+			method,
+			headers,
+			body,
+			redirect: "manual"
+		});
+	}
+}
 /**
 * An error that is thrown when an activity fails to send to a remote inbox.
 * It contains structured information about the failure, including the HTTP
@@ -5213,6 +5785,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 				if (decision.stateChange != null) recordCircuitBreakerSpanEvent(span, remoteHost, decision.stateChange);
 			}
 			await sendActivity({
+				allowPrivateAddress: this.allowPrivateAddress,
 				keys,
 				activity: message.activity,
 				activityId: message.activityId,
@@ -5834,6 +6407,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 			});
 			const promises = [];
 			for (const inbox in inboxes) promises.push(sendActivity({
+				allowPrivateAddress: this.allowPrivateAddress,
 				keys,
 				activity: jsonLd,
 				activityId: activity.id?.href,
@@ -7168,6 +7742,7 @@ async function forwardActivityInternal(ctx, loggerCategory, forwarder, recipient
 		else logger.debug("Forwarding activity immediately without queue since queue is not set.");
 		const promises = [];
 		for (const inbox in inboxes) promises.push(sendActivity({
+			allowPrivateAddress: ctx.federation.allowPrivateAddress,
 			keys,
 			activity: ctx.activity,
 			activityId: ctx.activityId,