effect-mq 0.3.2 → 0.4.0

package/dist/redis/scripts.js

@@ -158,6 +158,30 @@ local function finishCancelled(id, queue, name, startedAt, now, nowStr)
   releaseDedupe(name, redis.call("HGET", jk, "dedupeKey"), id, now)
   applyKeep(name, "cancelled", redis.call("HGET", jk, "keep"), now)
 end
+-- Insert one fresh job row plus every index entry. String params are stored
+-- verbatim (payload/metadata/backoff/keep/trace are pre-encoded JSON, "" =
+-- absent); priority/delayMs/now numeric-coercible.
+local function insertJobRow(id, name, queue, payloadJson, metadataJson, priority,
+    attemptsMax, backoffJson, keepJson, timeoutMs, dedupeKey, traceJson, delayMs, now, nowStr)
+  local seq = redis.call("INCR", prefix .. ":seq")
+  local state = delayMs > 0 and "delayed" or "waiting"
+  local runAt = now + delayMs
+  redis.call("HSET", jobKey(id),
+    "id", id, "name", name, "queue", queue,
+    "payload", payloadJson, "metadata", metadataJson, "state", state,
+    "priority", priority, "attemptsMax", attemptsMax, "attemptsMade", "0", "stalledCount", "0",
+    "backoff", backoffJson, "keep", keepJson, "timeoutMs", timeoutMs,
+    "cancelRequested", "0", "dedupeKey", dedupeKey, "trace", traceJson, "runAt", fmt(runAt), "enqueuedAt", nowStr,
+    "processedAt", "", "finishedAt", "", "exit", "", "failedReason", "",
+    "lockToken", "", "lockExpiresAt", "", "seq", fmt(seq))
+  redis.call("ZADD", prefix .. ":all", now, id)
+  if state == "waiting" then
+    addWaiting(queue, tonumber(priority), seq, id)
+  else
+    redis.call("ZADD", delayedKey(queue), runAt, id)
+  end
+  countsAdd(queue, state, 1)
+end
 `;
 /**
  * enqueue(prefix, idMode, id, name, queue, payloadJson, metadataJson,
@@ -165,7 +189,7 @@ end
  * idMode: "user" (dedup no-op), "generated" (collision -> retry sentinel),
  * "auto" (j-<seq>, in-script collision loop).
  */
-export const enqueue = Redis.script((prefix, idMode, id, name, queue, payloadJson, metadataJson, priority, attemptsMax, backoffJson, keepJson, timeoutMs, delayMs, now, dedupeKey, dedupeTtlMs, dedupeExtend, dedupeReplace) => [
+export const enqueue = Redis.script((prefix, idMode, id, name, queue, payloadJson, metadataJson, priority, attemptsMax, backoffJson, keepJson, timeoutMs, delayMs, now, dedupeKey, dedupeTtlMs, dedupeExtend, dedupeReplace, traceJson) => [
     prefix,
     idMode,
     id,
@@ -183,7 +207,8 @@ export const enqueue = Redis.script((prefix, idMode, id, name, queue, payloadJso
     dedupeKey,
     dedupeTtlMs,
     dedupeExtend,
-    dedupeReplace
+    dedupeReplace,
+    traceJson
 ], {
     numberOfKeys: 0,
     lua: `${HELPERS}
@@ -221,7 +246,7 @@ if dKey ~= "" then
       local newRunAt = now + delayMs
       redis.call("HSET", kjk, "payload", ARGV[6], "metadata", ARGV[7], "priority", ARGV[8],
         "attemptsMax", ARGV[9], "backoff", ARGV[10], "keep", ARGV[11], "timeoutMs", ARGV[12],
-        "runAt", fmt(newRunAt))
+        "trace", ARGV[19], "runAt", fmt(newRunAt))
       local keyedQueue = redis.call("HGET", kjk, "queue")
       redis.call("ZADD", delayedKey(keyedQueue), newRunAt, entryJob)
       -- A landed replace re-arms the ttl window.
@@ -255,24 +280,8 @@ if idMode == "auto" then
   end
   if id == "" then return '{"error":"id"}' end
 end
-local seq = redis.call("INCR", prefix .. ":seq")
-local state = delayMs > 0 and "delayed" or "waiting"
-local runAt = now + delayMs
-redis.call("HSET", jobKey(id),
-  "id", id, "name", ARGV[4], "queue", queue,
-  "payload", ARGV[6], "metadata", ARGV[7], "state", state,
-  "priority", ARGV[8], "attemptsMax", ARGV[9], "attemptsMade", "0", "stalledCount", "0",
-  "backoff", ARGV[10], "keep", ARGV[11], "timeoutMs", ARGV[12],
-  "cancelRequested", "0", "dedupeKey", dKey, "runAt", fmt(runAt), "enqueuedAt", nowStr,
-  "processedAt", "", "finishedAt", "", "exit", "", "failedReason", "",
-  "lockToken", "", "lockExpiresAt", "", "seq", fmt(seq))
-redis.call("ZADD", prefix .. ":all", now, id)
-if state == "waiting" then
-  addWaiting(queue, tonumber(ARGV[8]), seq, id)
-else
-  redis.call("ZADD", delayedKey(queue), runAt, id)
-end
-countsAdd(queue, state, 1)
+insertJobRow(id, ARGV[4], queue, ARGV[6], ARGV[7], ARGV[8], ARGV[9], ARGV[10], ARGV[11],
+  ARGV[12], dKey, ARGV[19], delayMs, now, nowStr)
 if dKey ~= "" then
   local sk = dedupeStoreKey(name, dKey)
   redis.call("DEL", sk)
@@ -831,6 +840,102 @@ redis.call("ZADD", prefix .. ":schedules", tonumber(ARGV[4]), key)
 return "1"
 `
 }).withReturnType();
+/**
+ * tickSchedule(prefix, key, expectedRunAt, nextRunAt, id, name, queue,
+ *   payloadJson, metadataJson, priority, attemptsMax, backoffJson, keepJson,
+ *   timeoutMs, traceJson, delayMs, now) -> "1" fired | "0"
+ * Atomic occurrence claim: the nextRunAt CAS and the tick job's insert run
+ * in one script, so a stale sweeper can never re-fire a slot — even after
+ * retention pruned the previous slot's job row.
+ */
+export const tickSchedule = Redis.script((prefix, key, expectedRunAt, nextRunAt, id, name, queue, payloadJson, metadataJson, priority, attemptsMax, backoffJson, keepJson, timeoutMs, traceJson, delayMs, now) => [
+    prefix,
+    key,
+    expectedRunAt,
+    nextRunAt,
+    id,
+    name,
+    queue,
+    payloadJson,
+    metadataJson,
+    priority,
+    attemptsMax,
+    backoffJson,
+    keepJson,
+    timeoutMs,
+    traceJson,
+    delayMs,
+    now
+], {
+    numberOfKeys: 0,
+    lua: `${HELPERS}
+local key = ARGV[2]
+local sk = prefix .. ":schedule:" .. key
+local current = redis.call("HGET", sk, "nextRunAt")
+if current == false or tonumber(current) ~= tonumber(ARGV[3]) then return "0" end
+redis.call("HSET", sk, "nextRunAt", fmt(tonumber(ARGV[4])))
+redis.call("ZADD", prefix .. ":schedules", tonumber(ARGV[4]), key)
+local id = ARGV[5]
+-- Pre-existing slot row (pre-0.4 crash between enqueue and advance): the
+-- schedule still advances, but nothing new fires.
+if redis.call("EXISTS", jobKey(id)) == 1 then return "0" end
+insertJobRow(id, ARGV[6], ARGV[7], ARGV[8], ARGV[9], ARGV[10], ARGV[11], ARGV[12], ARGV[13],
+  ARGV[14], "", ARGV[15], tonumber(ARGV[16]), tonumber(ARGV[17]), ARGV[17])
+return "1"
+`
+}).withReturnType();
+/**
+ * enqueueMany(prefix, now, count, ...items) -> JSON array of per-item results
+ * ({id, duplicate} | {collision} | {error}). Items are 13-ARGV strides:
+ * idMode, id, name, queue, payloadJson, metadataJson, priority, attemptsMax,
+ * backoffJson, keepJson, timeoutMs, traceJson, delayMs. Plain (non-dedup)
+ * items only — the caller routes dedup items through \`enqueue\`.
+ */
+export const enqueueMany = Redis.script((prefix, now, count, items) => [prefix, now, count, ...items], {
+    numberOfKeys: 0,
+    lua: `${HELPERS}
+local now = tonumber(ARGV[2])
+local nowStr = ARGV[2]
+local count = tonumber(ARGV[3])
+local out = {}
+for i = 0, count - 1 do
+  local base = 3 + i * 13
+  local idMode = ARGV[base + 1]
+  local id = ARGV[base + 2]
+  local result
+  if idMode ~= "auto" and redis.call("EXISTS", jobKey(id)) == 1 then
+    -- Sequential in-script processing makes intra-batch repeats of one user
+    -- id resolve exactly like separate enqueues: first inserts, rest dedup.
+    if idMode == "user" then
+      result = '{"id":' .. cjson.encode(id) .. ',"duplicate":true}'
+    else
+      result = '{"collision":true}'
+    end
+  else
+    if idMode == "auto" then
+      id = ""
+      for a = 1, 5 do
+        local candidate = "j-" .. fmt(redis.call("INCR", prefix .. ":seq"))
+        if redis.call("EXISTS", jobKey(candidate)) == 0 then
+          id = candidate
+          break
+        end
+      end
+    end
+    if id == "" then
+      result = '{"error":"id"}'
+    else
+      insertJobRow(id, ARGV[base + 3], ARGV[base + 4], ARGV[base + 5], ARGV[base + 6],
+        ARGV[base + 7], ARGV[base + 8], ARGV[base + 9], ARGV[base + 10], ARGV[base + 11],
+        "", ARGV[base + 12], tonumber(ARGV[base + 13]), now, nowStr)
+      result = '{"id":' .. cjson.encode(id) .. ',"duplicate":false}'
+    end
+  end
+  out[#out + 1] = result
+end
+return "[" .. table.concat(out, ",") .. "]"
+`
+}).withReturnType();
 /**
  * sweepState(prefix, state, ttlMs, limit, offset, now) -> {scanned, deleted}
  * One bounded page over a terminal state's finished zset, deleting rows past

package/dist/redis/scripts.js.map

@@ -1 +1 @@
-{"version":3,"file":"scripts.js","sourceRoot":"","sources":["../../src/redis/scripts.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"scripts.js","sourceRoot":"","sources":["../../src/redis/scripts.ts"],"names":[],"mappings":"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"}

package/dist/testing/conformance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conformance.d.ts","sourceRoot":"","sources":["../../src/testing/conformance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAA;AAE1C,OAAO,EAAuB,KAAK,KAAK,EAAU,MAAM,QAAQ,CAAA;AAiChE;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,SACxB,MAAM,cACA,MAAM,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAC/C,IAiuCF,CAAA"}
+{"version":3,"file":"conformance.d.ts","sourceRoot":"","sources":["../../src/testing/conformance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAA;AAE1C,OAAO,EAAuB,KAAK,KAAK,EAAU,MAAM,QAAQ,CAAA;AAkChE;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,SACxB,MAAM,cACA,MAAM,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAC/C,IA8jDF,CAAA"}

package/dist/testing/conformance.js

@@ -33,6 +33,7 @@ const baseRequest = (overrides) => ({
     keep: undefined,
     timeoutMs: undefined,
     dedupe: undefined,
+    trace: undefined,
     delayMs: 0,
     ...overrides
 });
@@ -586,6 +587,238 @@ export const jobStoreConformance = (name, storeLayer) => {
             expect(yield* store.removeSchedule(schedule.key)).toBe(false);
             expect(yield* store.listSchedules()).toEqual([]);
         })));
+        const minutelySchedule = () => ({
+            key: JobStore.ScheduleKey("TestJob/minutely"),
+            jobName: "TestJob",
+            queue: QueueName("default"),
+            cron: undefined,
+            tz: undefined,
+            everyMs: 60_000,
+            payload: { n: 7 },
+            metadata: {},
+            priority: 0,
+            attemptsMax: 1,
+            backoff: undefined,
+            keep: undefined,
+            timeoutMs: undefined,
+            nextRunAt: 60_000
+        });
+        it.effect("tickSchedule fires a slot exactly once and advances atomically", () => withStore((store) => Effect.gen(function* () {
+            const schedule = minutelySchedule();
+            yield* store.upsertSchedule(schedule);
+            yield* TestClock.adjust(60_000);
+            const request = baseRequest({
+                id: JobId("sched/TestJob/minutely/60000"),
+                payload: { n: 7 }
+            });
+            expect(yield* store.tickSchedule(schedule.key, 60_000, 120_000, request)).toBe(true);
+            expect((yield* store.listSchedules())[0]?.nextRunAt).toBe(120_000);
+            expect((yield* store.counts()).waiting).toBe(1);
+            // A concurrent sweeper holding the same stale expectation loses the
+            // CAS: nothing fires, nothing advances further.
+            expect(yield* store.tickSchedule(schedule.key, 60_000, 180_000, request)).toBe(false);
+            expect((yield* store.listSchedules())[0]?.nextRunAt).toBe(120_000);
+            expect((yield* store.counts()).waiting).toBe(1);
+            const claim = yield* store.claim(claimOptions());
+            assert(claim._tag === "Claimed");
+            expect(claim.job.id).toBe("sched/TestJob/minutely/60000");
+            expect(claim.job.payload).toEqual({ n: 7 });
+        })));
+        it.effect("a stale tick cannot re-fire a slot whose job was pruned", () => withStore((store) => Effect.gen(function* () {
+            const schedule = minutelySchedule();
+            yield* store.upsertSchedule(schedule);
+            yield* TestClock.adjust(60_000);
+            const slotId = JobId("sched/TestJob/minutely/60000");
+            const request = baseRequest({ id: slotId, payload: { n: 7 } });
+            expect(yield* store.tickSchedule(schedule.key, 60_000, 120_000, request)).toBe(true);
+            // Retention prunes the slot job — the old non-atomic design would
+            // now let a stale sweeper re-insert it. The CAS must still refuse.
+            expect(yield* store.remove(slotId)).toBe(true);
+            expect(yield* store.tickSchedule(schedule.key, 60_000, 180_000, request)).toBe(false);
+            expect((yield* store.counts()).waiting).toBe(0);
+            expect((yield* store.listSchedules())[0]?.nextRunAt).toBe(120_000);
+        })));
+        it.effect("tickSchedule advances without firing when the slot job already exists", () => withStore((store) => Effect.gen(function* () {
+            const schedule = minutelySchedule();
+            yield* store.upsertSchedule(schedule);
+            yield* TestClock.adjust(60_000);
+            const slotId = JobId("sched/TestJob/minutely/60000");
+            // A pre-0.4 worker crashed between its enqueue and advance: the
+            // slot row exists but nextRunAt is stale. The tick must advance the
+            // schedule (or it stays due forever) yet report nothing new fired.
+            yield* store.enqueue(baseRequest({ id: slotId, payload: { n: 7 } }));
+            const request = baseRequest({ id: slotId, payload: { n: 7 } });
+            expect(yield* store.tickSchedule(schedule.key, 60_000, 120_000, request)).toBe(false);
+            expect((yield* store.listSchedules())[0]?.nextRunAt).toBe(120_000);
+            expect((yield* store.counts()).waiting).toBe(1);
+        })));
+        it.effect("tickSchedule rejects requests without an id and unknown keys", () => withStore((store) => Effect.gen(function* () {
+            const missing = yield* Effect.flip(store.tickSchedule(JobStore.ScheduleKey("TestJob/minutely"), 60_000, 120_000, baseRequest()));
+            expect(missing._tag).toBe("JobStoreError");
+            expect(yield* store.tickSchedule(JobStore.ScheduleKey("ghost"), 0, 60_000, baseRequest({ id: JobId("sched/ghost/0") }))).toBe(false);
+            expect((yield* store.counts()).waiting).toBe(0);
+        })));
+        it.effect("tickSchedule wakes parked takers", () => withStore((store) => Effect.gen(function* () {
+            const schedule = minutelySchedule();
+            yield* store.upsertSchedule(schedule);
+            const empty = yield* store.claim(claimOptions());
+            assert(empty._tag === "Empty");
+            const waiter = yield* Effect.forkChild(store.awaitWake([QueueName("default")], empty.wakeToken));
+            yield* Effect.yieldNow;
+            yield* TestClock.adjust(60_000);
+            const request = baseRequest({
+                id: JobId("sched/TestJob/minutely/60000"),
+                payload: { n: 7 }
+            });
+            expect(yield* store.tickSchedule(schedule.key, 60_000, 120_000, request)).toBe(true);
+            yield* Fiber.join(waiter);
+            const claim = yield* store.claim(claimOptions({ token: "t-2" }));
+            assert(claim._tag === "Claimed");
+        })));
+        it.effect("enqueueMany inserts a batch with positional results", () => withStore((store) => Effect.gen(function* () {
+            const results = yield* store.enqueueMany([
+                baseRequest({ payload: { n: 1 } }),
+                baseRequest({ payload: { n: 2 }, delayMs: 60_000 }),
+                baseRequest({ id: JobId("batch-3"), payload: { n: 3 }, priority: 5 })
+            ]);
+            expect(results).toHaveLength(3);
+            expect(results.map((result) => result.duplicate)).toEqual([false, false, false]);
+            expect(new Set(results.map((result) => result.id)).size).toBe(3);
+            expect(results[2]?.id).toBe("batch-3");
+            const counts = yield* store.counts();
+            expect(counts.waiting).toBe(2);
+            expect(counts.delayed).toBe(1);
+            const explicit = yield* store.getJob(JobId("batch-3"));
+            assert(Option.isSome(explicit));
+            expect(explicit.value.payload).toEqual({ n: 3 });
+            expect(explicit.value.priority).toBe(5);
+            const delayedId = results[1]?.id;
+            assert(delayedId !== undefined);
+            const delayed = yield* store.getJob(delayedId);
+            assert(Option.isSome(delayed));
+            expect(delayed.value.state).toBe("delayed");
+            expect(delayed.value.runAt).toBe(60_000);
+            // Priority order survives the batch path.
+            const claim = yield* store.claim(claimOptions());
+            assert(claim._tag === "Claimed");
+            expect(claim.job.id).toBe("batch-3");
+        })));
+        it.effect("enqueueMany reports duplicates positionally without clobbering", () => withStore((store) => Effect.gen(function* () {
+            yield* store.enqueue(baseRequest({ id: JobId("dup-1"), payload: { n: 0 } }));
+            const results = yield* store.enqueueMany([
+                baseRequest({ payload: { n: 1 } }),
+                baseRequest({ id: JobId("dup-1"), payload: { n: 99 } }),
+                baseRequest({ payload: { n: 2 } })
+            ]);
+            expect(results.map((result) => result.duplicate)).toEqual([false, true, false]);
+            expect(results[1]?.id).toBe("dup-1");
+            const kept = yield* store.getJob(JobId("dup-1"));
+            assert(Option.isSome(kept));
+            expect(kept.value.payload).toEqual({ n: 0 });
+            expect((yield* store.counts()).waiting).toBe(3);
+        })));
+        it.effect("enqueueMany resolves intra-batch repeats of one id like separate enqueues", () => withStore((store) => Effect.gen(function* () {
+            const results = yield* store.enqueueMany([
+                baseRequest({ id: JobId("same"), payload: { n: 1 } }),
+                baseRequest({ id: JobId("same"), payload: { n: 2 } })
+            ]);
+            expect(results.map((result) => result.duplicate)).toEqual([false, true]);
+            expect(results[1]?.id).toBe("same");
+            expect((yield* store.counts()).waiting).toBe(1);
+            const job = yield* store.getJob(JobId("same"));
+            assert(Option.isSome(job));
+            expect(job.value.payload).toEqual({ n: 1 });
+        })));
+        it.effect("enqueueMany applies per-item dedup policies in order", () => withStore((store) => Effect.gen(function* () {
+            const dedupe = { key: "k", ttlMs: undefined, extend: false, replace: false };
+            const results = yield* store.enqueueMany([
+                baseRequest({ payload: { n: 1 }, dedupe }),
+                baseRequest({ payload: { n: 2 } }),
+                baseRequest({ payload: { n: 3 }, dedupe })
+            ]);
+            expect(results.map((result) => result.duplicate)).toEqual([false, false, true]);
+            expect(results[2]?.id).toBe(results[0]?.id);
+            expect((yield* store.counts()).waiting).toBe(2);
+        })));
+        it.effect("enqueueMany with an empty batch returns an empty array", () => withStore((store) => Effect.gen(function* () {
+            expect(yield* store.enqueueMany([])).toEqual([]);
+        })));
+        // Pins the hand-duplicated field plumbing in batch/tick insert paths
+        // (positional Lua ARGV strides, multi-row VALUES lists): every persisted
+        // field must come out identical to the single-enqueue path. A swapped
+        // pair of ARGVs or a dropped column fails this even though the simpler
+        // tests (payload/priority/state only) stay green.
+        it.effect("batch and tick inserts persist every field exactly like enqueue", () => withStore((store) => Effect.gen(function* () {
+            const richRequest = (id) => baseRequest({
+                id: JobId(id),
+                payload: { big: 1234567890123456, nested: { arr: [1, 2, 3] } },
+                metadata: { tenant: "acme", region: "us" },
+                priority: 3,
+                attemptsMax: 4,
+                backoff: { _tag: "fixed", delayMs: 2_000 },
+                keep: { completed: { count: 2, ageMs: undefined } },
+                timeoutMs: 9_000,
+                trace: { traceId: "trace-1", spanId: "span-1", sampled: true, delayed: false }
+            });
+            yield* store.enqueue(richRequest("rich-single"));
+            expect(yield* store.enqueueMany([richRequest("rich-batch")]))
+                .toEqual([{ id: "rich-batch", duplicate: false }]);
+            const schedule = {
+                ...minutelySchedule(),
+                key: JobStore.ScheduleKey("TestJob/parity"),
+                nextRunAt: 0
+            };
+            yield* store.upsertSchedule(schedule);
+            expect(yield* store.tickSchedule(schedule.key, 0, 60_000, richRequest("rich-tick")))
+                .toBe(true);
+            const project = (job) => ({
+                name: job.name,
+                queue: job.queue,
+                state: job.state,
+                payload: job.payload,
+                metadata: job.metadata,
+                priority: job.priority,
+                attemptsMax: job.attemptsMax,
+                attemptsMade: job.attemptsMade,
+                backoff: job.backoff,
+                keep: job.keep,
+                timeoutMs: job.timeoutMs,
+                cancelRequested: job.cancelRequested,
+                trace: job.trace,
+                runAt: job.runAt,
+                enqueuedAt: job.enqueuedAt
+            });
+            const single = yield* store.getJob(JobId("rich-single"));
+            assert(Option.isSome(single));
+            const expected = project(single.value);
+            // The reference row itself must carry the rich fields — otherwise
+            // three empty rows would compare equal and prove nothing.
+            expect(expected.backoff).toEqual({ _tag: "fixed", delayMs: 2_000 });
+            expect(expected.keep).toEqual({ completed: { count: 2 } });
+            expect(expected.timeoutMs).toBe(9_000);
+            expect(expected.trace).toEqual({
+                traceId: "trace-1",
+                spanId: "span-1",
+                sampled: true,
+                delayed: false
+            });
+            expect(expected.payload).toEqual({ big: 1234567890123456, nested: { arr: [1, 2, 3] } });
+            for (const id of [JobId("rich-batch"), JobId("rich-tick")]) {
+                const job = yield* store.getJob(id);
+                assert(Option.isSome(job));
+                expect(project(job.value)).toEqual(expected);
+            }
+        })));
+        it.effect("enqueueMany wakes parked takers", () => withStore((store) => Effect.gen(function* () {
+            const empty = yield* store.claim(claimOptions());
+            assert(empty._tag === "Empty");
+            const waiter = yield* Effect.forkChild(store.awaitWake([QueueName("default")], empty.wakeToken));
+            yield* Effect.yieldNow;
+            yield* store.enqueueMany([baseRequest()]);
+            yield* Fiber.join(waiter);
+            const claim = yield* store.claim(claimOptions({ token: "t-2" }));
+            assert(claim._tag === "Claimed");
+        })));
         it.effect("completion wins over a pending cancel request", () => withStore((store) => Effect.gen(function* () {
             const { id } = yield* store.enqueue(baseRequest());
             const claim = yield* store.claim(claimOptions());
@@ -930,6 +1163,39 @@ export const jobStoreConformance = (name, storeLayer) => {
             yield* Fiber.join(waiter);
             expect(woke).toBe(true);
         })));
+        it.effect("cancelByDedupe cancels pending keyed jobs and is idempotent", () => withStore((store) => Effect.gen(function* () {
+            const dedupe = { key: "emp-1", ttlMs: undefined, extend: false, replace: false };
+            // Unknown key: nothing pending, no error.
+            expect(yield* store.cancelByDedupe("TestJob", "emp-1")).toBe(false);
+            // Delayed keyed job: cancelled terminally.
+            const delayed = yield* store.enqueue(baseRequest({ dedupe, delayMs: 60_000 }));
+            expect(yield* store.cancelByDedupe("TestJob", "emp-1")).toBe(true);
+            const job = yield* store.getJob(delayed.id);
+            assert(Option.isSome(job));
+            expect(job.value.state).toBe("cancelled");
+            expect(yield* store.cancelByDedupe("TestJob", "emp-1")).toBe(false);
+            // Active keyed job: flagged for the heartbeat.
+            const active = yield* store.enqueue(baseRequest({ dedupe, payload: { n: 2 } }));
+            const claim = yield* store.claim(claimOptions());
+            assert(claim._tag === "Claimed");
+            expect(yield* store.cancelByDedupe("TestJob", "emp-1")).toBe(true);
+            const flagged = yield* store.getJob(active.id);
+            assert(Option.isSome(flagged));
+            expect(flagged.value.cancelRequested).toBe(true);
+            // Name scoping: same key under another name is untouched.
+            expect(yield* store.cancelByDedupe("OtherJob", "emp-1")).toBe(false);
+        })));
+        it.effect("the producer's trace context round-trips on the record", () => withStore((store) => Effect.gen(function* () {
+            const trace = { traceId: "trace-abc", spanId: "span-def", sampled: true, delayed: false };
+            const { id } = yield* store.enqueue(baseRequest({ trace }));
+            const job = yield* store.getJob(id);
+            assert(Option.isSome(job));
+            expect(job.value.trace).toEqual(trace);
+            const bare = yield* store.enqueue(baseRequest({ payload: { n: 2 } }));
+            const none = yield* store.getJob(bare.id);
+            assert(Option.isSome(none));
+            expect(none.value.trace).toBeUndefined();
+        })));
         it.effect("delayed jobs still promote to waiting while their queue is paused", () => withStore((store) => Effect.gen(function* () {
             const { id } = yield* store.enqueue(baseRequest({ delayMs: 1_000 }));
             yield* store.pause(QueueName("default"));