@fedify/fedify 2.2.0-pr.695.16 → 2.2.0-pr.697.17

package/dist/{middleware-RF-sUfTr.js → middleware-BpSfJf2S.js}

@@ -2,10 +2,10 @@ import { Temporal } from "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 import { t as __exportAll } from "./chunk-nlSIicah.js";
 import { r as getDefaultActivityTransformers } from "./transformers-ve6e2xcg.js";
-import { _ as version, a as verifyRequestDetailed, d as validateCryptoKey, f as formatAcceptSignature, g as name, i as verifyRequest, n as parseRfc9421SignatureInput, o as exportJwk, t as doubleKnock, u as importJwk } from "./http-D-MhhYUF.js";
-import { a as doesActorOwnKey, d as signJsonLd, f as verifyJsonLd, l as detachSignature, n as signObject, o as getKeyOwner, r as verifyObject, u as hasSignature } from "./proof-CirP9OSd.js";
+import { _ as version, a as verifyRequestDetailed, d as validateCryptoKey, f as formatAcceptSignature, g as name, i as verifyRequest, n as parseRfc9421SignatureInput, o as exportJwk, t as doubleKnock, u as importJwk } from "./http-CqkZgsp_.js";
+import { d as hasSignatureLike, f as signJsonLd, i as verifyObject, n as hasProofLike, o as doesActorOwnKey, p as verifyJsonLd, r as signObject, s as getKeyOwner, u as detachSignature } from "./proof-BtFhWZuV.js";
 import { n as getNodeInfo, t as nodeInfoToJson } from "./types-hvL8ElAs.js";
-import { n as getAuthenticatedDocumentLoader, t as kvCache } from "./kv-cache-D84Mk0fZ.js";
+import { n as getAuthenticatedDocumentLoader, t as kvCache } from "./kv-cache-Dgsvz3PC.js";
 import { getLogger, withContext } from "@logtape/logtape";
 import { Activity, Collection, CollectionPage, CryptographicKey, Link, Multikey, Object as Object$1, OrderedCollection, OrderedCollectionPage, Tombstone, getTypeId, lookupObject, traverseCollection } from "@fedify/vocab";
 import { SpanKind, SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
@@ -17,14 +17,15 @@ 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 { lookupWebFinger } from "@fedify/webfinger";
 import { domainToASCII } from "node:url";
-//#region src/federation/inbox.ts
-var InboxListenerSet = class InboxListenerSet {
+//#region src/federation/activity-listener.ts
+var ActivityListenerSet = class {
 	#listeners;
 	constructor() {
 		this.#listeners = /* @__PURE__ */ new Map();
 	}
 	clone() {
-		const clone = new InboxListenerSet();
+		const Clone = this.constructor;
+		const clone = new Clone();
 		clone.#listeners = new Map(this.#listeners);
 		return clone;
 	}
@@ -34,14 +35,13 @@ var InboxListenerSet = class InboxListenerSet {
 	}
 	dispatchWithClass(activity) {
 		let cls = activity.constructor;
-		const inboxListeners = this.#listeners;
-		if (inboxListeners == null) return null;
-		while (true) {
-			if (inboxListeners.has(cls)) break;
+		while (cls != null) {
+			if (this.#listeners.has(cls)) break;
 			if (cls === Activity) return null;
 			cls = globalThis.Object.getPrototypeOf(cls);
 		}
-		const listener = inboxListeners.get(cls);
+		if (cls == null) return null;
+		const listener = this.#listeners.get(cls);
 		return {
 			class: cls,
 			listener
@@ -51,142 +51,6 @@ var InboxListenerSet = class InboxListenerSet {
 		return this.dispatchWithClass(activity)?.listener ?? null;
 	}
 };
-async function routeActivity({ context: ctx, json, activity, recipient, inboxListeners, inboxContextFactory, inboxErrorHandler, kv, kvPrefixes, queue, span, tracerProvider, idempotencyStrategy }) {
-	const logger = getLogger([
-		"fedify",
-		"federation",
-		"inbox"
-	]);
-	let cacheKey = null;
-	if (activity.id != null) {
-		const inboxContext = inboxContextFactory(recipient, json, activity.id?.href, getTypeId(activity).href);
-		const strategy = idempotencyStrategy ?? "per-inbox";
-		let keyString;
-		if (typeof strategy === "function") keyString = await strategy(inboxContext, activity);
-		else switch (strategy) {
-			case "global":
-				keyString = activity.id.href;
-				break;
-			case "per-origin":
-				keyString = `${ctx.origin}\n${activity.id.href}`;
-				break;
-			case "per-inbox":
-				keyString = `${ctx.origin}\n${activity.id.href}\n${recipient == null ? "sharedInbox" : `inbox\n${recipient}`}`;
-				break;
-			default: keyString = `${ctx.origin}\n${activity.id.href}`;
-		}
-		if (keyString != null) cacheKey = [...kvPrefixes.activityIdempotence, keyString];
-	}
-	if (cacheKey != null) {
-		if (await kv.get(cacheKey) === true) {
-			logger.debug("Activity {activityId} has already been processed.", {
-				activityId: activity.id?.href,
-				activity: json,
-				recipient
-			});
-			span.setStatus({
-				code: SpanStatusCode.UNSET,
-				message: `Activity ${activity.id?.href} has already been processed.`
-			});
-			return "alreadyProcessed";
-		}
-	}
-	if (activity.actorId == null) {
-		logger.error("Missing actor.", { activity: json });
-		span.setStatus({
-			code: SpanStatusCode.ERROR,
-			message: "Missing actor."
-		});
-		return "missingActor";
-	}
-	span.setAttribute("activitypub.actor.id", activity.actorId.href);
-	if (queue != null) {
-		const carrier = {};
-		propagation.inject(context.active(), carrier);
-		try {
-			await queue.enqueue({
-				type: "inbox",
-				id: crypto.randomUUID(),
-				baseUrl: ctx.origin,
-				activity: json,
-				identifier: recipient,
-				attempt: 0,
-				started: (/* @__PURE__ */ new Date()).toISOString(),
-				traceContext: carrier
-			});
-		} catch (error) {
-			logger.error("Failed to enqueue the incoming activity {activityId}:\n{error}", {
-				error,
-				activityId: activity.id?.href,
-				activity: json,
-				recipient
-			});
-			span.setStatus({
-				code: SpanStatusCode.ERROR,
-				message: `Failed to enqueue the incoming activity ${activity.id?.href}.`
-			});
-			throw error;
-		}
-		logger.info("Activity {activityId} is enqueued.", {
-			activityId: activity.id?.href,
-			activity: json,
-			recipient
-		});
-		return "enqueued";
-	}
-	tracerProvider = tracerProvider ?? trace.getTracerProvider();
-	return await tracerProvider.getTracer(name, version).startActiveSpan("activitypub.dispatch_inbox_listener", { kind: SpanKind.INTERNAL }, async (span) => {
-		const dispatched = inboxListeners?.dispatchWithClass(activity);
-		if (dispatched == null) {
-			logger.error("Unsupported activity type:\n{activity}", {
-				activity: json,
-				recipient
-			});
-			span.setStatus({
-				code: SpanStatusCode.UNSET,
-				message: `Unsupported activity type: ${getTypeId(activity).href}`
-			});
-			span.end();
-			return "unsupportedActivity";
-		}
-		const { class: cls, listener } = dispatched;
-		span.updateName(`activitypub.dispatch_inbox_listener ${cls.name}`);
-		try {
-			await listener(inboxContextFactory(recipient, json, activity?.id?.href, getTypeId(activity).href), activity);
-		} catch (error) {
-			try {
-				await inboxErrorHandler?.(ctx, error);
-			} catch (error) {
-				logger.error("An unexpected error occurred in inbox error handler:\n{error}", {
-					error,
-					activityId: activity.id?.href,
-					activity: json,
-					recipient
-				});
-			}
-			logger.error("Failed to process the incoming activity {activityId}:\n{error}", {
-				error,
-				activityId: activity.id?.href,
-				activity: json,
-				recipient
-			});
-			span.setStatus({
-				code: SpanStatusCode.ERROR,
-				message: String(error)
-			});
-			span.end();
-			return "error";
-		}
-		if (cacheKey != null) await kv.set(cacheKey, true, { ttl: Temporal.Duration.from({ days: 1 }) });
-		logger.info("Activity {activityId} has been processed.", {
-			activityId: activity.id?.href,
-			activity: json,
-			recipient
-		});
-		span.end();
-		return "success";
-	});
-}
 //#endregion
 //#region src/federation/router.ts
 function cloneInnerRouter(router) {
@@ -296,6 +160,17 @@ var RouterError = class extends Error {
 };
 //#endregion
 //#region src/federation/builder.ts
+function validateSingleIdentifierVariablePath(path, errorMessage) {
+	const operatorMatches = globalThis.Array.from(path.matchAll(/{([+#./;?&]?)([A-Za-z_][A-Za-z0-9_]*)}/g));
+	if (operatorMatches.length !== 1 || operatorMatches[0]?.[2] !== "identifier") throw new RouterError(errorMessage);
+	if (operatorMatches.some((match) => [
+		"?",
+		"&",
+		"#"
+	].includes(match[1]) && match[2] === "identifier")) throw new RouterError(errorMessage);
+	const variables = new Router$1().add(path, "outbox");
+	if (variables.size !== 1 || !variables.has("identifier")) throw new RouterError(errorMessage);
+}
 var FederationBuilderImpl = class {
 	router;
 	actorCallbacks;
@@ -304,6 +179,7 @@ var FederationBuilderImpl = class {
 	objectCallbacks;
 	objectTypeIds;
 	inboxPath;
+	outboxPath;
 	inboxCallbacks;
 	outboxCallbacks;
 	followingCallbacks;
@@ -312,7 +188,10 @@ var FederationBuilderImpl = class {
 	featuredCallbacks;
 	featuredTagsCallbacks;
 	inboxListeners;
+	outboxListeners;
 	inboxErrorHandler;
+	outboxListenerErrorHandler;
+	outboxAuthorizePredicate;
 	sharedInboxKeyDispatcher;
 	unverifiedActivityHandler;
 	outboxPermanentFailureHandler;
@@ -343,6 +222,7 @@ var FederationBuilderImpl = class {
 		f.objectCallbacks = { ...this.objectCallbacks };
 		f.objectTypeIds = { ...this.objectTypeIds };
 		f.inboxPath = this.inboxPath;
+		f.outboxPath = this.outboxPath;
 		f.inboxCallbacks = this.inboxCallbacks == null ? void 0 : { ...this.inboxCallbacks };
 		f.outboxCallbacks = this.outboxCallbacks == null ? void 0 : { ...this.outboxCallbacks };
 		f.followingCallbacks = this.followingCallbacks == null ? void 0 : { ...this.followingCallbacks };
@@ -351,7 +231,10 @@ var FederationBuilderImpl = class {
 		f.featuredCallbacks = this.featuredCallbacks == null ? void 0 : { ...this.featuredCallbacks };
 		f.featuredTagsCallbacks = this.featuredTagsCallbacks == null ? void 0 : { ...this.featuredTagsCallbacks };
 		f.inboxListeners = this.inboxListeners?.clone();
+		f.outboxListeners = this.outboxListeners?.clone();
 		f.inboxErrorHandler = this.inboxErrorHandler;
+		f.outboxListenerErrorHandler = this.outboxListenerErrorHandler;
+		f.outboxAuthorizePredicate = this.outboxAuthorizePredicate;
 		f.sharedInboxKeyDispatcher = this.sharedInboxKeyDispatcher;
 		f.unverifiedActivityHandler = this.unverifiedActivityHandler;
 		f.outboxPermanentFailureHandler = this.outboxPermanentFailureHandler;
@@ -551,9 +434,14 @@ var FederationBuilderImpl = class {
 		return setters;
 	}
 	setOutboxDispatcher(path, dispatcher) {
-		if (this.router.has("outbox")) throw new RouterError("Outbox dispatcher already set.");
-		const variables = this.router.add(path, "outbox");
-		if (variables.size !== 1 || !variables.has("identifier")) throw new RouterError("Path for outbox dispatcher must have one variable: {identifier}");
+		if (this.outboxCallbacks != null) throw new RouterError("Outbox dispatcher already set.");
+		if (this.router.has("outbox")) {
+			if (this.outboxPath !== path) throw new RouterError("Outbox dispatcher path must match outbox listener path.");
+		} else {
+			validateSingleIdentifierVariablePath(path, "Path for outbox dispatcher must have one variable: {identifier}");
+			this.router.add(path, "outbox");
+			this.outboxPath = path;
+		}
 		const callbacks = { dispatcher };
 		this.outboxCallbacks = callbacks;
 		const setters = {
@@ -576,6 +464,32 @@ var FederationBuilderImpl = class {
 		};
 		return setters;
 	}
+	setOutboxListeners(outboxPath) {
+		if (this.outboxListeners != null) throw new RouterError("Outbox listeners already set.");
+		if (this.router.has("outbox")) {
+			if (this.outboxPath !== outboxPath) throw new RouterError("Outbox listener path must match outbox dispatcher path.");
+		} else {
+			validateSingleIdentifierVariablePath(outboxPath, "Path for outbox must have one variable: {identifier}");
+			this.router.add(outboxPath, "outbox");
+			this.outboxPath = outboxPath;
+		}
+		const listeners = this.outboxListeners = new ActivityListenerSet();
+		const setters = {
+			on(type, listener) {
+				listeners.add(type, listener);
+				return setters;
+			},
+			onError: (handler) => {
+				this.outboxListenerErrorHandler = handler;
+				return setters;
+			},
+			authorize: (predicate) => {
+				this.outboxAuthorizePredicate = predicate;
+				return setters;
+			}
+		};
+		return setters;
+	}
 	setFollowingDispatcher(path, dispatcher) {
 		if (this.router.has("following")) throw new RouterError("Following collection dispatcher already set.");
 		const variables = this.router.add(path, "following");
@@ -718,7 +632,7 @@ var FederationBuilderImpl = class {
 		if (sharedInboxPath != null) {
 			if (this.router.add(sharedInboxPath, "sharedInbox").size !== 0) throw new RouterError("Path for shared inbox must have no variables.");
 		}
-		const listeners = this.inboxListeners = new InboxListenerSet();
+		const listeners = this.inboxListeners = new ActivityListenerSet();
 		const setters = {
 			on(type, listener) {
 				listeners.add(type, listener);
@@ -855,6 +769,144 @@ async function buildCollectionSynchronizationHeader(collectionId, actorIds) {
 	return `collectionId="${collectionId}", url="${url}", digest="${encodeHex(await digest(actorIds))}"`;
 }
 //#endregion
+//#region src/federation/inbox.ts
+async function routeActivity({ context: ctx, json, activity, recipient, inboxListeners, inboxContextFactory, inboxErrorHandler, kv, kvPrefixes, queue, span, tracerProvider, idempotencyStrategy }) {
+	const logger = getLogger([
+		"fedify",
+		"federation",
+		"inbox"
+	]);
+	let cacheKey = null;
+	if (activity.id != null) {
+		const inboxContext = inboxContextFactory(recipient, json, activity.id?.href, getTypeId(activity).href);
+		const strategy = idempotencyStrategy ?? "per-inbox";
+		let keyString;
+		if (typeof strategy === "function") keyString = await strategy(inboxContext, activity);
+		else switch (strategy) {
+			case "global":
+				keyString = activity.id.href;
+				break;
+			case "per-origin":
+				keyString = `${ctx.origin}\n${activity.id.href}`;
+				break;
+			case "per-inbox":
+				keyString = `${ctx.origin}\n${activity.id.href}\n${recipient == null ? "sharedInbox" : `inbox\n${recipient}`}`;
+				break;
+			default: keyString = `${ctx.origin}\n${activity.id.href}`;
+		}
+		if (keyString != null) cacheKey = [...kvPrefixes.activityIdempotence, keyString];
+	}
+	if (cacheKey != null) {
+		if (await kv.get(cacheKey) === true) {
+			logger.debug("Activity {activityId} has already been processed.", {
+				activityId: activity.id?.href,
+				activity: json,
+				recipient
+			});
+			span.setStatus({
+				code: SpanStatusCode.UNSET,
+				message: `Activity ${activity.id?.href} has already been processed.`
+			});
+			return "alreadyProcessed";
+		}
+	}
+	if (activity.actorId == null) {
+		logger.error("Missing actor.", { activity: json });
+		span.setStatus({
+			code: SpanStatusCode.ERROR,
+			message: "Missing actor."
+		});
+		return "missingActor";
+	}
+	span.setAttribute("activitypub.actor.id", activity.actorId.href);
+	if (queue != null) {
+		const carrier = {};
+		propagation.inject(context.active(), carrier);
+		try {
+			await queue.enqueue({
+				type: "inbox",
+				id: crypto.randomUUID(),
+				baseUrl: ctx.origin,
+				activity: json,
+				identifier: recipient,
+				attempt: 0,
+				started: (/* @__PURE__ */ new Date()).toISOString(),
+				traceContext: carrier
+			});
+		} catch (error) {
+			logger.error("Failed to enqueue the incoming activity {activityId}:\n{error}", {
+				error,
+				activityId: activity.id?.href,
+				activity: json,
+				recipient
+			});
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: `Failed to enqueue the incoming activity ${activity.id?.href}.`
+			});
+			throw error;
+		}
+		logger.info("Activity {activityId} is enqueued.", {
+			activityId: activity.id?.href,
+			activity: json,
+			recipient
+		});
+		return "enqueued";
+	}
+	tracerProvider = tracerProvider ?? trace.getTracerProvider();
+	return await tracerProvider.getTracer(name, version).startActiveSpan("activitypub.dispatch_inbox_listener", { kind: SpanKind.INTERNAL }, async (span) => {
+		const dispatched = inboxListeners?.dispatchWithClass(activity);
+		if (dispatched == null) {
+			logger.error("Unsupported activity type:\n{activity}", {
+				activity: json,
+				recipient
+			});
+			span.setStatus({
+				code: SpanStatusCode.UNSET,
+				message: `Unsupported activity type: ${getTypeId(activity).href}`
+			});
+			span.end();
+			return "unsupportedActivity";
+		}
+		const { class: cls, listener } = dispatched;
+		span.updateName(`activitypub.dispatch_inbox_listener ${cls.name}`);
+		try {
+			await listener(inboxContextFactory(recipient, json, activity?.id?.href, getTypeId(activity).href), activity);
+		} catch (error) {
+			try {
+				await inboxErrorHandler?.(ctx, error);
+			} catch (error) {
+				logger.error("An unexpected error occurred in inbox error handler:\n{error}", {
+					error,
+					activityId: activity.id?.href,
+					activity: json,
+					recipient
+				});
+			}
+			logger.error("Failed to process the incoming activity {activityId}:\n{error}", {
+				error,
+				activityId: activity.id?.href,
+				activity: json,
+				recipient
+			});
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: String(error)
+			});
+			span.end();
+			return "error";
+		}
+		if (cacheKey != null) await kv.set(cacheKey, true, { ttl: Temporal.Duration.from({ days: 1 }) });
+		logger.info("Activity {activityId} has been processed.", {
+			activityId: activity.id?.href,
+			activity: json,
+			recipient
+		});
+		span.end();
+		return "success";
+	});
+}
+//#endregion
 //#region src/federation/keycache.ts
 var KvKeyCache = class {
 	kv;
@@ -1082,8 +1134,8 @@ async function handleObject(request, { values, context, objectDispatcher, author
 * @param parameters The parameters for handling the collection.
 * @returns A promise that resolves to an HTTP response.
 */
-async function handleCollection(request, { name: name$2, identifier, uriGetter, filter, filterPredicate, context, collectionCallbacks, tracerProvider, onUnauthorized, onNotFound }) {
-	const spanName = name$2.trim().replace(/\s+/g, "_");
+async function handleCollection(request, { name: name$1, identifier, uriGetter, filter, filterPredicate, context, collectionCallbacks, tracerProvider, onUnauthorized, onNotFound }) {
+	const spanName = name$1.trim().replace(/\s+/g, "_");
 	tracerProvider = tracerProvider ?? trace.getTracerProvider();
 	const tracer = tracerProvider.getTracer(name, version);
 	const cursor = new URL(request.url).searchParams.get("cursor");
@@ -1125,7 +1177,7 @@ async function handleCollection(request, { name: name$2, identifier, uriGetter,
 			collection = new OrderedCollection({
 				id: baseUri,
 				totalItems: totalItems == null ? null : Number(totalItems),
-				items: filterCollectionItems(itemsOrResponse, name$2, filterPredicate)
+				items: filterCollectionItems(itemsOrResponse, name$1, filterPredicate)
 			});
 		} else {
 			const lastCursor = await collectionCallbacks.lastCursor?.(context, identifier);
@@ -1146,7 +1198,7 @@ async function handleCollection(request, { name: name$2, identifier, uriGetter,
 	} else {
 		const uri = new URL(baseUri);
 		uri.searchParams.set("cursor", cursor);
-		const pageOrResponse = await tracer.startActiveSpan(`activitypub.dispatch_collection_page ${name$2}`, {
+		const pageOrResponse = await tracer.startActiveSpan(`activitypub.dispatch_collection_page ${name$1}`, {
 			kind: SpanKind.SERVER,
 			attributes: {
 				"activitypub.collection.id": uri.href,
@@ -1190,7 +1242,7 @@ async function handleCollection(request, { name: name$2, identifier, uriGetter,
 			id: uri,
 			prev,
 			next,
-			items: filterCollectionItems(items, name$2, filterPredicate),
+			items: filterCollectionItems(items, name$1, filterPredicate),
 			partOf
 		});
 	}
@@ -1230,9 +1282,205 @@ function filterCollectionItems(items, collectionName, filterPredicate) {
 			}
 			continue;
 		}
-		result.push(mappedItem);
+		result.push(mappedItem);
+	}
+	return result;
+}
+function summarizeJsonActivity(json) {
+	if (json == null || typeof json !== "object") return {};
+	const activity = json;
+	return {
+		activityId: typeof activity.id === "string" ? activity.id : void 0,
+		activityType: typeof activity.type === "string" ? activity.type : void 0
+	};
+}
+/**
+* Handles an outbox POST request.
+* @template TContextData The context data to pass to the context.
+* @param request The HTTP request.
+* @param parameters The parameters for handling the request.
+* @returns A promise that resolves to an HTTP response.
+* @since 2.2.0
+*/
+async function handleOutbox(request, { identifier, context: ctx, outboxContextFactory, actorDispatcher, authorizePredicate, outboxListeners, outboxErrorHandler, onUnauthorized, onNotFound }) {
+	const logger = getLogger([
+		"fedify",
+		"federation",
+		"outbox"
+	]);
+	if (request.bodyUsed) {
+		logger.error("Request body has already been read.", { identifier });
+		return new Response("Internal server error.", {
+			status: 500,
+			headers: { "Content-Type": "text/plain; charset=utf-8" }
+		});
+	} else if (request.body?.locked) {
+		logger.error("Request body is locked.", { identifier });
+		return new Response("Internal server error.", {
+			status: 500,
+			headers: { "Content-Type": "text/plain; charset=utf-8" }
+		});
+	}
+	if (actorDispatcher == null) {
+		logger.error("Actor dispatcher is not set.", { identifier });
+		return await onNotFound(request);
+	}
+	if (authorizePredicate != null) {
+		const authorizeContext = ctx.clone(ctx.data);
+		authorizeContext.request = request.clone();
+		const requestForUnauthorized = authorizeContext.request.clone();
+		if (!await authorizePredicate(authorizeContext, identifier)) return await onUnauthorized(requestForUnauthorized);
+	}
+	const actor = await actorDispatcher(ctx, identifier);
+	if (actor == null || actor instanceof Tombstone) {
+		logger.error("Actor {identifier} not found.", { identifier });
+		return await onNotFound(request);
+	}
+	const requestForParsing = request.clone();
+	let json;
+	try {
+		json = await requestForParsing.json();
+	} catch (error) {
+		logger.error("Failed to parse JSON:\n{error}", {
+			identifier,
+			error
+		});
+		const outboxContext = outboxContextFactory(identifier, null, void 0, "");
+		try {
+			await outboxErrorHandler?.(outboxContext, error);
+		} catch (error) {
+			logger.error("An unexpected error occurred in outbox error handler:\n{error}", {
+				error,
+				identifier
+			});
+		}
+		return new Response("Invalid JSON.", {
+			status: 400,
+			headers: { "Content-Type": "text/plain; charset=utf-8" }
+		});
+	}
+	let activity;
+	try {
+		activity = await Activity.fromJsonLd(json, ctx);
+	} catch (error) {
+		const summary = summarizeJsonActivity(json);
+		logger.error("Failed to parse activity:\n{error}", {
+			identifier,
+			...summary,
+			error
+		});
+		const outboxContext = outboxContextFactory(identifier, json, summary.activityId, summary.activityType ?? "");
+		try {
+			await outboxErrorHandler?.(outboxContext, error);
+		} catch (error) {
+			logger.error("An unexpected error occurred in outbox error handler:\n{error}", {
+				error,
+				identifier,
+				...summary
+			});
+		}
+		return new Response("Invalid activity.", {
+			status: 400,
+			headers: { "Content-Type": "text/plain; charset=utf-8" }
+		});
+	}
+	const outboxContext = outboxContextFactory(identifier, json, activity.id?.href, getTypeId(activity).href);
+	const expectedActorId = actor.id ?? ctx.getActorUri(identifier);
+	if (activity.actorIds.length < 1) {
+		const error = /* @__PURE__ */ new Error("The posted activity has no actor.");
+		logger.error("The posted activity has no actor for outbox {identifier}.", {
+			identifier,
+			activityId: activity.id?.href,
+			expectedActorId: expectedActorId.href
+		});
+		try {
+			await outboxErrorHandler?.(outboxContext, error);
+		} catch (error) {
+			logger.error("An unexpected error occurred in outbox error handler:\n{error}", {
+				error,
+				activityId: activity.id?.href,
+				activityType: getTypeId(activity).href,
+				identifier
+			});
+		}
+		return new Response(error.message, {
+			status: 400,
+			headers: { "Content-Type": "text/plain; charset=utf-8" }
+		});
 	}
-	return result;
+	if (!activity.actorIds.every((actorId) => actorId.href === expectedActorId.href)) {
+		const error = /* @__PURE__ */ new Error("The activity actor does not match the outbox owner.");
+		logger.error("The posted activity actor does not match outbox owner {identifier}.", {
+			identifier,
+			activityId: activity.id?.href,
+			expectedActorId: expectedActorId.href,
+			actorIds: activity.actorIds.map((actorId) => actorId.href)
+		});
+		try {
+			await outboxErrorHandler?.(outboxContext, error);
+		} catch (error) {
+			logger.error("An unexpected error occurred in outbox error handler:\n{error}", {
+				error,
+				activityId: activity.id?.href,
+				activityType: getTypeId(activity).href,
+				identifier
+			});
+		}
+		return new Response(error.message, {
+			status: 400,
+			headers: { "Content-Type": "text/plain; charset=utf-8" }
+		});
+	}
+	const dispatched = outboxListeners?.dispatchWithClass(activity);
+	if (dispatched == null) {
+		logger.debug("Unsupported activity type {activityType}.", {
+			identifier,
+			activityId: activity.id?.href,
+			activityType: getTypeId(activity).href
+		});
+		return new Response("", {
+			status: 202,
+			headers: { "Content-Type": "text/plain; charset=utf-8" }
+		});
+	}
+	try {
+		await dispatched.listener(outboxContext, activity);
+	} catch (error) {
+		try {
+			await outboxErrorHandler?.(outboxContext, error);
+		} catch (error) {
+			logger.error("An unexpected error occurred in outbox error handler:\n{error}", {
+				error,
+				activityId: activity.id?.href,
+				activityType: getTypeId(activity).href,
+				identifier
+			});
+		}
+		logger.error("Failed to process the incoming activity {activityId}:\n{error}", {
+			error,
+			activityId: activity.id?.href,
+			activityType: getTypeId(activity).href,
+			identifier
+		});
+		return new Response("Internal server error.", {
+			status: 500,
+			headers: { "Content-Type": "text/plain; charset=utf-8" }
+		});
+	}
+	if (!outboxContext.hasDeliveredActivity()) logger.warn("Outbox listener for {identifier} returned without delivering the posted activity; ctx.sendActivity() or ctx.forwardActivity() may have been skipped or resulted in no delivery.", {
+		identifier,
+		activityId: activity.id?.href,
+		activityType: getTypeId(activity).href
+	});
+	logger.info("Activity {activityId} has been processed in outbox listener.", {
+		activityId: activity.id?.href,
+		activityType: getTypeId(activity).href,
+		identifier
+	});
+	return new Response("", {
+		status: 202,
+		headers: { "Content-Type": "text/plain; charset=utf-8" }
+	});
 }
 /**
 * Handles an inbox request for ActivityPub activities.
@@ -1664,8 +1912,8 @@ var CustomCollectionHandler = class {
 	* @param CollectionPage The CollectionPage constructor.
 	* @param filterPredicate Optional filter predicate for items.
 	*/
-	constructor(name$1, values, context, callbacks, tracerProvider = trace.getTracerProvider(), Collection, CollectionPage, filterPredicate) {
-		this.name = name$1;
+	constructor(name$2, values, context, callbacks, tracerProvider = trace.getTracerProvider(), Collection, CollectionPage, filterPredicate) {
+		this.name = name$2;
 		this.values = values;
 		this.context = context;
 		this.callbacks = callbacks;
@@ -2467,6 +2715,7 @@ var middleware_exports = /* @__PURE__ */ __exportAll({
 	FederationImpl: () => FederationImpl,
 	InboxContextImpl: () => InboxContextImpl,
 	KvSpecDeterminer: () => KvSpecDeterminer,
+	OutboxContextImpl: () => OutboxContextImpl,
 	createFederation: () => createFederation
 });
 /**
@@ -3281,16 +3530,37 @@ var FederationImpl = class extends FederationBuilderImpl {
 					onNotFound
 				});
 			}
-			case "outbox": return await handleCollection(request, {
-				name: "outbox",
-				identifier: route.values.identifier,
-				uriGetter: context.getOutboxUri.bind(context),
-				context,
-				collectionCallbacks: this.outboxCallbacks,
-				tracerProvider: this.tracerProvider,
-				onUnauthorized,
-				onNotFound
-			});
+			case "outbox":
+				if (request.method === "POST") {
+					if (this.outboxListeners == null) return new Response("Method not allowed.", {
+						status: 405,
+						headers: {
+							Allow: "GET, HEAD",
+							"Content-Type": "text/plain; charset=utf-8"
+						}
+					});
+					return await handleOutbox(request, {
+						identifier: route.values.identifier,
+						context,
+						outboxContextFactory: context.toOutboxContext.bind(context),
+						actorDispatcher: this.actorCallbacks?.dispatcher,
+						authorizePredicate: this.outboxAuthorizePredicate ?? this.outboxCallbacks?.authorizePredicate,
+						outboxListeners: this.outboxListeners,
+						outboxErrorHandler: this.outboxListenerErrorHandler,
+						onUnauthorized,
+						onNotFound
+					});
+				}
+				return await handleCollection(request, {
+					name: "outbox",
+					identifier: route.values.identifier,
+					uriGetter: context.getOutboxUri.bind(context),
+					context,
+					collectionCallbacks: this.outboxCallbacks,
+					tracerProvider: this.tracerProvider,
+					onUnauthorized,
+					onNotFound
+				});
 			case "inbox":
 				if (request.method !== "POST") return await handleCollection(request, {
 					name: "inbox",
@@ -3460,6 +3730,16 @@ var ContextImpl = class ContextImpl {
 			invokedFromActorKeyPairsDispatcher: this.invokedFromActorKeyPairsDispatcher
 		});
 	}
+	toOutboxContext(identifier, activity, activityId, activityType) {
+		return new OutboxContextImpl(identifier, activity, activityId, activityType, {
+			url: this.url,
+			federation: this.federation,
+			data: this.data,
+			documentLoader: this.documentLoader,
+			contextLoader: this.contextLoader,
+			invokedFromActorKeyPairsDispatcher: this.invokedFromActorKeyPairsDispatcher
+		});
+	}
 	get hostname() {
 		return this.url.hostname;
 	}
@@ -3749,9 +4029,9 @@ var ContextImpl = class ContextImpl {
 			attributes: {
 				"activitypub.activity.type": getTypeId(activity).href,
 				"activitypub.activity.to": activity.toIds.map((to) => to.href),
-				"activitypub.activity.cc": activity.toIds.map((cc) => cc.href),
+				"activitypub.activity.cc": activity.ccIds.map((cc) => cc.href),
 				"activitypub.activity.bto": activity.btoIds.map((bto) => bto.href),
-				"activitypub.activity.bcc": activity.toIds.map((bcc) => bcc.href)
+				"activitypub.activity.bcc": activity.bccIds.map((bcc) => bcc.href)
 			}
 		}, async (span) => {
 			try {
@@ -3846,6 +4126,13 @@ var ContextImpl = class ContextImpl {
 			preferSharedInbox: options.preferSharedInbox,
 			excludeBaseUris: options.excludeBaseUris
 		});
+		if (globalThis.Object.keys(inboxes).length < 1) {
+			logger.debug("No inboxes found for activity {activityId}.", {
+				activityId: activity.id?.href,
+				activity
+			});
+			return false;
+		}
 		logger.debug("Sending activity {activityId} to inboxes:\n{inboxes}", {
 			inboxes: globalThis.Object.keys(inboxes),
 			activityId: activity.id?.href,
@@ -3853,7 +4140,7 @@ var ContextImpl = class ContextImpl {
 		});
 		if (this.federation.fanoutQueue == null || options.immediate || options.fanout === "skip" || (options.fanout ?? "auto") === "auto" && globalThis.Object.keys(inboxes).length < FANOUT_THRESHOLD) {
 			await this.federation.sendActivity(keys, inboxes, activity, opts);
-			return;
+			return true;
 		}
 		const keyJwkPairs = await Promise.all(keys.map(async ({ keyId, privateKey }) => ({
 			keyId: keyId.href,
@@ -3882,6 +4169,7 @@ var ContextImpl = class ContextImpl {
 		};
 		if (!this.federation.manuallyStartQueue) this.federation._startQueueInternal(this.data);
 		await this.federation.fanoutQueue.enqueue(message, { orderingKey: options.orderingKey });
+		return true;
 	}
 	async *getFollowers(identifier) {
 		if (this.federation.followersCallbacks == null) throw new Error("No followers collection dispatcher registered.");
@@ -4116,6 +4404,170 @@ var RequestContextImpl = class RequestContextImpl extends ContextImpl {
 		}
 	}
 };
+function forwardActivity(ctx, loggerCategory, forwarder, recipients, options) {
+	return ctx.tracerProvider.getTracer(name, version).startActiveSpan(ctx.federation.outboxQueue == null || options?.immediate ? `activitypub.${loggerCategory}` : "activitypub.fanout", {
+		kind: ctx.federation.outboxQueue == null || options?.immediate ? SpanKind.CLIENT : SpanKind.PRODUCER,
+		attributes: { "activitypub.activity.type": ctx.activityType }
+	}, async (span) => {
+		try {
+			if (ctx.activityId != null) span.setAttribute("activitypub.activity.id", ctx.activityId);
+			return await forwardActivityInternal(ctx, loggerCategory, forwarder, recipients, options);
+		} catch (e) {
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: String(e)
+			});
+			throw e;
+		} finally {
+			span.end();
+		}
+	});
+}
+async function forwardActivityInternal(ctx, loggerCategory, forwarder, recipients, options) {
+	const logger = getLogger([
+		"fedify",
+		"federation",
+		loggerCategory
+	]);
+	let keys;
+	let identifier = null;
+	if ("identifier" in forwarder || "username" in forwarder) {
+		if ("identifier" in forwarder) identifier = forwarder.identifier;
+		else {
+			const username = forwarder.username;
+			if (ctx.federation.actorCallbacks?.handleMapper == null) identifier = username;
+			else {
+				const mapped = await ctx.federation.actorCallbacks.handleMapper(ctx, username);
+				if (mapped == null) throw new Error(`No actor found for the given username ${JSON.stringify(username)}.`);
+				identifier = mapped;
+			}
+		}
+		const actorKeyPairs = await ctx.getActorKeyPairs(identifier);
+		if (actorKeyPairs.length < 1) throw new Error(`No key pair found for actor ${JSON.stringify(identifier)}.`);
+		keys = actorKeyPairs.map((kp) => ({
+			keyId: kp.keyId,
+			privateKey: kp.privateKey
+		}));
+	} else if (Array.isArray(forwarder)) {
+		if (forwarder.length < 1) throw new Error("The forwarder's key pairs are empty.");
+		keys = forwarder;
+	} else keys = [forwarder];
+	if (!hasSignatureLike(ctx.activity)) {
+		if (!hasProofLike(ctx.activity)) {
+			if (options?.skipIfUnsigned) return false;
+			logger.warn("The activity {activityId} is not signed; even if it is forwarded to other servers as is, it may not be accepted by them due to the lack of a signature/proof.", {
+				activityId: ctx.activityId,
+				activityType: ctx.activityType,
+				identifier: identifier ?? void 0
+			});
+		}
+	}
+	if (recipients === "followers") {
+		if (identifier == null) throw new Error("If recipients is \"followers\", forwarder must be an actor identifier or username.");
+		const followers = [];
+		for await (const recipient of ctx.getFollowers(identifier)) followers.push(recipient);
+		recipients = followers;
+	}
+	const inboxes = extractInboxes({
+		recipients: Array.isArray(recipients) ? recipients : [recipients],
+		preferSharedInbox: options?.preferSharedInbox,
+		excludeBaseUris: options?.excludeBaseUris
+	});
+	if (globalThis.Object.keys(inboxes).length < 1) {
+		logger.debug("No inboxes found for activity {activityId}.", {
+			activityId: ctx.activityId,
+			activityType: ctx.activityType,
+			identifier: identifier ?? void 0
+		});
+		return false;
+	}
+	logger.debug("Forwarding activity {activityId} to inboxes:\n{inboxes}", {
+		inboxes: globalThis.Object.keys(inboxes),
+		activityId: ctx.activityId,
+		activity: ctx.activity
+	});
+	if (options?.immediate || ctx.federation.outboxQueue == null) {
+		if (options?.immediate) logger.debug("Forwarding activity immediately without queue since immediate option is set.");
+		else logger.debug("Forwarding activity immediately without queue since queue is not set.");
+		const promises = [];
+		for (const inbox in inboxes) promises.push(sendActivity({
+			keys,
+			activity: ctx.activity,
+			activityId: ctx.activityId,
+			activityType: ctx.activityType,
+			inbox: new URL(inbox),
+			sharedInbox: inboxes[inbox].sharedInbox,
+			tracerProvider: ctx.tracerProvider,
+			specDeterminer: new KvSpecDeterminer(ctx.federation.kv, ctx.federation.kvPrefixes.httpMessageSignaturesSpec, ctx.federation.firstKnock)
+		}));
+		await Promise.all(promises);
+		return true;
+	}
+	logger.debug("Enqueuing activity {activityId} to forward later.", {
+		activityId: ctx.activityId,
+		activity: ctx.activity
+	});
+	if (!ctx.federation.manuallyStartQueue) ctx.federation._startQueueInternal(ctx.data);
+	const keyJwkPairs = [];
+	for (const { keyId, privateKey } of keys) {
+		const privateKeyJwk = await exportJwk(privateKey);
+		keyJwkPairs.push({
+			keyId: keyId.href,
+			privateKey: privateKeyJwk
+		});
+	}
+	const carrier = {};
+	propagation.inject(context.active(), carrier);
+	const orderingKey = options?.orderingKey;
+	const started = (/* @__PURE__ */ new Date()).toISOString();
+	const messages = [];
+	for (const inbox in inboxes) {
+		const inboxUrl = new URL(inbox);
+		const message = {
+			type: "outbox",
+			id: crypto.randomUUID(),
+			baseUrl: ctx.origin,
+			keys: keyJwkPairs,
+			activity: ctx.activity,
+			activityId: ctx.activityId,
+			activityType: ctx.activityType,
+			inbox,
+			sharedInbox: inboxes[inbox].sharedInbox,
+			actorIds: [...inboxes[inbox].actorIds],
+			started,
+			attempt: 0,
+			headers: {},
+			orderingKey: orderingKey == null ? void 0 : `${orderingKey}\n${inboxUrl.origin}`,
+			traceContext: carrier
+		};
+		messages.push({
+			message,
+			orderingKey: message.orderingKey
+		});
+	}
+	const { outboxQueue } = ctx.federation;
+	if (outboxQueue.enqueueMany == null || orderingKey != null) {
+		const promises = messages.map((m) => outboxQueue.enqueue(m.message, { orderingKey: m.orderingKey }));
+		const errors = (await Promise.allSettled(promises)).filter((r) => r.status === "rejected").map((r) => r.reason);
+		if (errors.length > 0) {
+			logger.error("Failed to enqueue activity {activityId} to forward later:\n{errors}", {
+				activityId: ctx.activityId,
+				errors
+			});
+			if (errors.length > 1) throw new AggregateError(errors, `Failed to enqueue activity ${ctx.activityId} to forward later.`);
+			throw errors[0];
+		}
+	} else try {
+		await outboxQueue.enqueueMany(messages.map((m) => m.message));
+	} catch (error) {
+		logger.error("Failed to enqueue activity {activityId} to forward later:\n{error}", {
+			activityId: ctx.activityId,
+			error
+		});
+		throw error;
+	}
+	return true;
+}
 var InboxContextImpl = class InboxContextImpl extends ContextImpl {
 	recipient;
 	activity;
@@ -4139,13 +4591,40 @@ var InboxContextImpl = class InboxContextImpl extends ContextImpl {
 		});
 	}
 	forwardActivity(forwarder, recipients, options) {
-		return this.tracerProvider.getTracer(name, version).startActiveSpan("activitypub.outbox", {
-			kind: this.federation.outboxQueue == null || options?.immediate ? SpanKind.CLIENT : SpanKind.PRODUCER,
-			attributes: { "activitypub.activity.type": this.activityType }
+		return forwardActivity(this, "inbox", forwarder, recipients, options).then(() => void 0);
+	}
+};
+var OutboxContextImpl = class OutboxContextImpl extends ContextImpl {
+	#deliveryState;
+	identifier;
+	activity;
+	activityId;
+	activityType;
+	constructor(identifier, activity, activityId, activityType, options, deliveryState = { delivered: false }) {
+		super(options);
+		this.#deliveryState = deliveryState;
+		this.identifier = identifier;
+		this.activity = activity;
+		this.activityId = activityId;
+		this.activityType = activityType;
+	}
+	hasDeliveredActivity() {
+		return this.#deliveryState.delivered;
+	}
+	sendActivity(sender, recipients, activity, options = {}) {
+		return this.tracerProvider.getTracer(name, version).startActiveSpan(this.federation.outboxQueue == null || options.immediate ? "activitypub.outbox" : "activitypub.fanout", {
+			kind: this.federation.outboxQueue == null || options.immediate ? SpanKind.CLIENT : SpanKind.PRODUCER,
+			attributes: {
+				"activitypub.activity.type": getTypeId(activity).href,
+				"activitypub.activity.to": activity.toIds.map((to) => to.href),
+				"activitypub.activity.cc": activity.ccIds.map((cc) => cc.href),
+				"activitypub.activity.bto": activity.btoIds.map((bto) => bto.href),
+				"activitypub.activity.bcc": activity.bccIds.map((bcc) => bcc.href)
+			}
 		}, async (span) => {
 			try {
-				if (this.activityId != null) span.setAttribute("activitypub.activity.id", this.activityId);
-				await this.forwardActivityInternal(forwarder, recipients, options);
+				if (activity.id != null) span.setAttribute("activitypub.activity.id", activity.id.href);
+				if (await this.sendActivityInternal(sender, recipients, activity, options, span)) this.#deliveryState.delivered = true;
 			} catch (e) {
 				span.setStatus({
 					code: SpanStatusCode.ERROR,
@@ -4157,151 +4636,20 @@ var InboxContextImpl = class InboxContextImpl extends ContextImpl {
 			}
 		});
 	}
-	async forwardActivityInternal(forwarder, recipients, options) {
-		const logger = getLogger([
-			"fedify",
-			"federation",
-			"inbox"
-		]);
-		let keys;
-		let identifier = null;
-		if ("identifier" in forwarder || "username" in forwarder) {
-			if ("identifier" in forwarder) identifier = forwarder.identifier;
-			else {
-				const username = forwarder.username;
-				if (this.federation.actorCallbacks?.handleMapper == null) identifier = username;
-				else {
-					const mapped = await this.federation.actorCallbacks.handleMapper(this, username);
-					if (mapped == null) throw new Error(`No actor found for the given username ${JSON.stringify(username)}.`);
-					identifier = mapped;
-				}
-			}
-			const actorKeyPairs = await this.getActorKeyPairs(identifier);
-			if (actorKeyPairs.length < 1) throw new Error(`No key pair found for actor ${JSON.stringify(identifier)}.`);
-			keys = actorKeyPairs.map((kp) => ({
-				keyId: kp.keyId,
-				privateKey: kp.privateKey
-			}));
-		} else if (Array.isArray(forwarder)) {
-			if (forwarder.length < 1) throw new Error("The forwarder's key pairs are empty.");
-			keys = forwarder;
-		} else keys = [forwarder];
-		if (!hasSignature(this.activity)) {
-			let hasProof;
-			try {
-				hasProof = await (await Activity.fromJsonLd(this.activity, this)).getProof() != null;
-			} catch {
-				hasProof = false;
-			}
-			if (!hasProof) {
-				if (options?.skipIfUnsigned) return;
-				logger.warn("The received activity {activityId} is not signed; even if it is forwarded to other servers as is, it may not be accepted by them due to the lack of a signature/proof.");
-			}
-		}
-		if (recipients === "followers") {
-			if (identifier == null) throw new Error("If recipients is \"followers\", forwarder must be an actor identifier or username.");
-			const followers = [];
-			for await (const recipient of this.getFollowers(identifier)) followers.push(recipient);
-			recipients = followers;
-		}
-		const inboxes = extractInboxes({
-			recipients: Array.isArray(recipients) ? recipients : [recipients],
-			preferSharedInbox: options?.preferSharedInbox,
-			excludeBaseUris: options?.excludeBaseUris
-		});
-		logger.debug("Forwarding activity {activityId} to inboxes:\n{inboxes}", {
-			inboxes: globalThis.Object.keys(inboxes),
-			activityId: this.activityId,
-			activity: this.activity
-		});
-		if (options?.immediate || this.federation.outboxQueue == null) {
-			if (options?.immediate) logger.debug("Forwarding activity immediately without queue since immediate option is set.");
-			else logger.debug("Forwarding activity immediately without queue since queue is not set.");
-			const promises = [];
-			for (const inbox in inboxes) promises.push(sendActivity({
-				keys,
-				activity: this.activity,
-				activityId: this.activityId,
-				activityType: this.activityType,
-				inbox: new URL(inbox),
-				sharedInbox: inboxes[inbox].sharedInbox,
-				tracerProvider: this.tracerProvider,
-				specDeterminer: new KvSpecDeterminer(this.federation.kv, this.federation.kvPrefixes.httpMessageSignaturesSpec, this.federation.firstKnock)
-			}));
-			await Promise.all(promises);
-			return;
-		}
-		logger.debug("Enqueuing activity {activityId} to forward later.", {
-			activityId: this.activityId,
-			activity: this.activity
+	forwardActivity(forwarder, recipients, options) {
+		return forwardActivity(this, "outbox", forwarder, recipients, options).then((delivered) => {
+			if (delivered) this.#deliveryState.delivered = true;
 		});
-		const keyJwkPairs = [];
-		for (const { keyId, privateKey } of keys) {
-			const privateKeyJwk = await exportJwk(privateKey);
-			keyJwkPairs.push({
-				keyId: keyId.href,
-				privateKey: privateKeyJwk
-			});
-		}
-		const carrier = {};
-		propagation.inject(context.active(), carrier);
-		const orderingKey = options?.orderingKey;
-		const messages = [];
-		for (const inbox in inboxes) {
-			const inboxUrl = new URL(inbox);
-			const message = {
-				type: "outbox",
-				id: crypto.randomUUID(),
-				baseUrl: this.origin,
-				keys: keyJwkPairs,
-				activity: this.activity,
-				activityId: this.activityId,
-				activityType: this.activityType,
-				inbox,
-				sharedInbox: inboxes[inbox].sharedInbox,
-				started: (/* @__PURE__ */ new Date()).toISOString(),
-				attempt: 0,
-				headers: {},
-				orderingKey: orderingKey == null ? void 0 : `${orderingKey}\n${inboxUrl.origin}`,
-				traceContext: carrier
-			};
-			messages.push({
-				message,
-				orderingKey: message.orderingKey
-			});
-		}
-		const { outboxQueue } = this.federation;
-		if (outboxQueue.enqueueMany == null) {
-			const promises = messages.map((m) => outboxQueue.enqueue(m.message, { orderingKey: m.orderingKey }));
-			const errors = (await Promise.allSettled(promises)).filter((r) => r.status === "rejected").map((r) => r.reason);
-			if (errors.length > 0) {
-				logger.error("Failed to enqueue activity {activityId} to forward later:\n{errors}", {
-					activityId: this.activityId,
-					errors
-				});
-				if (errors.length > 1) throw new AggregateError(errors, `Failed to enqueue activity ${this.activityId} to forward later.`);
-				throw errors[0];
-			}
-		} else if (orderingKey != null) {
-			const promises = messages.map((m) => outboxQueue.enqueue(m.message, { orderingKey: m.orderingKey }));
-			const errors = (await Promise.allSettled(promises)).filter((r) => r.status === "rejected").map((r) => r.reason);
-			if (errors.length > 0) {
-				logger.error("Failed to enqueue activity {activityId} to forward later:\n{errors}", {
-					activityId: this.activityId,
-					errors
-				});
-				if (errors.length > 1) throw new AggregateError(errors, `Failed to enqueue activity ${this.activityId} to forward later.`);
-				throw errors[0];
-			}
-		} else try {
-			await outboxQueue.enqueueMany(messages.map((m) => m.message));
-		} catch (error) {
-			logger.error("Failed to enqueue activity {activityId} to forward later:\n{error}", {
-				activityId: this.activityId,
-				error
-			});
-			throw error;
-		}
+	}
+	clone(data) {
+		return new OutboxContextImpl(this.identifier, this.activity, this.activityId, this.activityType, {
+			url: this.url,
+			federation: this.federation,
+			data,
+			documentLoader: this.documentLoader,
+			contextLoader: this.contextLoader,
+			invokedFromActorKeyPairsDispatcher: this.invokedFromActorKeyPairsDispatcher
+		}, this.#deliveryState);
 	}
 };
 var KvSpecDeterminer = class {