@fedify/fedify 2.4.0-dev.1634 → 2.4.0-pr.934.40

package/dist/{middleware-BPHpdYl4.cjs → middleware-BW7WQltk.cjs}

@@ -1,11 +1,11 @@
 const { URLPattern } = require("urlpattern-polyfill");
 const require_chunk = require("./chunk-Czpeue4M.cjs");
 const require_transformers = require("./transformers-DGwl-hD1.cjs");
-const require_http = require("./http-DiMJDFtd.cjs");
+const require_http = require("./http-jr0TkgZe.cjs");
 const require_temporal_polyfill = require("./temporal-polyfill-BCdTHexd.cjs");
-const require_proof = require("./proof-BI4Wn6Ur.cjs");
+const require_proof = require("./proof-NY0D8Oux.cjs");
 const require_types = require("./types-CPym83zc.cjs");
-const require_kv_cache = require("./kv-cache-BInLi0Ro.cjs");
+const require_kv_cache = require("./kv-cache-D-hbjJAD.cjs");
 let _logtape_logtape = require("@logtape/logtape");
 let _fedify_uri_template = require("@fedify/uri-template");
 let _fedify_vocab = require("@fedify/vocab");
@@ -723,7 +723,7 @@ function createFederationBuilder() {
 }
 //#endregion
 //#region src/federation/circuit-breaker.ts
-const Temporal$8 = require_temporal_polyfill.Temporal;
+const Temporal$7 = require_temporal_polyfill.Temporal;
 const MAX_CUSTOM_FAILURE_HISTORY = 100;
 /**
 * Tracks reachability state for remote outbox delivery hosts.
@@ -739,7 +739,7 @@ var CircuitBreaker = class {
 		this.#kv = options.kv;
 		this.#prefix = options.prefix;
 		this.#options = normalizeCircuitBreakerOptions(options.options ?? {});
-		this.#now = options.now ?? (() => Temporal$8.Now.instant());
+		this.#now = options.now ?? (() => Temporal$7.Now.instant());
 		this.#stateChangeObserver = options.stateChangeObserver;
 	}
 	get options() {
@@ -752,7 +752,7 @@ var CircuitBreaker = class {
 	async beforeSend(remoteHost, message) {
 		const heldSince = parseHeldSince(message.circuitHeldSince);
 		const now = this.#now();
-		if (heldSince != null && Temporal$8.Instant.compare(heldSince.add(this.#options.heldActivityTtl), now) <= 0) return {
+		if (heldSince != null && Temporal$7.Instant.compare(heldSince.add(this.#options.heldActivityTtl), now) <= 0) return {
 			type: "drop",
 			heldSince
 		};
@@ -764,12 +764,12 @@ var CircuitBreaker = class {
 				probe: false
 			};
 			if (oldState.state === "half-open") {
-				const halfOpened = oldState.halfOpened == null ? void 0 : Temporal$8.Instant.from(oldState.halfOpened);
+				const halfOpened = oldState.halfOpened == null ? void 0 : Temporal$7.Instant.from(oldState.halfOpened);
 				if (halfOpened != null) {
 					const staleAt = halfOpened.add(this.#options.recoveryDelay);
-					if (Temporal$8.Instant.compare(now, staleAt) < 0) {
+					if (Temporal$7.Instant.compare(now, staleAt) < 0) {
 						const releaseAt = now.add(this.#options.releaseInterval);
-						const retryAt = Temporal$8.Instant.compare(releaseAt, staleAt) < 0 ? releaseAt : staleAt;
+						const retryAt = Temporal$7.Instant.compare(releaseAt, staleAt) < 0 ? releaseAt : staleAt;
 						const cappedRetryAt = this.#capHeldRetryAt(now, heldSince, retryAt);
 						return {
 							type: "hold",
@@ -791,8 +791,8 @@ var CircuitBreaker = class {
 				lastConflictingState = "half-open";
 				continue;
 			}
-			const probeAt = (oldState.opened == null ? now : Temporal$8.Instant.from(oldState.opened)).add(this.#options.recoveryDelay);
-			if (Temporal$8.Instant.compare(now, probeAt) < 0) {
+			const probeAt = (oldState.opened == null ? now : Temporal$7.Instant.from(oldState.opened)).add(this.#options.recoveryDelay);
+			if (Temporal$7.Instant.compare(now, probeAt) < 0) {
 				const retryAt = this.#capHeldRetryAt(now, heldSince, probeAt);
 				return {
 					type: "hold",
@@ -855,7 +855,7 @@ var CircuitBreaker = class {
 		for (let attempt = 0; attempt < 10; attempt++) {
 			const oldState = await this.#get(remoteHost);
 			if (oldState?.state === "open") return void 0;
-			const oldFailures = oldState?.failures.map(Temporal$8.Instant.from) ?? [];
+			const oldFailures = oldState?.failures.map(Temporal$7.Instant.from) ?? [];
 			const failures = this.#options.pruneFailures([...oldFailures, now], now);
 			let newState;
 			let transition;
@@ -905,7 +905,7 @@ var CircuitBreaker = class {
 	}
 	#capHeldRetryAt(now, heldSince, retryAt) {
 		const expiresAt = (heldSince ?? now).add(this.#options.heldActivityTtl);
-		return Temporal$8.Instant.compare(expiresAt, retryAt) < 0 ? expiresAt : retryAt;
+		return Temporal$7.Instant.compare(expiresAt, retryAt) < 0 ? expiresAt : retryAt;
 	}
 	async #get(remoteHost) {
 		return parseCircuitBreakerKvState(await this.#kv.get(this.#key(remoteHost)));
@@ -976,13 +976,13 @@ function normalizeCircuitBreakerOptions(options) {
 		assertPositiveDuration(failureWindow, "failureWindow");
 		pruneFailures = (timestamps, now) => {
 			const earliest = now.subtract(failureWindow);
-			return timestamps.filter((timestamp) => Temporal$8.Instant.compare(timestamp, earliest) >= 0).slice(-failureThreshold);
+			return timestamps.filter((timestamp) => Temporal$7.Instant.compare(timestamp, earliest) >= 0).slice(-failureThreshold);
 		};
 		failure = (timestamps) => {
 			if (timestamps.length < failureThreshold) return false;
 			const first = timestamps[timestamps.length - failureThreshold];
 			const last = timestamps[timestamps.length - 1];
-			return Temporal$8.Duration.compare(first.until(last), failureWindow) <= 0;
+			return Temporal$7.Duration.compare(first.until(last), failureWindow) <= 0;
 		};
 	} else {
 		failure = options.failure;
@@ -999,19 +999,19 @@ function normalizeCircuitBreakerOptions(options) {
 	};
 }
 function toInstantDuration(duration) {
-	const parsed = Temporal$8.Duration.from(duration);
-	return Temporal$8.Duration.from({ milliseconds: Math.trunc(parsed.total({
+	const parsed = Temporal$7.Duration.from(duration);
+	return Temporal$7.Duration.from({ milliseconds: Math.trunc(parsed.total({
 		unit: "millisecond",
-		relativeTo: Temporal$8.PlainDateTime.from("2026-01-01T00:00:00")
+		relativeTo: Temporal$7.PlainDateTime.from("2026-01-01T00:00:00")
 	})) });
 }
 function assertPositiveDuration(duration, name) {
-	if (Temporal$8.Duration.compare(duration, { seconds: 0 }) <= 0) throw new RangeError(`${name} must be a positive duration.`);
+	if (Temporal$7.Duration.compare(duration, { seconds: 0 }) <= 0) throw new RangeError(`${name} must be a positive duration.`);
 }
 function parseHeldSince(value) {
 	if (value == null) return void 0;
 	try {
-		return Temporal$8.Instant.from(value);
+		return Temporal$7.Instant.from(value);
 	} catch (error) {
 		(0, _logtape_logtape.getLogger)([
 			"fedify",
@@ -1035,7 +1035,7 @@ function parseCircuitBreakerKvState(value) {
 	const isInstantString = (v) => {
 		if (typeof v !== "string") return false;
 		try {
-			Temporal$8.Instant.from(v);
+			Temporal$7.Instant.from(v);
 			return true;
 		} catch {
 			return false;
@@ -1095,7 +1095,7 @@ async function buildCollectionSynchronizationHeader(collectionId, actorIds) {
 }
 //#endregion
 //#region src/federation/inbox.ts
-const Temporal$7 = require_temporal_polyfill.Temporal;
+const Temporal$6 = require_temporal_polyfill.Temporal;
 async function routeActivity({ context: ctx, json, originalJson, normalizedActivity, ldSignatureVerified, activity, recipient, inboxListeners, inboxContextFactory, listenerInboxContextFactory, inboxErrorHandler, kv, kvPrefixes, queue, span, meterProvider, tracerProvider, idempotencyStrategy }) {
 	const logger = (0, _logtape_logtape.getLogger)([
 		"fedify",
@@ -1242,7 +1242,7 @@ async function routeActivity({ context: ctx, json, originalJson, normalizedActiv
 			return "error";
 		}
 		require_http.recordInboxActivity(meterProvider, "processed", (0, _fedify_vocab.getTypeId)(activity).href);
-		if (cacheKey != null) await kv.set(cacheKey, true, { ttl: Temporal$7.Duration.from({ days: 1 }) });
+		if (cacheKey != null) await kv.set(cacheKey, true, { ttl: Temporal$6.Duration.from({ days: 1 }) });
 		logger.info("Activity {activityId} has been processed.", {
 			activityId: activity.id?.href,
 			activity: json,
@@ -1254,7 +1254,7 @@ async function routeActivity({ context: ctx, json, originalJson, normalizedActiv
 }
 //#endregion
 //#region src/federation/keycache.ts
-const Temporal$6 = require_temporal_polyfill.Temporal;
+const Temporal$5 = require_temporal_polyfill.Temporal;
 var KvKeyCache = class {
 	kv;
 	prefix;
@@ -1265,7 +1265,7 @@ var KvKeyCache = class {
 		this.kv = kv;
 		this.prefix = prefix;
 		this.options = options;
-		this.unavailableKeyTtl = options.unavailableKeyTtl ?? Temporal$6.Duration.from({ minutes: 10 });
+		this.unavailableKeyTtl = options.unavailableKeyTtl ?? Temporal$5.Duration.from({ minutes: 10 });
 		this.nullKeys = /* @__PURE__ */ new Map();
 	}
 	#getFetchErrorKey(keyId) {
@@ -1278,13 +1278,13 @@ var KvKeyCache = class {
 	async get(keyId) {
 		const negativeExpiration = this.nullKeys.get(keyId.href);
 		if (negativeExpiration != null) {
-			if (Temporal$6.Now.instant().until(negativeExpiration).sign >= 0) return null;
+			if (Temporal$5.Now.instant().until(negativeExpiration).sign >= 0) return null;
 			this.nullKeys.delete(keyId.href);
 		}
 		const serialized = await this.kv.get([...this.prefix, keyId.href]);
 		if (serialized === void 0) return void 0;
 		if (serialized === null) {
-			this.nullKeys.set(keyId.href, Temporal$6.Now.instant().add(this.unavailableKeyTtl));
+			this.nullKeys.set(keyId.href, Temporal$5.Now.instant().add(this.unavailableKeyTtl));
 			return null;
 		}
 		try {
@@ -1300,7 +1300,7 @@ var KvKeyCache = class {
 	}
 	async set(keyId, key) {
 		if (key == null) {
-			this.nullKeys.set(keyId.href, Temporal$6.Now.instant().add(this.unavailableKeyTtl));
+			this.nullKeys.set(keyId.href, Temporal$5.Now.instant().add(this.unavailableKeyTtl));
 			await this.kv.set([...this.prefix, keyId.href], null, { ttl: this.unavailableKeyTtl });
 			return;
 		}
@@ -1439,7 +1439,7 @@ function acceptsJsonLd(request) {
 }
 //#endregion
 //#region src/federation/temporal.ts
-const Temporal$5 = require_temporal_polyfill.Temporal;
+const Temporal$4 = require_temporal_polyfill.Temporal;
 function isPlainObject$1(value) {
 	return typeof value === "object" && value != null && !Array.isArray(value);
 }
@@ -1449,7 +1449,7 @@ function normalizeDateTimeLiteral(value) {
 function isMalformedDateTimeLiteral(value) {
 	if (typeof value !== "string") return false;
 	try {
-		Temporal$5.Instant.from(normalizeDateTimeLiteral(value));
+		Temporal$4.Instant.from(normalizeDateTimeLiteral(value));
 		return false;
 	} catch {
 		return true;
@@ -1458,7 +1458,7 @@ function isMalformedDateTimeLiteral(value) {
 function isMalformedDurationLiteral(value) {
 	if (typeof value !== "string") return false;
 	try {
-		Temporal$5.Duration.from(value);
+		Temporal$4.Duration.from(value);
 		return false;
 	} catch {
 		return true;
@@ -1529,7 +1529,7 @@ async function hasMalformedKnownTemporalLiteral(value, contextLoader) {
 }
 //#endregion
 //#region src/federation/handler.ts
-const Temporal$4 = require_temporal_polyfill.Temporal;
+const Temporal$3 = require_temporal_polyfill.Temporal;
 const rawInboxContextFactorySymbol = Symbol("fedify.rawInboxContextFactory");
 function isRemoteContextLoadingFailure$1(error) {
 	return error instanceof Error && typeof error.details === "object" && error.details != null && error.details.code === "loading remote context failed";
@@ -3284,7 +3284,7 @@ async function buildAcceptSignatureHeader(policy, kv, noncePrefix) {
 }
 async function setKey(kv, key, policy) {
 	const seconds = policy.nonceTtlSeconds ?? 300;
-	const ttl = Temporal$4.Duration.from({ seconds });
+	const ttl = Temporal$3.Duration.from({ seconds });
 	await kv.set(key, true, { ttl });
 }
 const DEF_COMPONENTS = [
@@ -3759,7 +3759,7 @@ function serializeDataPointType(dataPointType) {
 }
 //#endregion
 //#region src/federation/retry.ts
-const Temporal$3 = require_temporal_polyfill.Temporal;
+const Temporal$2 = require_temporal_polyfill.Temporal;
 /**
 * Creates an exponential backoff retry policy.  The delay between retries
 * starts at the `initialDelay` and is multiplied by the `factor` for each
@@ -3771,8 +3771,8 @@ const Temporal$3 = require_temporal_polyfill.Temporal;
 * @since 0.12.0
 */
 function createExponentialBackoffPolicy(options = {}) {
-	const initialDelay = Temporal$3.Duration.from(options.initialDelay ?? { seconds: 1 });
-	const maxDelay = Temporal$3.Duration.from(options.maxDelay ?? { hours: 12 });
+	const initialDelay = Temporal$2.Duration.from(options.initialDelay ?? { seconds: 1 });
+	const maxDelay = Temporal$2.Duration.from(options.maxDelay ?? { hours: 12 });
 	const maxAttempts = options.maxAttempts ?? 10;
 	const factor = options.factor ?? 2;
 	const jitter = options.jitter ?? true;
@@ -3784,8 +3784,8 @@ function createExponentialBackoffPolicy(options = {}) {
 			milliseconds *= 1 + Math.random();
 			milliseconds = Math.round(milliseconds);
 		}
-		const delay = Temporal$3.Duration.from({ milliseconds });
-		return Temporal$3.Duration.compare(delay, maxDelay) > 0 ? maxDelay : delay;
+		const delay = Temporal$2.Duration.from({ milliseconds });
+		return Temporal$2.Duration.compare(delay, maxDelay) > 0 ? maxDelay : delay;
 	};
 }
 //#endregion
@@ -3907,279 +3907,6 @@ const classReviver = (filter, init, set) => (seen, revive, node) => {
 	})();
 };
 //#endregion
-//#region src/federation/mq.ts
-const Temporal$2 = require_temporal_polyfill.Temporal;
-/**
-* A message queue that processes messages in the same process.
-* Do not use this in production as it does neither persist messages nor
-* distribute them across multiple processes.
-*
-* @since 0.5.0
-*/
-var InProcessMessageQueue = class {
-	#messages;
-	#monitors;
-	#pollIntervalMs;
-	#delayedMessages;
-	/**
-	* Tracks which ordering keys are currently being processed to ensure
-	* sequential processing for messages with the same key.
-	*/
-	#processingKeys;
-	/**
-	* In-process message queue does not provide native retry mechanisms.
-	* @since 1.7.0
-	*/
-	nativeRetrial = false;
-	/**
-	* In-process message queue does not deduplicate messages natively.
-	* @since 2.4.0
-	*/
-	nativeDeduplication = false;
-	/**
-	* Constructs a new {@link InProcessMessageQueue} with the given options.
-	* @param options Additional options for the in-process message queue.
-	*/
-	constructor(options = {}) {
-		this.#messages = [];
-		this.#monitors = {};
-		this.#pollIntervalMs = Temporal$2.Duration.from(options.pollInterval ?? { seconds: 5 }).total("millisecond");
-		this.#delayedMessages = 0;
-		this.#processingKeys = /* @__PURE__ */ new Set();
-	}
-	enqueue(message, options) {
-		const delay = options?.delay == null ? 0 : Math.max(options.delay.total("millisecond"), 0);
-		if (delay > 0) {
-			this.#delayedMessages++;
-			setTimeout(() => {
-				this.#delayedMessages--;
-				this.#enqueueReady(message, options);
-			}, delay);
-			return Promise.resolve();
-		}
-		this.#enqueueReady(message, options);
-		return Promise.resolve();
-	}
-	#enqueueReady(message, options) {
-		const orderingKey = options?.orderingKey ?? null;
-		this.#messages.push({
-			message,
-			orderingKey
-		});
-		this.#notifyMonitors();
-	}
-	#notifyMonitors() {
-		for (const monitorId in this.#monitors) this.#monitors[monitorId]();
-	}
-	enqueueMany(messages, options) {
-		if (messages.length === 0) return Promise.resolve();
-		const delay = options?.delay == null ? 0 : Math.max(options.delay.total("millisecond"), 0);
-		if (delay > 0) {
-			const delayedCount = messages.length;
-			const deferredMessages = [...messages];
-			this.#delayedMessages += delayedCount;
-			setTimeout(() => {
-				this.#delayedMessages -= delayedCount;
-				this.#enqueueManyReady(deferredMessages, options);
-			}, delay);
-			return Promise.resolve();
-		}
-		this.#enqueueManyReady(messages, options);
-		return Promise.resolve();
-	}
-	#enqueueManyReady(messages, options) {
-		const orderingKey = options?.orderingKey ?? null;
-		for (const message of messages) this.#messages.push({
-			message,
-			orderingKey
-		});
-		this.#notifyMonitors();
-	}
-	async listen(handler, options = {}) {
-		const signal = options.signal;
-		while (signal == null || !signal.aborted) {
-			const idx = this.#messages.findIndex((m) => m.orderingKey == null || !this.#processingKeys.has(m.orderingKey));
-			if (idx >= 0) {
-				const { message, orderingKey } = this.#messages.splice(idx, 1)[0];
-				if (orderingKey != null) this.#processingKeys.add(orderingKey);
-				try {
-					await handler(message);
-				} finally {
-					if (orderingKey != null) this.#processingKeys.delete(orderingKey);
-				}
-			} else if (this.#messages.length === 0) await this.#wait(this.#pollIntervalMs, signal);
-			else await this.#wait(10, signal);
-		}
-	}
-	getDepth() {
-		const ready = this.#messages.length;
-		const delayed = this.#delayedMessages;
-		return Promise.resolve({
-			queued: ready + delayed,
-			ready,
-			delayed
-		});
-	}
-	#wait(ms, signal) {
-		let timer = null;
-		return Promise.any([new Promise((resolve) => {
-			signal?.addEventListener("abort", () => {
-				if (timer != null) clearTimeout(timer);
-				resolve();
-			}, { once: true });
-			const monitorId = crypto.randomUUID();
-			this.#monitors[monitorId] = () => {
-				delete this.#monitors[monitorId];
-				if (timer != null) clearTimeout(timer);
-				resolve();
-			};
-		}), new Promise((resolve) => timer = setTimeout(resolve, ms))]);
-	}
-};
-/**
-* A message queue that processes messages in parallel.  It takes another
-* {@link MessageQueue}, and processes messages in parallel up to a certain
-* number of workers.
-*
-* Actually, it's rather a decorator than a queue itself.
-*
-* Note that the workers do not run in truly parallel, in the sense that they
-* are not running in separate threads or processes.  They are running in the
-* same process, but are scheduled to run in parallel.  Hence, this is useful
-* for I/O-bound tasks, but not for CPU-bound tasks, which is okay for Fedify's
-* workloads.
-*
-* When using `ParallelMessageQueue`, the ordering guarantee is preserved
-* *only if* the underlying queue implementation delivers messages in a wrapper
-* format that includes the `__fedify_ordering_key__` property.  Currently,
-* only `DenoKvMessageQueue` and `WorkersMessageQueue` use this format.
-* For other queue implementations (e.g., `InProcessMessageQueue`,
-* `RedisMessageQueue`, `PostgresMessageQueue`, `SqliteMessageQueue`,
-* `AmqpMessageQueue`), the ordering key cannot be detected by
-* `ParallelMessageQueue`, so ordering guarantees are handled by those
-* implementations directly rather than at the `ParallelMessageQueue` level.
-*
-* Messages with the same ordering key will never be processed concurrently
-* by different workers, ensuring sequential processing within each key.
-* Messages with different ordering keys (or no ordering key) can still be
-* processed in parallel.
-*
-* @since 1.0.0
-*/
-var ParallelMessageQueue = class ParallelMessageQueue {
-	queue;
-	workers;
-	/**
-	* Inherits the native retry capability from the wrapped queue.
-	* @since 1.7.0
-	*/
-	nativeRetrial;
-	/**
-	* Inherits the native deduplication capability from the wrapped queue.
-	* @since 2.4.0
-	*/
-	nativeDeduplication;
-	getDepth;
-	/**
-	* Tracks which ordering keys are currently being processed to ensure
-	* sequential processing for messages with the same key.
-	*/
-	#processingKeys = /* @__PURE__ */ new Set();
-	/**
-	* Pending messages waiting for their ordering key to become available.
-	*/
-	#pendingMessages = [];
-	/**
-	* Constructs a new {@link ParallelMessageQueue} with the given queue and
-	* number of workers.
-	* @param queue The message queue to use under the hood.  Note that
-	*              {@link ParallelMessageQueue} cannot be nested.
-	* @param workers The number of workers to process messages in parallel.
-	* @throws {TypeError} If the given queue is an instance of
-	*                     {@link ParallelMessageQueue}.
-	*/
-	constructor(queue, workers) {
-		if (queue instanceof ParallelMessageQueue) throw new TypeError("Cannot nest ParallelMessageQueue.");
-		this.queue = queue;
-		this.workers = workers;
-		this.nativeRetrial = queue.nativeRetrial;
-		this.nativeDeduplication = queue.nativeDeduplication;
-		if (queue.getDepth != null) this.getDepth = () => queue.getDepth();
-	}
-	enqueue(message, options) {
-		return this.queue.enqueue(message, options);
-	}
-	async enqueueMany(messages, options) {
-		if (this.queue.enqueueMany == null) {
-			if (messages.length === 1) {
-				await this.queue.enqueue(messages[0], options);
-				return;
-			}
-			if (options?.deduplicationKey != null) throw new TypeError("Cannot enqueue a batch with a deduplicationKey: the wrapped queue does not implement enqueueMany, so ParallelMessageQueue would have to fan out to individual enqueue() calls that cannot share one deduplicationKey atomically.  Wrap a queue that implements enqueueMany instead.");
-			const errors = (await Promise.allSettled(messages.map((message) => this.queue.enqueue(message, options)))).filter((r) => r.status === "rejected").map((r) => r.reason);
-			if (errors.length > 1) throw new AggregateError(errors, "Failed to enqueue messages.");
-			else if (errors.length === 1) throw errors[0];
-			return;
-		}
-		await this.queue.enqueueMany(messages, options);
-	}
-	/**
-	* Extracts ordering key from a message if present.
-	*
-	* This method only works for queue implementations that deliver messages
-	* in the wrapper format with `__fedify_ordering_key__` property.  Currently,
-	* only `DenoKvMessageQueue` and `WorkersMessageQueue` use this format.
-	*
-	* For other queue implementations (`InProcessMessageQueue`,
-	* `RedisMessageQueue`, `PostgresMessageQueue`, `SqliteMessageQueue`,
-	* `AmqpMessageQueue`), messages are delivered as raw payloads without the
-	* wrapper, so the ordering key cannot be detected here.  Those
-	* implementations handle ordering guarantees internally.
-	*/
-	#extractOrderingKey(message) {
-		if (message != null && typeof message === "object") {
-			if ("__fedify_ordering_key__" in message) return message.__fedify_ordering_key__;
-		}
-	}
-	listen(handler, options = {}) {
-		const workers = /* @__PURE__ */ new Map();
-		return this.queue.listen(async (message) => {
-			while (workers.size >= this.workers) {
-				const consumedId = await Promise.any(workers.values());
-				workers.delete(consumedId);
-			}
-			const workerId = crypto.randomUUID();
-			const orderingKey = this.#extractOrderingKey(message);
-			if (orderingKey != null && this.#processingKeys.has(orderingKey)) await new Promise((resolve) => {
-				this.#pendingMessages.push({
-					message,
-					orderingKey,
-					resolve
-				});
-			});
-			if (orderingKey != null) this.#processingKeys.add(orderingKey);
-			const promise = this.#work(workerId, handler, message, orderingKey);
-			workers.set(workerId, promise);
-		}, options);
-	}
-	async #work(workerId, handler, message, orderingKey) {
-		await this.#sleep(0);
-		try {
-			await handler(message);
-		} finally {
-			if (orderingKey != null) {
-				this.#processingKeys.delete(orderingKey);
-				const pendingIdx = this.#pendingMessages.findIndex((p) => p.orderingKey === orderingKey);
-				if (pendingIdx >= 0) this.#pendingMessages.splice(pendingIdx, 1)[0].resolve();
-			}
-		}
-		return workerId;
-	}
-	#sleep(ms) {
-		return new Promise((resolve) => setTimeout(resolve, ms));
-	}
-};
-//#endregion
 //#region src/federation/tasks/enqueue.ts
 /**
 * The enqueue pipeline for custom background tasks.  `ContextImpl.enqueueTask`
@@ -4247,8 +3974,8 @@ function planDeduplication(ctx, queue, taskName, options, itemCount) {
 	const key = options.deduplicationKey;
 	const native = queue.nativeDeduplication === true;
 	const canCas = ctx.federation.kv.cas != null;
-	const canBatchAtomically = queue.enqueueMany != null && !(queue instanceof ParallelMessageQueue && queue.queue.enqueueMany == null);
-	if (itemCount > 1 && !canBatchAtomically && (native || canCas)) throw new TypeError(`Task ${JSON.stringify(taskName)} was enqueued as a batch with a deduplicationKey, but its message queue does not implement enqueueMany; a multi-item batch cannot be deduplicated atomically without it.  Implement enqueueMany on the queue, or enqueue the tasks individually with enqueueTask().`);
+	const canBatchAtomically = queue.enqueueMany != null && queue.atomicEnqueueMany !== false;
+	if (itemCount > 1 && !canBatchAtomically && (native || canCas)) throw new TypeError(`Task ${JSON.stringify(taskName)} was enqueued as a batch with a deduplicationKey, but its message queue does not provide an atomic enqueueMany implementation; a multi-item batch cannot be deduplicated atomically without it.  Use a queue with atomic batch enqueueing, or enqueue the tasks individually with enqueueTask().`);
 	if (native) return {
 		kind: "native",
 		key
@@ -7420,18 +7147,6 @@ Object.defineProperty(exports, "CircuitBreaker", {
 		return CircuitBreaker;
 	}
 });
-Object.defineProperty(exports, "InProcessMessageQueue", {
-	enumerable: true,
-	get: function() {
-		return InProcessMessageQueue;
-	}
-});
-Object.defineProperty(exports, "ParallelMessageQueue", {
-	enumerable: true,
-	get: function() {
-		return ParallelMessageQueue;
-	}
-});
 Object.defineProperty(exports, "SendActivityError", {
 	enumerable: true,
 	get: function() {