@fedify/fedify 2.4.0-dev.1508 → 2.4.0-dev.1531

package/dist/federation/tasks/enqueue.test.mjs

@@ -1,992 +0,0 @@
-import { Temporal } from "@js-temporal/polyfill";
-import "urlpattern-polyfill";
-globalThis.addEventListener = () => {};
-import { t as MemoryKvStore } from "../../kv-CIvR3Non.mjs";
-import { a as numberSchema, i as makeSchema, n as baseOptions, o as stringSchema, t as MockQueue } from "../../testing-Dy-WhqpN.mjs";
-import { o as createFederation } from "../../middleware-Dl2nyVgB.mjs";
-import { n as ParallelMessageQueue } from "../../mq-03vS-C9P.mjs";
-import { configure, reset } from "@logtape/logtape";
-import { delay } from "es-toolkit";
-import { test } from "@fedify/fixture";
-import { deepStrictEqual, ok, rejects, strictEqual } from "node:assert/strict";
-//#region src/federation/tasks/enqueue.test.ts
-/**
-* A {@link KvStore} that delegates to an in-memory store but deliberately
-* omits `cas`, so that `kv.cas == null`.  This drives the deduplication
-* fallback branches that fire when no conditional-write primitive exists.
-*/
-var CaslessKvStore = class {
-	inner = new MemoryKvStore();
-	get(key) {
-		return this.inner.get(key);
-	}
-	set(key, value, options) {
-		return this.inner.set(key, value, options);
-	}
-	delete(key) {
-		return this.inner.delete(key);
-	}
-	list(prefix) {
-		return this.inner.list(prefix);
-	}
-};
-async function collectKeys(kv, prefix) {
-	const keys = [];
-	for await (const { key } of kv.list(prefix)) keys.push(key);
-	return keys;
-}
-const TASK_DEDUP_PREFIX = ["_fedify", "taskDeduplication"];
-const ACTIVITY_IDEMPOTENCE_PREFIX = ["_fedify", "activityIdempotence"];
-const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-test("enqueueTasks() validation and dispatch", async (t) => {
-	await t.step("rejects an invalid payload at enqueue", async () => {
-		const queue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: { task: queue }
-		});
-		const task = federation.defineTask("strictly-typed", {
-			schema: numberSchema,
-			handler: () => {}
-		});
-		const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-		await rejects(() => ctx.enqueueTask(task, "not a number"), {
-			name: "TypeError",
-			message: /Task data failed schema validation/
-		});
-		strictEqual(queue.enqueued.length, 0);
-	});
-	await t.step("stamps the message envelope", async () => {
-		const queue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: { task: queue }
-		});
-		const task = federation.defineTask("envelope", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		await federation.createContext(new URL("https://example.com/"), void 0).enqueueTask(task, "payload");
-		strictEqual(queue.enqueued.length, 1);
-		const { message } = queue.enqueued[0];
-		strictEqual(message.type, "task");
-		strictEqual(message.taskName, "envelope");
-		strictEqual(message.baseUrl, "https://example.com");
-		strictEqual(message.attempt, 0);
-		ok(UUID_RE.test(message.id));
-		ok(typeof message.data === "string" && message.data.length > 0);
-		ok(Temporal.Instant.from(message.started) instanceof Temporal.Instant);
-		ok(typeof message.traceContext === "object" && message.traceContext != null);
-	});
-	await t.step("passes delay and orderingKey through", async () => {
-		const queue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: { task: queue }
-		});
-		const task = federation.defineTask("delayed", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		await federation.createContext(new URL("https://example.com/"), void 0).enqueueTask(task, "payload", {
-			delay: { seconds: 30 },
-			orderingKey: "user:alice"
-		});
-		strictEqual(queue.enqueued.length, 1);
-		const { message, options } = queue.enqueued[0];
-		strictEqual(message.taskName, "delayed");
-		strictEqual(message.orderingKey, "user:alice");
-		strictEqual(message.attempt, 0);
-		ok(options?.delay instanceof Temporal.Duration);
-		strictEqual(options.delay.total("second"), 30);
-		strictEqual(options.orderingKey, "user:alice");
-	});
-	await t.step("starts the task worker on first enqueue without startQueue()", async () => {
-		const queue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			manuallyStartQueue: false,
-			queue: { task: queue }
-		});
-		const task = federation.defineTask("auto-start", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-		await ctx.enqueueTask(task, "first");
-		strictEqual(queue.listenCount, 1);
-		await ctx.enqueueTask(task, "second");
-		strictEqual(queue.listenCount, 1);
-		strictEqual(queue.enqueued.length, 2);
-	});
-	await t.step("throws when the resolved task queue is null", async () => {
-		const federation = createFederation({ ...baseOptions });
-		const task = federation.defineTask("queueless", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-		await rejects(() => ctx.enqueueTask(task, "data"), {
-			name: "TypeError",
-			message: /No message queue is configured/
-		});
-	});
-	await t.step("rejects a handle from another federation at enqueue", async () => {
-		const queue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: { task: queue }
-		});
-		const foreignTask = createFederation({
-			...baseOptions,
-			queue: { task: new MockQueue() }
-		}).defineTask("foreign", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-		await rejects(() => ctx.enqueueTask(foreignTask, "data"), {
-			name: "TypeError",
-			message: /is not defined on this federation/
-		});
-		strictEqual(queue.enqueued.length, 0);
-	});
-	await t.step("rejects a same-named handle from another federation", async () => {
-		const queue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: { task: queue }
-		});
-		let called = 0;
-		federation.defineTask("rename", {
-			schema: numberSchema,
-			handler: () => {
-				called++;
-			}
-		});
-		const foreignTask = createFederation({
-			...baseOptions,
-			queue: { task: new MockQueue() }
-		}).defineTask("rename", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-		await rejects(() => ctx.enqueueTask(foreignTask, "not a number"), {
-			name: "TypeError",
-			message: /is not defined on this federation/
-		});
-		strictEqual(queue.enqueued.length, 0);
-		strictEqual(called, 0);
-	});
-	await t.step("enqueueTaskMany() uses enqueueMany when available", async () => {
-		const queue = new MockQueue({ supportsEnqueueMany: true });
-		const federation = createFederation({
-			...baseOptions,
-			queue: { task: queue }
-		});
-		const task = federation.defineTask("bulk", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		await federation.createContext(new URL("https://example.com/"), void 0).enqueueTaskMany(task, [
-			"a",
-			"b",
-			"c"
-		]);
-		strictEqual(queue.enqueued.length, 0);
-		strictEqual(queue.enqueuedMany.length, 1);
-		strictEqual(queue.enqueuedMany[0].messages.length, 3);
-	});
-	await t.step("enqueueTaskMany() falls back to parallel enqueues", async () => {
-		const queue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: { task: queue }
-		});
-		const task = federation.defineTask("bulk-fallback", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		await federation.createContext(new URL("https://example.com/"), void 0).enqueueTaskMany(task, ["a", "b"]);
-		strictEqual(queue.enqueued.length, 2);
-	});
-	await t.step("enqueueTaskMany() with no payloads touches no queue", async () => {
-		const queue = new MockQueue({ supportsEnqueueMany: true });
-		const federation = createFederation({
-			...baseOptions,
-			queue: { task: queue }
-		});
-		const task = federation.defineTask("bulk-empty", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		await federation.createContext(new URL("https://example.com/"), void 0).enqueueTaskMany(task, []);
-		strictEqual(queue.enqueued.length, 0);
-		strictEqual(queue.enqueuedMany.length, 0);
-	});
-});
-test("task deduplication", async (t) => {
-	await t.step("forwards the key to a nativeDeduplication queue without writing KV", async () => {
-		const queue = new MockQueue({ nativeDeduplication: true });
-		const kv = new MemoryKvStore();
-		const federation = createFederation({
-			...baseOptions,
-			kv,
-			queue: { task: queue }
-		});
-		const task = federation.defineTask("native-dedup", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		await federation.createContext(new URL("https://example.com/"), void 0).enqueueTask(task, "payload", { deduplicationKey: "k" });
-		strictEqual(queue.enqueued.length, 1);
-		strictEqual(queue.enqueued[0].options?.deduplicationKey, "k");
-		strictEqual((await collectKeys(kv, TASK_DEDUP_PREFIX)).length, 0);
-	});
-	await t.step("skips a second enqueue with the same key within the TTL", async () => {
-		const queue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			kv: new MemoryKvStore(),
-			queue: { task: queue }
-		});
-		const task = federation.defineTask("kv-dedup", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-		await ctx.enqueueTask(task, "first", { deduplicationKey: "k" });
-		await ctx.enqueueTask(task, "second", { deduplicationKey: "k" });
-		strictEqual(queue.enqueued.length, 1);
-		strictEqual(queue.enqueued[0].message.taskName, "kv-dedup");
-		strictEqual(queue.enqueued[0].options?.deduplicationKey, void 0);
-	});
-	await t.step("re-enqueues with the same key after the TTL expires", async () => {
-		const queue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			kv: new MemoryKvStore(),
-			queue: { task: queue },
-			taskDeduplicationTtl: { milliseconds: 100 }
-		});
-		const task = federation.defineTask("kv-dedup-ttl", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-		await ctx.enqueueTask(task, "first", { deduplicationKey: "k" });
-		strictEqual(queue.enqueued.length, 1);
-		await delay(300);
-		await ctx.enqueueTask(task, "second", { deduplicationKey: "k" });
-		strictEqual(queue.enqueued.length, 2);
-	});
-	await t.step("rejects with TypeError when fallback is \"closed\" and no cas exists", async () => {
-		const queue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			kv: new CaslessKvStore(),
-			queue: { task: queue },
-			taskDeduplicationFallback: "closed"
-		});
-		const task = federation.defineTask("closed-fallback", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-		await rejects(() => ctx.enqueueTask(task, "payload", { deduplicationKey: "k" }), { name: "TypeError" });
-		strictEqual(queue.enqueued.length, 0);
-	});
-	await t.step("proceeds when fallback is \"open\" and no cas exists", async () => {
-		const queue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			kv: new CaslessKvStore(),
-			queue: { task: queue },
-			taskDeduplicationFallback: "open"
-		});
-		const task = federation.defineTask("open-fallback", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		await federation.createContext(new URL("https://example.com/"), void 0).enqueueTask(task, "payload", { deduplicationKey: "k" });
-		strictEqual(queue.enqueued.length, 1);
-		strictEqual(queue.enqueued[0].options?.deduplicationKey, void 0);
-	});
-	await t.step("writes only under taskDeduplication, never activityIdempotence", async () => {
-		const queue = new MockQueue();
-		const kv = new MemoryKvStore();
-		const federation = createFederation({
-			...baseOptions,
-			kv,
-			queue: { task: queue }
-		});
-		const task = federation.defineTask("prefix-isolation", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		await federation.createContext(new URL("https://example.com/"), void 0).enqueueTask(task, "payload", { deduplicationKey: "k" });
-		strictEqual((await collectKeys(kv, TASK_DEDUP_PREFIX)).length, 1);
-		strictEqual((await collectKeys(kv, ACTIVITY_IDEMPOTENCE_PREFIX)).length, 0);
-	});
-	await t.step("applies one batch-level key to enqueueTaskMany", async () => {
-		const queue = new MockQueue({ supportsEnqueueMany: true });
-		const federation = createFederation({
-			...baseOptions,
-			kv: new MemoryKvStore(),
-			queue: { task: queue }
-		});
-		const task = federation.defineTask("batch-dedup", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-		await ctx.enqueueTaskMany(task, [
-			"a",
-			"b",
-			"c"
-		], { deduplicationKey: "batch" });
-		await ctx.enqueueTaskMany(task, [
-			"a",
-			"b",
-			"c"
-		], { deduplicationKey: "batch" });
-		strictEqual(queue.enqueuedMany.length, 1);
-		strictEqual(queue.enqueuedMany[0].messages.length, 3);
-	});
-});
-test("task deduplication validates every payload before reserving the key", async () => {
-	const queue = new MockQueue();
-	const kv = new MemoryKvStore();
-	const federation = createFederation({
-		...baseOptions,
-		kv,
-		queue: { task: queue }
-	});
-	const task = federation.defineTask("dedup-validation", {
-		schema: stringSchema,
-		handler: () => {}
-	});
-	const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-	await rejects(() => ctx.enqueueTask(task, 123, { deduplicationKey: "k" }));
-	strictEqual(queue.enqueued.length, 0);
-	deepStrictEqual(await collectKeys(kv, TASK_DEDUP_PREFIX), []);
-	await ctx.enqueueTask(task, "valid", { deduplicationKey: "k" });
-	strictEqual(queue.enqueued.length, 1);
-	deepStrictEqual(await collectKeys(kv, TASK_DEDUP_PREFIX), [[...TASK_DEDUP_PREFIX, "k"]]);
-	await ctx.enqueueTask(task, "duplicate", { deduplicationKey: "k" });
-	strictEqual(queue.enqueued.length, 1);
-});
-test("native task batch deduplication is one enqueueMany operation per call", async () => {
-	class NativeBatchDeduplicatingQueue {
-		nativeDeduplication = true;
-		#seen = /* @__PURE__ */ new Set();
-		attempts = [];
-		accepted = [];
-		enqueue() {
-			throw new Error("A multi-item native batch must use enqueueMany().");
-		}
-		enqueueMany(messages, options) {
-			const key = options?.deduplicationKey;
-			if (key == null) throw new TypeError("Native batch enqueue requires a deduplication key.");
-			this.attempts.push({
-				messages,
-				options
-			});
-			if (this.#seen.has(key)) return Promise.resolve();
-			this.#seen.add(key);
-			this.accepted.push({
-				messages,
-				options
-			});
-			return Promise.resolve();
-		}
-		listen() {
-			return Promise.resolve();
-		}
-	}
-	const queue = new NativeBatchDeduplicatingQueue();
-	const kv = new MemoryKvStore();
-	const federation = createFederation({
-		...baseOptions,
-		kv,
-		queue: { task: queue }
-	});
-	const task = federation.defineTask("native-batch-dedup", {
-		schema: stringSchema,
-		handler: () => {}
-	});
-	const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-	await ctx.enqueueTaskMany(task, [
-		"a1",
-		"a2",
-		"a3"
-	], { deduplicationKey: "batch-a" });
-	await ctx.enqueueTaskMany(task, [
-		"duplicate1",
-		"duplicate2",
-		"duplicate3"
-	], { deduplicationKey: "batch-a" });
-	await ctx.enqueueTaskMany(task, [
-		"b1",
-		"b2",
-		"b3"
-	], { deduplicationKey: "batch-b" });
-	strictEqual(queue.attempts.length, 3);
-	deepStrictEqual(queue.attempts.map(({ messages }) => messages.length), [
-		3,
-		3,
-		3
-	]);
-	deepStrictEqual(queue.attempts.map(({ options }) => options?.deduplicationKey), [
-		"batch-a",
-		"batch-a",
-		"batch-b"
-	]);
-	strictEqual(queue.accepted.length, 2);
-	deepStrictEqual(queue.accepted.map(({ messages }) => messages.length), [3, 3]);
-	deepStrictEqual(queue.accepted.map(({ options }) => options?.deduplicationKey), ["batch-a", "batch-b"]);
-	deepStrictEqual(await collectKeys(kv, TASK_DEDUP_PREFIX), []);
-});
-test("native task batch deduplication rejects without enqueueMany", async () => {
-	const queue = new MockQueue({ nativeDeduplication: true });
-	const kv = new MemoryKvStore();
-	const federation = createFederation({
-		...baseOptions,
-		kv,
-		queue: { task: queue }
-	});
-	const task = federation.defineTask("native-batch-without-enqueue-many", {
-		schema: stringSchema,
-		handler: () => {}
-	});
-	const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-	await rejects(() => ctx.enqueueTaskMany(task, [
-		"a",
-		"b",
-		"c"
-	], { deduplicationKey: "batch" }), {
-		name: "TypeError",
-		message: /enqueueMany/
-	});
-	strictEqual(queue.enqueued.length, 0);
-	strictEqual(queue.enqueuedMany.length, 0);
-	deepStrictEqual(await collectKeys(kv, TASK_DEDUP_PREFIX), []);
-	await ctx.enqueueTaskMany(task, ["single"], { deduplicationKey: "single" });
-	strictEqual(queue.enqueued.length, 1);
-	strictEqual(queue.enqueued[0].options?.deduplicationKey, "single");
-});
-test("deduplication - native batch capability errors precede payload validation", async () => {
-	let validationCalls = 0;
-	const schema = makeSchema((data) => {
-		validationCalls++;
-		return typeof data === "string";
-	});
-	const queue = new MockQueue({ nativeDeduplication: true });
-	const kv = new MemoryKvStore();
-	const federation = createFederation({
-		...baseOptions,
-		kv,
-		queue: { task: queue }
-	});
-	const task = federation.defineTask("native-batch-capability-order", {
-		schema,
-		handler: () => {}
-	});
-	const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-	let caught;
-	try {
-		await ctx.enqueueTaskMany(task, [
-			1,
-			2,
-			3
-		], { deduplicationKey: "batch" });
-	} catch (error) {
-		caught = error;
-	}
-	strictEqual(validationCalls, 0);
-	ok(caught instanceof TypeError);
-	ok(caught.message.includes("enqueueMany"));
-	strictEqual(queue.enqueued.length, 0);
-	strictEqual(queue.enqueuedMany.length, 0);
-	deepStrictEqual(await collectKeys(kv, TASK_DEDUP_PREFIX), []);
-});
-test("closed deduplication fallback errors precede payload validation", async () => {
-	let validationCalls = 0;
-	const schema = makeSchema((data) => {
-		validationCalls++;
-		return typeof data === "string";
-	});
-	const queue = new MockQueue();
-	const kv = new CaslessKvStore();
-	const federation = createFederation({
-		...baseOptions,
-		kv,
-		queue: { task: queue },
-		taskDeduplicationFallback: "closed"
-	});
-	const task = federation.defineTask("closed-fallback-order", {
-		schema,
-		handler: () => {}
-	});
-	const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-	let caught;
-	try {
-		await ctx.enqueueTask(task, 1, { deduplicationKey: "k" });
-	} catch (error) {
-		caught = error;
-	}
-	strictEqual(validationCalls, 0);
-	ok(caught instanceof TypeError);
-	ok(caught.message.includes("conditional write"));
-	strictEqual(queue.enqueued.length, 0);
-	strictEqual(queue.enqueuedMany.length, 0);
-	deepStrictEqual(await collectKeys(kv, TASK_DEDUP_PREFIX), []);
-});
-/**
-* A {@link MessageQueue} that fails its first enqueue—single or batch—with a
-* transient error, then records every later enqueue.  One class covers both the
-* `enqueue()` and `enqueueMany()` rollback paths; each test instantiates its own
-* copy, so the one-shot `#failNext` flag never leaks between them.
-*/
-var FlakyQueue = class {
-	nativeDeduplication = false;
-	#failNext = true;
-	enqueued = [];
-	enqueuedMany = [];
-	#failOnce() {
-		if (!this.#failNext) return false;
-		this.#failNext = false;
-		return true;
-	}
-	enqueue(message) {
-		if (this.#failOnce()) return Promise.reject(/* @__PURE__ */ new Error("transient backend failure"));
-		this.enqueued.push(message);
-		return Promise.resolve();
-	}
-	enqueueMany(messages) {
-		if (this.#failOnce()) return Promise.reject(/* @__PURE__ */ new Error("transient backend failure"));
-		this.enqueuedMany.push([...messages]);
-		return Promise.resolve();
-	}
-	listen() {
-		return Promise.resolve();
-	}
-};
-test("a failed enqueue rolls back its dedup marker so the retry is not dropped", async () => {
-	const queue = new FlakyQueue();
-	const kv = new MemoryKvStore();
-	const federation = createFederation({
-		...baseOptions,
-		kv,
-		queue: { task: queue }
-	});
-	const task = federation.defineTask("flaky-enqueue", {
-		schema: stringSchema,
-		handler: () => {}
-	});
-	const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-	const markerKey = [...TASK_DEDUP_PREFIX, "k"];
-	await rejects(() => ctx.enqueueTask(task, "first", { deduplicationKey: "k" }), { message: /transient backend failure/ });
-	strictEqual(queue.enqueued.length, 0);
-	strictEqual(await kv.get(markerKey), void 0);
-	await ctx.enqueueTask(task, "first-retry", { deduplicationKey: "k" });
-	strictEqual(queue.enqueued.length, 1);
-	ok(await kv.get(markerKey) != null);
-	await ctx.enqueueTask(task, "duplicate", { deduplicationKey: "k" });
-	strictEqual(queue.enqueued.length, 1);
-});
-test("a failed batch enqueue rolls back its dedup marker so the retry is not dropped", async () => {
-	const queue = new FlakyQueue();
-	const kv = new MemoryKvStore();
-	const federation = createFederation({
-		...baseOptions,
-		kv,
-		queue: { task: queue }
-	});
-	const task = federation.defineTask("flaky-batch-enqueue", {
-		schema: stringSchema,
-		handler: () => {}
-	});
-	const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-	const markerKey = [...TASK_DEDUP_PREFIX, "batch"];
-	await rejects(() => ctx.enqueueTaskMany(task, ["first", "second"], { deduplicationKey: "batch" }), { message: /transient backend failure/ });
-	strictEqual(queue.enqueuedMany.length, 0);
-	strictEqual(await kv.get(markerKey), void 0);
-	await ctx.enqueueTaskMany(task, ["first-retry", "second-retry"], { deduplicationKey: "batch" });
-	strictEqual(queue.enqueuedMany.length, 1);
-	strictEqual(queue.enqueuedMany[0].length, 2);
-	ok(await kv.get(markerKey) != null);
-	await ctx.enqueueTaskMany(task, ["duplicate-first", "duplicate-second"], { deduplicationKey: "batch" });
-	strictEqual(queue.enqueuedMany.length, 1);
-});
-test("a stale rollback does not clear a marker another enqueue re-claimed", async () => {
-	const kv = new MemoryKvStore();
-	const markerKey = [...TASK_DEDUP_PREFIX, "k"];
-	let signalFirstEntered;
-	const firstEntered = new Promise((resolve) => {
-		signalFirstEntered = resolve;
-	});
-	let releaseFirst;
-	const firstReleased = new Promise((resolve) => {
-		releaseFirst = resolve;
-	});
-	class BlockingThenFailingQueue {
-		nativeDeduplication = false;
-		#calls = 0;
-		async enqueue() {
-			this.#calls++;
-			if (this.#calls === 1) {
-				signalFirstEntered();
-				await firstReleased;
-				throw new Error("transient backend failure");
-			}
-		}
-		listen() {
-			return Promise.resolve();
-		}
-	}
-	const queue = new BlockingThenFailingQueue();
-	const federation = createFederation({
-		...baseOptions,
-		kv,
-		queue: { task: queue },
-		taskDeduplicationTtl: { milliseconds: 1 }
-	});
-	const task = federation.defineTask("stale-rollback", {
-		schema: stringSchema,
-		handler: () => {}
-	});
-	const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-	const first = ctx.enqueueTask(task, "first", { deduplicationKey: "k" });
-	await firstEntered;
-	await delay(20);
-	await ctx.enqueueTask(task, "second", { deduplicationKey: "k" });
-	const secondToken = await kv.get(markerKey);
-	ok(secondToken != null);
-	releaseFirst();
-	await rejects(() => first, { message: /transient backend failure/ });
-	strictEqual(await kv.get(markerKey), secondToken);
-});
-test("a multi-item batch dedup without enqueueMany is rejected on the cas path", async () => {
-	const queue = new MockQueue();
-	const kv = new MemoryKvStore();
-	const federation = createFederation({
-		...baseOptions,
-		kv,
-		queue: { task: queue }
-	});
-	const task = federation.defineTask("cas-batch-without-enqueue-many", {
-		schema: stringSchema,
-		handler: () => {}
-	});
-	const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-	await rejects(() => ctx.enqueueTaskMany(task, [
-		"a",
-		"b",
-		"c"
-	], { deduplicationKey: "batch" }), {
-		name: "TypeError",
-		message: /enqueueMany/
-	});
-	strictEqual(queue.enqueued.length, 0);
-	strictEqual(queue.enqueuedMany.length, 0);
-	deepStrictEqual(await collectKeys(kv, TASK_DEDUP_PREFIX), []);
-	await ctx.enqueueTaskMany(task, ["single"], { deduplicationKey: "single" });
-	strictEqual(queue.enqueued.length, 1);
-});
-test("a failed rollback is swallowed; the original enqueue error reaches the caller", async () => {
-	class ClearFailingKvStore {
-		inner = new MemoryKvStore();
-		clearAttempts = 0;
-		get(key) {
-			return this.inner.get(key);
-		}
-		set(key, value, options) {
-			return this.inner.set(key, value, options);
-		}
-		delete(key) {
-			return this.inner.delete(key);
-		}
-		list(prefix) {
-			return this.inner.list(prefix);
-		}
-		cas(key, expectedValue, newValue, options) {
-			if (newValue === void 0) {
-				this.clearAttempts++;
-				return Promise.reject(/* @__PURE__ */ new Error("kv cas clear failed"));
-			}
-			return this.inner.cas(key, expectedValue, newValue, options);
-		}
-	}
-	const queue = new FlakyQueue();
-	const kv = new ClearFailingKvStore();
-	const federation = createFederation({
-		...baseOptions,
-		kv,
-		queue: { task: queue }
-	});
-	const task = federation.defineTask("rollback-failure", {
-		schema: stringSchema,
-		handler: () => {}
-	});
-	const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-	await rejects(() => ctx.enqueueTask(task, "first", { deduplicationKey: "k" }), { message: /transient backend failure/ });
-	strictEqual(queue.enqueued.length, 0);
-	strictEqual(kv.clearAttempts, 1);
-});
-/**
-* A native-deduplication backend that drops repeat-key single enqueues and
-* does **not** implement `enqueueMany`.  Wrapping it in
-* {@link ParallelMessageQueue} used to fan a batch out to one `enqueue()` per
-* message, all carrying the same `deduplicationKey`, so the backend collapsed
-* the whole batch onto its first message.
-*/
-var NativeDedupNoBulkQueue = class {
-	nativeDeduplication = true;
-	#seen = /* @__PURE__ */ new Set();
-	enqueued = [];
-	enqueue(message, options) {
-		const key = options?.deduplicationKey;
-		if (key != null) {
-			if (this.#seen.has(key)) return Promise.resolve();
-			this.#seen.add(key);
-		}
-		this.enqueued.push({
-			message,
-			options
-		});
-		return Promise.resolve();
-	}
-	listen() {
-		return Promise.resolve();
-	}
-};
-test("a deduplicated batch over a ParallelMessageQueue wrapping a native, no-enqueueMany backend is rejected, not collapsed", async () => {
-	const backend = new NativeDedupNoBulkQueue();
-	const queue = new ParallelMessageQueue(backend, 5);
-	const kv = new MemoryKvStore();
-	const federation = createFederation({
-		...baseOptions,
-		kv,
-		queue: { task: queue }
-	});
-	const task = federation.defineTask("parallel-native-no-bulk", {
-		schema: stringSchema,
-		handler: () => {}
-	});
-	const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-	await rejects(() => ctx.enqueueTaskMany(task, [
-		"a",
-		"b",
-		"c"
-	], { deduplicationKey: "batch" }), {
-		name: "TypeError",
-		message: /enqueueMany/
-	});
-	strictEqual(backend.enqueued.length, 0);
-	deepStrictEqual(await collectKeys(kv, TASK_DEDUP_PREFIX), []);
-	await ctx.enqueueTaskMany(task, ["solo"], { deduplicationKey: "solo" });
-	strictEqual(backend.enqueued.length, 1);
-	strictEqual(backend.enqueued[0].options?.deduplicationKey, "solo");
-});
-test("a deduplicated batch over a ParallelMessageQueue wrapping a non-native, no-enqueueMany backend is rejected on the cas path", async () => {
-	const backend = new MockQueue();
-	const queue = new ParallelMessageQueue(backend, 5);
-	const kv = new MemoryKvStore();
-	const federation = createFederation({
-		...baseOptions,
-		kv,
-		queue: { task: queue }
-	});
-	const task = federation.defineTask("parallel-cas-no-bulk", {
-		schema: stringSchema,
-		handler: () => {}
-	});
-	const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-	await rejects(() => ctx.enqueueTaskMany(task, [
-		"a",
-		"b",
-		"c"
-	], { deduplicationKey: "batch" }), {
-		name: "TypeError",
-		message: /enqueueMany/
-	});
-	strictEqual(backend.enqueued.length, 0);
-	deepStrictEqual(await collectKeys(kv, TASK_DEDUP_PREFIX), []);
-	await ctx.enqueueTaskMany(task, ["solo"], { deduplicationKey: "solo" });
-	strictEqual(backend.enqueued.length, 1);
-});
-test("a deduplicated batch over a ParallelMessageQueue wrapping a native enqueueMany backend forwards the key atomically", async () => {
-	class NativeBatchQueue {
-		nativeDeduplication = true;
-		#seen = /* @__PURE__ */ new Set();
-		batches = [];
-		enqueue() {
-			throw new Error("A multi-item native batch must use enqueueMany().");
-		}
-		enqueueMany(messages, options) {
-			const key = options?.deduplicationKey;
-			if (key != null && this.#seen.has(key)) return Promise.resolve();
-			if (key != null) this.#seen.add(key);
-			this.batches.push({
-				messages,
-				options
-			});
-			return Promise.resolve();
-		}
-		listen() {
-			return Promise.resolve();
-		}
-	}
-	const backend = new NativeBatchQueue();
-	const queue = new ParallelMessageQueue(backend, 5);
-	const kv = new MemoryKvStore();
-	const federation = createFederation({
-		...baseOptions,
-		kv,
-		queue: { task: queue }
-	});
-	const task = federation.defineTask("parallel-native-bulk", {
-		schema: stringSchema,
-		handler: () => {}
-	});
-	const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-	await ctx.enqueueTaskMany(task, [
-		"a",
-		"b",
-		"c"
-	], { deduplicationKey: "batch" });
-	await ctx.enqueueTaskMany(task, [
-		"x",
-		"y",
-		"z"
-	], { deduplicationKey: "batch" });
-	strictEqual(backend.batches.length, 1);
-	strictEqual(backend.batches[0].messages.length, 3);
-	strictEqual(backend.batches[0].options?.deduplicationKey, "batch");
-	deepStrictEqual(await collectKeys(kv, TASK_DEDUP_PREFIX), []);
-});
-test("an \"open\" fallback fans out a multi-item batch without enqueueMany instead of rejecting it", async () => {
-	const queue = new MockQueue();
-	const kv = new CaslessKvStore();
-	const federation = createFederation({
-		...baseOptions,
-		kv,
-		queue: { task: queue },
-		taskDeduplicationFallback: "open"
-	});
-	const task = federation.defineTask("open-batch-fanout", {
-		schema: stringSchema,
-		handler: () => {}
-	});
-	await federation.createContext(new URL("https://example.com/"), void 0).enqueueTaskMany(task, [
-		"a",
-		"b",
-		"c"
-	], { deduplicationKey: "batch" });
-	strictEqual(queue.enqueued.length, 3);
-	for (const { options } of queue.enqueued) strictEqual(options?.deduplicationKey, void 0);
-	deepStrictEqual(await collectKeys(kv.inner, TASK_DEDUP_PREFIX), []);
-});
-test("an \"open\" fallback logs a debug record when it ignores the key", async () => {
-	const records = [];
-	await reset();
-	try {
-		await configure({
-			sinks: { buffer(record) {
-				records.push(record);
-			} },
-			filters: {},
-			loggers: [{
-				category: [],
-				lowestLevel: "debug",
-				sinks: ["buffer"]
-			}]
-		});
-		const queue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			kv: new CaslessKvStore(),
-			queue: { task: queue },
-			taskDeduplicationFallback: "open"
-		});
-		const task = federation.defineTask("open-debug-log", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		await federation.createContext(new URL("https://example.com/"), void 0).enqueueTask(task, "payload", { deduplicationKey: "k" });
-		strictEqual(records.filter((record) => record.level === "debug" && record.properties.deduplicationKey === "k" && record.properties.taskName === "open-debug-log").length, 1);
-	} finally {
-		await reset();
-	}
-});
-test("two concurrent enqueues sharing a key: exactly one wins the cas claim", async () => {
-	let signalEntered;
-	const entered = new Promise((resolve) => {
-		signalEntered = resolve;
-	});
-	let release;
-	const released = new Promise((resolve) => {
-		release = resolve;
-	});
-	class BlockingQueue {
-		nativeDeduplication = false;
-		enqueued = [];
-		#first = true;
-		async enqueue(message) {
-			if (this.#first) {
-				this.#first = false;
-				signalEntered();
-				await released;
-			}
-			this.enqueued.push(message);
-		}
-		listen() {
-			return Promise.resolve();
-		}
-	}
-	const queue = new BlockingQueue();
-	const kv = new MemoryKvStore();
-	const federation = createFederation({
-		...baseOptions,
-		kv,
-		queue: { task: queue }
-	});
-	const task = federation.defineTask("concurrent-claim", {
-		schema: stringSchema,
-		handler: () => {}
-	});
-	const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-	const first = ctx.enqueueTask(task, "first", { deduplicationKey: "k" });
-	await entered;
-	await ctx.enqueueTask(task, "second", { deduplicationKey: "k" });
-	release();
-	await first;
-	strictEqual(queue.enqueued.length, 1);
-	await ctx.enqueueTask(task, "third", { deduplicationKey: "k" });
-	strictEqual(queue.enqueued.length, 1);
-});
-test("a native enqueue forwards orderingKey and deduplicationKey together", async () => {
-	const queue = new MockQueue({ nativeDeduplication: true });
-	const federation = createFederation({
-		...baseOptions,
-		kv: new MemoryKvStore(),
-		queue: { task: queue }
-	});
-	const task = federation.defineTask("native-both-keys", {
-		schema: stringSchema,
-		handler: () => {}
-	});
-	await federation.createContext(new URL("https://example.com/"), void 0).enqueueTask(task, "payload", {
-		orderingKey: "user:alice",
-		deduplicationKey: "dedup:alice"
-	});
-	strictEqual(queue.enqueued.length, 1);
-	const { message, options } = queue.enqueued[0];
-	strictEqual(message.orderingKey, "user:alice");
-	strictEqual(options?.orderingKey, "user:alice");
-	strictEqual(options?.deduplicationKey, "dedup:alice");
-});
-//#endregion
-export {};