@fedify/fedify 2.3.0-dev.1079 → 2.3.0-dev.1110

package/dist/{middleware-DZNHpEbh.js → middleware-CjzI3aYo.js}

@@ -1,11 +1,11 @@
 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-b__OS_rJ.js";
-import { c as getKeyOwner, d as detachSignature, f as hasSignatureLike, i as verifyObject, m as verifyJsonLd, n as hasProofLike, o as normalizeOutgoingActivityJsonLd, p as signJsonLd, r as signObject, s as doesActorOwnKey } from "./proof-CO1qAbN8.js";
-import { n as getNodeInfo, t as nodeInfoToJson } from "./types-hvL8ElAs.js";
-import { n as getAuthenticatedDocumentLoader, t as kvCache } from "./kv-cache-D5vjOi5y.js";
+import { URLPattern } from "urlpattern-polyfill";
+import { t as __exportAll } from "./chunk-CRNNMoPX.js";
+import { r as getDefaultActivityTransformers } from "./transformers-BGMIq1cs.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-O8MYWwk8.js";
+import { c as getKeyOwner, d as detachSignature, f as hasSignatureLike, i as verifyObject, m as verifyJsonLd, n as hasProofLike, o as normalizeOutgoingActivityJsonLd, p as signJsonLd, r as signObject, s as doesActorOwnKey } from "./proof-5kT7OUPV.js";
+import { n as getNodeInfo, t as nodeInfoToJson } from "./types-CAY3OdLq.js";
+import { n as getAuthenticatedDocumentLoader, t as kvCache } from "./kv-cache-C3NWWiTg.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, metrics, propagation, trace } from "@opentelemetry/api";
@@ -788,6 +788,12 @@ var FederationMetrics = class {
 	inboxProcessingDuration;
 	httpServerRequestCount;
 	httpServerRequestDuration;
+	queueTaskEnqueued;
+	queueTaskStarted;
+	queueTaskCompleted;
+	queueTaskFailed;
+	queueTaskDuration;
+	queueTaskInFlight;
 	constructor(meterProvider) {
 		const meter = meterProvider.getMeter(name, version);
 		this.deliverySent = meter.createCounter("activitypub.delivery.sent", {
@@ -834,6 +840,46 @@ var FederationMetrics = class {
 				1e4
 			] }
 		});
+		this.queueTaskEnqueued = meter.createCounter("fedify.queue.task.enqueued", {
+			description: "Tasks Fedify enqueued for inbox, outbox, or fanout work.",
+			unit: "{task}"
+		});
+		this.queueTaskStarted = meter.createCounter("fedify.queue.task.started", {
+			description: "Tasks Fedify began processing as a queue worker.",
+			unit: "{task}"
+		});
+		this.queueTaskCompleted = meter.createCounter("fedify.queue.task.completed", {
+			description: "Queue tasks Fedify finished processing without throwing.",
+			unit: "{task}"
+		});
+		this.queueTaskFailed = meter.createCounter("fedify.queue.task.failed", {
+			description: "Queue tasks Fedify abandoned because processing threw.",
+			unit: "{task}"
+		});
+		this.queueTaskDuration = meter.createHistogram("fedify.queue.task.duration", {
+			description: "Duration of queue task processing in Fedify workers.",
+			unit: "ms",
+			advice: { explicitBucketBoundaries: [
+				5,
+				10,
+				25,
+				50,
+				75,
+				100,
+				250,
+				500,
+				750,
+				1e3,
+				2500,
+				5e3,
+				7500,
+				1e4
+			] }
+		});
+		this.queueTaskInFlight = meter.createUpDownCounter("fedify.queue.task.in_flight", {
+			description: "Queue tasks currently being processed in this Fedify process.",
+			unit: "{task}"
+		});
 	}
 	recordDelivery(inbox, durationMs, success, activityType) {
 		const deliveryAttributes = {
@@ -868,7 +914,85 @@ var FederationMetrics = class {
 		this.httpServerRequestCount.add(1, attributes);
 		this.httpServerRequestDuration.record(durationMs, attributes);
 	}
+	recordQueueTaskEnqueued(common, attempt) {
+		const attributes = buildQueueTaskAttributes(common);
+		attributes["fedify.queue.task.attempt"] = attempt;
+		this.queueTaskEnqueued.add(1, attributes);
+	}
+	recordQueueTaskStarted(common) {
+		this.queueTaskStarted.add(1, buildQueueTaskAttributes(common));
+	}
+	incrementQueueTaskInFlight(common) {
+		this.queueTaskInFlight.add(1, buildQueueTaskInFlightAttributes(common));
+	}
+	decrementQueueTaskInFlight(common) {
+		this.queueTaskInFlight.add(-1, buildQueueTaskInFlightAttributes(common));
+	}
+	recordQueueTaskOutcome(common, result, durationMs) {
+		const attributes = buildQueueTaskAttributes(common);
+		attributes["fedify.queue.task.result"] = result;
+		if (result === "completed") this.queueTaskCompleted.add(1, attributes);
+		else if (result === "failed") this.queueTaskFailed.add(1, attributes);
+		this.queueTaskDuration.record(durationMs, attributes);
+	}
 };
+function buildQueueTaskAttributes(common) {
+	const attributes = { "fedify.queue.role": common.role };
+	const backend = getQueueBackend(common.queue);
+	if (backend != null) attributes["fedify.queue.backend"] = backend;
+	const nativeRetrial = common.queue?.nativeRetrial;
+	if (typeof nativeRetrial === "boolean") attributes["fedify.queue.native_retrial"] = nativeRetrial;
+	if (common.activityType != null) attributes["activitypub.activity.type"] = common.activityType;
+	return attributes;
+}
+function buildQueueTaskInFlightAttributes(common) {
+	return buildQueueTaskAttributes({
+		role: common.role,
+		queue: common.queue
+	});
+}
+/**
+* Returns the constructor name of the given message queue, when it is a
+* meaningful identifier.  Used as a best-effort `fedify.queue.backend`
+* attribute on queue task metrics; returns `undefined` for plain object
+* literals (whose constructor is `Object`) so the attribute does not appear
+* with a non-informative value.
+* @since 2.3.0
+*/
+function getQueueBackend(queue) {
+	const name = queue?.constructor?.name;
+	if (name == null || name === "" || name === "Object") return void 0;
+	return name;
+}
+/**
+* Records `fedify.queue.task.enqueued` for an outgoing outbox enqueue.
+*
+* Both `Context.sendActivity()` and `OutboxContext.forwardActivity()` enqueue
+* outbox messages with the same metric attributes (role, queue, activity
+* type, attempt), so they share this helper rather than each defining a local
+* closure.
+* @since 2.3.0
+*/
+function recordOutboxEnqueue(meterProvider, outboxQueue, message) {
+	getFederationMetrics(meterProvider).recordQueueTaskEnqueued({
+		role: "outbox",
+		queue: outboxQueue,
+		activityType: message.activityType
+	}, message.attempt);
+}
+/**
+* Whether the given thrown value is an `AbortError`.
+*
+* `processQueuedTask` distinguishes aborted tasks (recorded as
+* `fedify.queue.task.result=aborted`) from other failures so that backend
+* shutdown signals do not inflate the `fedify.queue.task.failed` counter.
+* @since 2.3.0
+*/
+function isAbortError(error) {
+	if (error == null || typeof error !== "object") return false;
+	const name = error.name;
+	return typeof name === "string" && name === "AbortError";
+}
 const KNOWN_HTTP_METHODS = new Set([
 	"CONNECT",
 	"DELETE",
@@ -990,6 +1114,11 @@ async function routeActivity({ context: ctx, json, activity, recipient, inboxLis
 			});
 			throw error;
 		}
+		getFederationMetrics(meterProvider).recordQueueTaskEnqueued({
+			role: "inbox",
+			queue,
+			activityType: getTypeId(activity).href
+		}, 0);
 		logger.info("Activity {activityId} is enqueued.", {
 			activityId: activity.id?.href,
 			activity: json,
@@ -3104,78 +3233,123 @@ var FederationImpl = class extends FederationBuilderImpl {
 	processQueuedTask(contextData, message) {
 		const tracer = this._getTracer();
 		const extractedContext = propagation.extract(context.active(), message.traceContext);
+		const meter = getFederationMetrics(this.meterProvider);
 		return withContext({ messageId: message.id }, async () => {
-			if (message.type === "fanout") await tracer.startActiveSpan("activitypub.fanout", {
-				kind: SpanKind.CONSUMER,
-				attributes: { "activitypub.activity.type": message.activityType }
-			}, extractedContext, async (span) => {
-				const spanCtx = span.spanContext();
-				return await withContext({
-					traceId: spanCtx.traceId,
-					spanId: spanCtx.spanId
-				}, async () => {
-					if (message.activityId != null) span.setAttribute("activitypub.activity.id", message.activityId);
-					try {
-						await this.#listenFanoutMessage(contextData, message);
-					} catch (e) {
-						span.setStatus({
-							code: SpanStatusCode.ERROR,
-							message: String(e)
-						});
-						throw e;
-					} finally {
-						span.end();
-					}
+			if (message.type === "fanout") {
+				const common = {
+					role: "fanout",
+					queue: this.fanoutQueue,
+					activityType: message.activityType
+				};
+				await tracer.startActiveSpan("activitypub.fanout", {
+					kind: SpanKind.CONSUMER,
+					attributes: { "activitypub.activity.type": message.activityType }
+				}, extractedContext, async (span) => {
+					const spanCtx = span.spanContext();
+					return await withContext({
+						traceId: spanCtx.traceId,
+						spanId: spanCtx.spanId
+					}, async () => {
+						if (message.activityId != null) span.setAttribute("activitypub.activity.id", message.activityId);
+						meter.recordQueueTaskStarted(common);
+						meter.incrementQueueTaskInFlight(common);
+						const startedAt = performance.now();
+						let outcome = "completed";
+						try {
+							await this.#listenFanoutMessage(contextData, message);
+						} catch (e) {
+							const aborted = isAbortError(e);
+							outcome = aborted ? "aborted" : "failed";
+							if (!aborted) span.setStatus({
+								code: SpanStatusCode.ERROR,
+								message: String(e)
+							});
+							throw e;
+						} finally {
+							meter.recordQueueTaskOutcome(common, outcome, getDurationMs(startedAt));
+							meter.decrementQueueTaskInFlight(common);
+							span.end();
+						}
+					});
 				});
-			});
-			else if (message.type === "outbox") await tracer.startActiveSpan("activitypub.outbox", {
-				kind: SpanKind.CONSUMER,
-				attributes: {
-					"activitypub.activity.type": message.activityType,
-					"activitypub.activity.retries": message.attempt
-				}
-			}, extractedContext, async (span) => {
-				const spanCtx = span.spanContext();
-				return await withContext({
-					traceId: spanCtx.traceId,
-					spanId: spanCtx.spanId
-				}, async () => {
-					if (message.activityId != null) span.setAttribute("activitypub.activity.id", message.activityId);
-					try {
-						await this.#listenOutboxMessage(contextData, message, span);
-					} catch (e) {
-						span.setStatus({
-							code: SpanStatusCode.ERROR,
-							message: String(e)
-						});
-						throw e;
-					} finally {
-						span.end();
+			} else if (message.type === "outbox") {
+				const common = {
+					role: "outbox",
+					queue: this.outboxQueue,
+					activityType: message.activityType
+				};
+				await tracer.startActiveSpan("activitypub.outbox", {
+					kind: SpanKind.CONSUMER,
+					attributes: {
+						"activitypub.activity.type": message.activityType,
+						"activitypub.activity.retries": message.attempt
 					}
+				}, extractedContext, async (span) => {
+					const spanCtx = span.spanContext();
+					return await withContext({
+						traceId: spanCtx.traceId,
+						spanId: spanCtx.spanId
+					}, async () => {
+						if (message.activityId != null) span.setAttribute("activitypub.activity.id", message.activityId);
+						meter.recordQueueTaskStarted(common);
+						meter.incrementQueueTaskInFlight(common);
+						const startedAt = performance.now();
+						let outcome = "completed";
+						try {
+							await this.#listenOutboxMessage(contextData, message, span);
+						} catch (e) {
+							const aborted = isAbortError(e);
+							outcome = aborted ? "aborted" : "failed";
+							if (!aborted) span.setStatus({
+								code: SpanStatusCode.ERROR,
+								message: String(e)
+							});
+							throw e;
+						} finally {
+							meter.recordQueueTaskOutcome(common, outcome, getDurationMs(startedAt));
+							meter.decrementQueueTaskInFlight(common);
+							span.end();
+						}
+					});
 				});
-			});
-			else if (message.type === "inbox") await tracer.startActiveSpan("activitypub.inbox", {
-				kind: SpanKind.CONSUMER,
-				attributes: { "activitypub.shared_inbox": message.identifier == null }
-			}, extractedContext, async (span) => {
-				const spanCtx = span.spanContext();
-				return await withContext({
-					traceId: spanCtx.traceId,
-					spanId: spanCtx.spanId
-				}, async () => {
-					try {
-						await this.#listenInboxMessage(contextData, message, span);
-					} catch (e) {
-						span.setStatus({
-							code: SpanStatusCode.ERROR,
-							message: String(e)
-						});
-						throw e;
-					} finally {
-						span.end();
-					}
+			} else if (message.type === "inbox") {
+				const common = {
+					role: "inbox",
+					queue: this.inboxQueue
+				};
+				await tracer.startActiveSpan("activitypub.inbox", {
+					kind: SpanKind.CONSUMER,
+					attributes: { "activitypub.shared_inbox": message.identifier == null }
+				}, extractedContext, async (span) => {
+					const spanCtx = span.spanContext();
+					return await withContext({
+						traceId: spanCtx.traceId,
+						spanId: spanCtx.spanId
+					}, async () => {
+						meter.recordQueueTaskStarted(common);
+						meter.incrementQueueTaskInFlight(common);
+						const startedAt = performance.now();
+						let outcome = "completed";
+						try {
+							await this.#listenInboxMessage(contextData, message, span, (activityType) => {
+								common.activityType = activityType;
+							});
+						} catch (e) {
+							const aborted = isAbortError(e);
+							outcome = aborted ? "aborted" : "failed";
+							if (!aborted) span.setStatus({
+								code: SpanStatusCode.ERROR,
+								message: String(e)
+							});
+							throw e;
+						} finally {
+							meter.recordQueueTaskOutcome(common, outcome, getDurationMs(startedAt));
+							meter.decrementQueueTaskInFlight(common);
+							span.end();
+						}
+					});
 				});
-			});
+			}
 		});
 	}
 	async #listenFanoutMessage(data, message) {
@@ -3332,10 +3506,19 @@ var FederationImpl = class extends FederationBuilderImpl {
 					...logData,
 					error
 				});
-				await this.outboxQueue?.enqueue({
+				const retryMessage = {
 					...message,
 					attempt: message.attempt + 1
-				}, { delay: Temporal.Duration.compare(delay, { seconds: 0 }) < 0 ? Temporal.Duration.from({ seconds: 0 }) : delay });
+				};
+				const { outboxQueue } = this;
+				if (outboxQueue != null) {
+					await outboxQueue.enqueue(retryMessage, { delay: Temporal.Duration.compare(delay, { seconds: 0 }) < 0 ? Temporal.Duration.from({ seconds: 0 }) : delay });
+					getFederationMetrics(this.meterProvider).recordQueueTaskEnqueued({
+						role: "outbox",
+						queue: outboxQueue,
+						activityType: retryMessage.activityType
+					}, retryMessage.attempt);
+				}
 			} else logger.error("Failed to send activity {activityId} to {inbox} after {attempt} attempts; giving up:\n{error}", {
 				...logData,
 				error
@@ -3344,7 +3527,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 		}
 		logger.info("Successfully sent activity {activityId} to {inbox}.", { ...logData });
 	}
-	async #listenInboxMessage(ctxData, message, span) {
+	async #listenInboxMessage(ctxData, message, span, onActivityType) {
 		const logger = getLogger([
 			"fedify",
 			"federation",
@@ -3358,7 +3541,9 @@ var FederationImpl = class extends FederationBuilderImpl {
 			if (identity != null) context = this.#createContext(baseUrl, ctxData, { documentLoader: "identifier" in identity || "username" in identity ? await context.getDocumentLoader(identity) : context.getDocumentLoader(identity) });
 		}
 		const activity = await Activity.fromJsonLd(message.activity, context);
-		span.setAttribute("activitypub.activity.type", getTypeId(activity).href);
+		const activityType = getTypeId(activity).href;
+		span.setAttribute("activitypub.activity.type", activityType);
+		onActivityType?.(activityType);
 		if (activity.id != null) span.setAttribute("activitypub.activity.id", activity.id.href);
 		const cacheKey = activity.id == null ? null : [
 			...this.kvPrefixes.activityIdempotence,
@@ -3386,7 +3571,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 				});
 				span.setStatus({
 					code: SpanStatusCode.ERROR,
-					message: `Unsupported activity type: ${getTypeId(activity).href}`
+					message: `Unsupported activity type: ${activityType}`
 				});
 				span.end();
 				return;
@@ -3394,7 +3579,6 @@ var FederationImpl = class extends FederationBuilderImpl {
 			const { class: cls, listener } = dispatched;
 			span.updateName(`activitypub.dispatch_inbox_listener ${cls.name}`);
 			try {
-				const activityType = getTypeId(activity).href;
 				const started = performance.now();
 				try {
 					await listener(context.toInboxContext(message.identifier, message.activity, activity.id?.href, activityType), activity);
@@ -3439,10 +3623,19 @@ var FederationImpl = class extends FederationBuilderImpl {
 						activity: message.activity,
 						recipient: message.identifier
 					});
-					await this.inboxQueue?.enqueue({
+					const retryMessage = {
 						...message,
 						attempt: message.attempt + 1
-					}, { delay: Temporal.Duration.compare(delay, { seconds: 0 }) < 0 ? Temporal.Duration.from({ seconds: 0 }) : delay });
+					};
+					const { inboxQueue } = this;
+					if (inboxQueue != null) {
+						await inboxQueue.enqueue(retryMessage, { delay: Temporal.Duration.compare(delay, { seconds: 0 }) < 0 ? Temporal.Duration.from({ seconds: 0 }) : delay });
+						getFederationMetrics(this.meterProvider).recordQueueTaskEnqueued({
+							role: "inbox",
+							queue: inboxQueue,
+							activityType
+						}, retryMessage.attempt);
+					}
 				} else logger.error("Failed to process the incoming activity {activityId} after {trial} attempts; giving up:\n{error}", {
 					error,
 					activityId: activity.id?.href,
@@ -3631,9 +3824,11 @@ var FederationImpl = class extends FederationBuilderImpl {
 			});
 		}
 		const { outboxQueue } = this;
-		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 (outboxQueue.enqueueMany == null || orderingKey != null) {
+			const errors = (await Promise.allSettled(messages.map(async (m) => {
+				await outboxQueue.enqueue(m.message, { orderingKey: m.orderingKey });
+				recordOutboxEnqueue(this.meterProvider, outboxQueue, m.message);
+			}))).filter((r) => r.status === "rejected").map((r) => r.reason);
 			if (errors.length > 0) {
 				logger.error("Failed to enqueue activity {activityId} to send later: {errors}", {
 					activityId: activity.id.href,
@@ -3642,25 +3837,17 @@ var FederationImpl = class extends FederationBuilderImpl {
 				if (errors.length > 1) throw new AggregateError(errors, `Failed to enqueue activity ${activityId} to send 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 send later: {errors}", {
+		} else {
+			try {
+				await outboxQueue.enqueueMany(messages.map((m) => m.message));
+			} catch (error) {
+				logger.error("Failed to enqueue activity {activityId} to send later: {error}", {
 					activityId: activity.id.href,
-					errors
+					error
 				});
-				if (errors.length > 1) throw new AggregateError(errors, `Failed to enqueue activity ${activityId} to send later.`);
-				throw errors[0];
+				throw error;
 			}
-		} else try {
-			await outboxQueue.enqueueMany(messages.map((m) => m.message));
-		} catch (error) {
-			logger.error("Failed to enqueue activity {activityId} to send later: {error}", {
-				activityId: activity.id.href,
-				error
-			});
-			throw error;
+			for (const m of messages) recordOutboxEnqueue(this.meterProvider, outboxQueue, m.message);
 		}
 	}
 	fetch(request, options) {
@@ -4476,6 +4663,11 @@ var ContextImpl = class ContextImpl {
 		};
 		if (!this.federation.manuallyStartQueue) this.federation._startQueueInternal(this.data);
 		await this.federation.fanoutQueue.enqueue(message, { orderingKey: options.orderingKey });
+		getFederationMetrics(this.federation.meterProvider).recordQueueTaskEnqueued({
+			role: "fanout",
+			queue: this.federation.fanoutQueue,
+			activityType: message.activityType
+		}, 0);
 		return true;
 	}
 	async *getFollowers(identifier) {
@@ -4606,6 +4798,7 @@ var ContextImpl = class ContextImpl {
 			kvPrefixes: this.federation.kvPrefixes,
 			queue: this.federation.inboxQueue,
 			span,
+			meterProvider: this.federation.meterProvider,
 			tracerProvider: options.tracerProvider ?? this.tracerProvider,
 			idempotencyStrategy: this.federation.idempotencyStrategy
 		});
@@ -4855,8 +5048,10 @@ async function forwardActivityInternal(ctx, loggerCategory, forwarder, recipient
 	}
 	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);
+		const errors = (await Promise.allSettled(messages.map(async (m) => {
+			await outboxQueue.enqueue(m.message, { orderingKey: m.orderingKey });
+			recordOutboxEnqueue(ctx.federation.meterProvider, outboxQueue, m.message);
+		}))).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,
@@ -4865,14 +5060,17 @@ async function forwardActivityInternal(ctx, loggerCategory, forwarder, recipient
 			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;
+	} 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;
+		}
+		for (const m of messages) recordOutboxEnqueue(ctx.federation.meterProvider, outboxQueue, m.message);
 	}
 	return true;
 }

package/dist/{middleware-CpCSD43m.mjs → middleware-D6FbOjuK.mjs}

@@ -1,5 +1,5 @@
 import "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as FederationImpl } from "./middleware-CTdNwf_s.mjs";
+import { n as FederationImpl } from "./middleware-DA2WTBr4.mjs";
 export { FederationImpl };