effect-mq 0.2.0 → 0.3.0

package/dist/redis/scripts.js

@@ -21,11 +21,13 @@
  * - `p:delayed:<queue>`         ZSET, score `runAt`
  * - `p:active`                  ZSET, score `lockExpiresAt`
  * - `p:all`                     ZSET, score `enqueuedAt` (list pagination)
- * - `p:finished`                ZSET, score `finishedAt` (history TTL)
+ * - `p:finished:<state>`        ZSET, score `finishedAt` (history TTL)
  * - `p:terminal:<name>:<state>` ZSET, score `finishedAt` (keep pruning)
  * - `p:counts`                  HASH `<queue>|<state>` -> integer
  * - `p:paused`                  SET of paused queues
  * - `p:schedules` / `p:schedule:<key>`  ZSET by nextRunAt + HASH per record
+ * - `p:dedupe:<name>\0<key>`   HASH {jobId, expiresAt} + `p:dedupes` index
+ *                               ZSET (score = window expiry, +inf = pending)
  *
  * @since 0.2.0
  */
@@ -77,7 +79,7 @@ local function deleteJob(id)
   local name = redis.call("HGET", jk, "name")
   countsAdd(queue, state, -1)
   redis.call("ZREM", prefix .. ":all", id)
-  redis.call("ZREM", prefix .. ":finished", id)
+  redis.call("ZREM", prefix .. ":finished:" .. state, id)
   redis.call("ZREM", prefix .. ":active", id)
   redis.call("ZREM", terminalKey(name, state), id)
   remWaiting(queue, id)
@@ -89,8 +91,20 @@ end
 -- zset score alone cannot carry the seq tie-break exactly.
 local function applyKeep(name, state, keepJson, now)
   if keepJson == nil or keepJson == "" then return end
-  local ok, keep = pcall(cjson.decode, keepJson)
-  if not ok or type(keep) ~= "table" then return end
+  local ok, decoded = pcall(cjson.decode, keepJson)
+  if not ok or type(decoded) ~= "table" then return end
+  -- Policies are split per terminal state; rows persisted by 0.2.x carry the
+  -- flat {count, ageMs} shape and apply to every state.
+  local keep = decoded[state]
+  if type(keep) ~= "table" then
+    if decoded.completed == nil and decoded.failed == nil and decoded.cancelled == nil
+      and (decoded.count ~= nil or decoded.ageMs ~= nil)
+    then
+      keep = decoded
+    else
+      return
+    end
+  end
   local tkey = terminalKey(name, state)
   if keep.ageMs ~= nil then
     local old = redis.call("ZRANGEBYSCORE", tkey, "-inf", now - keep.ageMs)
@@ -116,6 +130,20 @@ local function applyKeep(name, state, keepJson, now)
     for i = count + 1, #arr do deleteJob(arr[i].id) end
   end
 end
+local function dedupeStoreKey(name, key) return prefix .. ":dedupe:" .. name .. "\0" .. key end
+-- A job leaving the pending states frees its pending-mode dedup entry; live
+-- throttle windows deliberately outlast the job.
+local function releaseDedupe(name, dkey, jobId, now)
+  if dkey == nil or dkey == false or dkey == "" then return end
+  local sk = dedupeStoreKey(name, dkey)
+  if redis.call("HGET", sk, "jobId") == jobId then
+    local exp = redis.call("HGET", sk, "expiresAt")
+    if exp == "" or tonumber(exp) <= now then
+      redis.call("DEL", sk)
+      redis.call("ZREM", prefix .. ":dedupes", name .. "\0" .. dkey)
+    end
+  end
+end
 -- Move an active job (whose lock bookkeeping was already cleared by the
 -- caller) to the terminal cancelled state.
 local function finishCancelled(id, queue, name, startedAt, now, nowStr)
@@ -124,9 +152,10 @@ local function finishCancelled(id, queue, name, startedAt, now, nowStr)
     "lockToken", "", "lockExpiresAt", "")
   countsAdd(queue, "active", -1)
   countsAdd(queue, "cancelled", 1)
-  redis.call("ZADD", prefix .. ":finished", now, id)
+  redis.call("ZADD", prefix .. ":finished:cancelled", now, id)
   redis.call("ZADD", terminalKey(name, "cancelled"), now, id)
   appendAttempt(id, "cancelled", startedAt, nowStr, "")
+  releaseDedupe(name, redis.call("HGET", jk, "dedupeKey"), id, now)
   applyKeep(name, "cancelled", redis.call("HGET", jk, "keep"), now)
 end
 `;
@@ -136,7 +165,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) => [
+export const enqueue = Redis.script((prefix, idMode, id, name, queue, payloadJson, metadataJson, priority, attemptsMax, backoffJson, keepJson, timeoutMs, delayMs, now, dedupeKey, dedupeTtlMs, dedupeExtend, dedupeReplace) => [
     prefix,
     idMode,
     id,
@@ -150,7 +179,11 @@ export const enqueue = Redis.script((prefix, idMode, id, name, queue, payloadJso
     keepJson,
     timeoutMs,
     delayMs,
-    now
+    now,
+    dedupeKey,
+    dedupeTtlMs,
+    dedupeExtend,
+    dedupeReplace
 ], {
     numberOfKeys: 0,
     lua: `${HELPERS}
@@ -164,7 +197,54 @@ if idMode == "user" or idMode == "generated" then
     if idMode == "user" then return '{"duplicate":true,"id":' .. cjson.encode(id) .. '}' end
     return '{"collision":true}'
   end
-else
+end
+-- Dedup decision tree: replace-while-delayed, throttle window, pending dedup.
+local dKey = ARGV[15]
+local name = ARGV[4]
+if dKey ~= "" then
+  local sk = dedupeStoreKey(name, dKey)
+  local entryJob = redis.call("HGET", sk, "jobId")
+  if entryJob then
+    local expStr = redis.call("HGET", sk, "expiresAt")
+    local windowLive = expStr ~= "" and tonumber(expStr) > now
+    local keyedState = redis.call("HGET", jobKey(entryJob), "state")
+    local function bumpWindow()
+      if ARGV[17] == "1" and ARGV[16] ~= "" then
+        local windowEnd = now + tonumber(ARGV[16])
+        redis.call("HSET", sk, "expiresAt", fmt(windowEnd))
+        redis.call("ZADD", prefix .. ":dedupes", windowEnd, name .. "\0" .. dKey)
+      end
+    end
+    -- Latest-wins while the keyed job is still delayed.
+    if ARGV[18] == "1" and keyedState == "delayed" then
+      local kjk = jobKey(entryJob)
+      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))
+      local keyedQueue = redis.call("HGET", kjk, "queue")
+      redis.call("ZADD", delayedKey(keyedQueue), newRunAt, entryJob)
+      -- A landed replace re-arms the ttl window.
+      if ARGV[16] ~= "" then
+        local windowEnd = now + tonumber(ARGV[16])
+        redis.call("HSET", sk, "expiresAt", fmt(windowEnd))
+        redis.call("ZADD", prefix .. ":dedupes", windowEnd, name .. "\0" .. dKey)
+      end
+      return '{"id":' .. cjson.encode(entryJob) .. ',"duplicate":true,"wake":true,"queue":' .. cjson.encode(keyedQueue) .. '}'
+    end
+    if windowLive then
+      bumpWindow()
+      return '{"id":' .. cjson.encode(entryJob) .. ',"duplicate":true}'
+    end
+    local pending = keyedState ~= false and keyedState ~= "completed"
+      and keyedState ~= "failed" and keyedState ~= "cancelled"
+    if expStr == "" and pending then
+      return '{"id":' .. cjson.encode(entryJob) .. ',"duplicate":true}'
+    end
+    -- Dead entry: the new job takes over the key below.
+  end
+end
+if idMode == "auto" then
   id = ""
   for i = 1, 5 do
     local candidate = "j-" .. fmt(redis.call("INCR", prefix .. ":seq"))
@@ -183,7 +263,7 @@ redis.call("HSET", jobKey(id),
   "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", "runAt", fmt(runAt), "enqueuedAt", nowStr,
+  "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)
@@ -193,6 +273,14 @@ else
   redis.call("ZADD", delayedKey(queue), runAt, id)
 end
 countsAdd(queue, state, 1)
+if dKey ~= "" then
+  local sk = dedupeStoreKey(name, dKey)
+  redis.call("DEL", sk)
+  redis.call("HSET", sk, "jobId", id,
+    "expiresAt", ARGV[16] == "" and "" or fmt(now + tonumber(ARGV[16])))
+  redis.call("ZADD", prefix .. ":dedupes",
+    ARGV[16] == "" and "inf" or tostring(now + tonumber(ARGV[16])), name .. "\0" .. dKey)
+end
 -- Wake on EVERY insert (delayed too): idle workers must re-claim to learn
 -- the new nextRunAt, exactly like the memory and Postgres drivers.
 return '{"id":' .. cjson.encode(id) .. ',"duplicate":false,"wake":true}'
@@ -313,9 +401,10 @@ local function finish(newState, storeExit, outcome, ledgerExit)
   if storeExit ~= nil then redis.call("HSET", jk, "exit", storeExit) end
   countsAdd(queue, "active", -1)
   countsAdd(queue, newState, 1)
-  redis.call("ZADD", prefix .. ":finished", now, id)
+  redis.call("ZADD", prefix .. ":finished:" .. newState, now, id)
   redis.call("ZADD", terminalKey(name, newState), now, id)
   appendAttempt(id, outcome, startedAt, nowStr, ledgerExit)
+  releaseDedupe(name, redis.call("HGET", jk, "dedupeKey"), id, now)
   applyKeep(name, newState, redis.call("HGET", jk, "keep"), now)
 end
 
@@ -342,7 +431,7 @@ else
   else
     redis.call("ZADD", delayedKey(queue), runAt, id)
   end
-  return '{"ok":true,"wake":true}'
+  return '{"ok":true,"wake":true,"queue":' .. cjson.encode(queue) .. '}'
 end
 return '{"ok":true}'
 `
@@ -374,7 +463,7 @@ redis.call("HSET", jk, "state", "waiting", "lockToken", "", "lockExpiresAt", "")
 addWaiting(queue, priority, seq, id)
 countsAdd(queue, "active", -1)
 countsAdd(queue, "waiting", 1)
-return '{"ok":true,"wake":true}'
+return '{"ok":true,"wake":true,"queue":' .. cjson.encode(queue) .. '}'
 `
 }).withReturnType();
 /**
@@ -432,8 +521,9 @@ for _, id in ipairs(expired) do
           "failedReason", "job stalled more than allowable limit")
         countsAdd(queue, "active", -1)
         countsAdd(queue, "failed", 1)
-        redis.call("ZADD", prefix .. ":finished", now, id)
+        redis.call("ZADD", prefix .. ":finished:failed", now, id)
         redis.call("ZADD", terminalKey(name, "failed"), now, id)
+        releaseDedupe(name, redis.call("HGET", jk, "dedupeKey"), id, now)
         recovered[#recovered + 1] = { id = id, failed = true }
       else
         local seq = tonumber(redis.call("HGET", jk, "seq")) or 0
@@ -571,13 +661,13 @@ local seq = redis.call("INCR", prefix .. ":seq")
 redis.call("HSET", jk, "state", "waiting", "attemptsMade", "0", "stalledCount", "0",
   "cancelRequested", "0", "exit", "", "failedReason", "", "finishedAt", "",
   "processedAt", "", "runAt", nowStr, "seq", fmt(seq))
-redis.call("ZREM", prefix .. ":finished", id)
+redis.call("ZREM", prefix .. ":finished:failed", id)
 redis.call("ZREM", terminalKey(name, "failed"), id)
 local priority = tonumber(redis.call("HGET", jk, "priority")) or 0
 addWaiting(queue, priority, seq, id)
 countsAdd(queue, "failed", -1)
 countsAdd(queue, "waiting", 1)
-return '{"ok":true}'
+return '{"ok":true,"queue":' .. cjson.encode(queue) .. '}'
 `
 }).withReturnType();
 /**
@@ -607,9 +697,10 @@ redis.call("ZREM", delayedKey(queue), id)
 redis.call("HSET", jk, "state", "cancelled", "finishedAt", nowStr, "cancelRequested", "0")
 countsAdd(queue, state, -1)
 countsAdd(queue, "cancelled", 1)
-redis.call("ZADD", prefix .. ":finished", now, id)
+redis.call("ZADD", prefix .. ":finished:cancelled", now, id)
 redis.call("ZADD", terminalKey(name, "cancelled"), now, id)
 appendAttempt(id, "cancelled", redis.call("HGET", jk, "processedAt"), nowStr, "")
+releaseDedupe(name, redis.call("HGET", jk, "dedupeKey"), id, now)
 applyKeep(name, "cancelled", redis.call("HGET", jk, "keep"), now)
 return '{"ok":true}'
 `
@@ -631,7 +722,7 @@ redis.call("HSET", jk, "state", "waiting", "runAt", ARGV[3])
 addWaiting(queue, priority, seq, id)
 countsAdd(queue, "delayed", -1)
 countsAdd(queue, "waiting", 1)
-return '{"ok":true}'
+return '{"ok":true,"queue":' .. cjson.encode(queue) .. '}'
 `
 }).withReturnType();
 /**
@@ -741,15 +832,109 @@ return "1"
 `
 }).withReturnType();
 /**
- * sweepHistory(prefix, cutoff, limit) -> number swept (bounded batch; the
- * caller loops until 0).
+ * sweepState(prefix, state, ttlMs, limit, offset, now) -> {scanned, deleted}
+ * One bounded page over a terminal state's finished zset, deleting rows past
+ * min(store ceiling, per-row keep.age). The caller advances the offset by
+ * (scanned - deleted) and stops when a page comes back short.
  */
-export const sweepHistory = Redis.script((prefix, cutoff, limit) => [prefix, cutoff, limit], {
+export const sweepState = Redis.script((prefix, state, ttlMs, limit, offset, now) => [
+    prefix,
+    state,
+    ttlMs,
+    limit,
+    offset,
+    now
+], {
+    numberOfKeys: 0,
+    lua: `${HELPERS}
+local state = ARGV[2]
+local ttl = ARGV[3] ~= "" and tonumber(ARGV[3]) or nil
+local limit = tonumber(ARGV[4])
+local offset = tonumber(ARGV[5])
+local now = tonumber(ARGV[6])
+local batch = redis.call("ZRANGEBYSCORE", prefix .. ":finished:" .. state, "-inf", now,
+  "WITHSCORES", "LIMIT", offset, limit)
+local scanned = 0
+local deleted = 0
+for i = 1, #batch, 2 do
+  scanned = scanned + 1
+  local id = batch[i]
+  local finishedAt = tonumber(batch[i + 1])
+  if redis.call("EXISTS", jobKey(id)) == 0 then
+    -- Orphaned member (hash evicted/removed out of band): self-heal so the
+    -- cursor math stays honest and the member never loops the sweep.
+    redis.call("ZREM", prefix .. ":finished:" .. state, id)
+    deleted = deleted + 1
+  else
+    local cutoffAge = ttl
+    local keepJson = redis.call("HGET", jobKey(id), "keep")
+    if keepJson and keepJson ~= "" then
+      local ok, keep = pcall(cjson.decode, keepJson)
+      if ok and type(keep) == "table" then
+        local policy = keep[state]
+        if type(policy) ~= "table"
+          and keep.completed == nil and keep.failed == nil and keep.cancelled == nil
+          and (keep.count ~= nil or keep.ageMs ~= nil)
+        then
+          policy = keep
+        end
+        if type(policy) == "table" and policy.ageMs ~= nil then
+          local age = tonumber(policy.ageMs)
+          if age ~= nil and (cutoffAge == nil or age < cutoffAge) then cutoffAge = age end
+        end
+      end
+    end
+    if cutoffAge ~= nil and finishedAt <= now - cutoffAge then
+      deleteJob(id)
+      deleted = deleted + 1
+    end
+  end
+end
+return cjson.encode({ scanned = scanned, deleted = deleted })
+`
+}).withReturnType();
+/**
+ * sweepDedupes(prefix, limit, now) -> number pruned (bounded batch; the
+ * caller loops until 0): expired windows, then pending pointers (+inf)
+ * whose job is gone or terminal.
+ */
+export const sweepDedupes = Redis.script((prefix, limit, now) => [prefix, limit, now], {
     numberOfKeys: 0,
     lua: `${HELPERS}
-local old = redis.call("ZRANGEBYSCORE", prefix .. ":finished", "-inf", tonumber(ARGV[2]), "LIMIT", 0, tonumber(ARGV[3]))
-for _, id in ipairs(old) do deleteJob(id) end
-return tostring(#old)
+local limit = tonumber(ARGV[2])
+local now = tonumber(ARGV[3])
+-- Lazy migration: drain the pre-0.3 unsplit finished zset into the per-state
+-- keys (or drop orphans) so old history keeps getting swept.
+local migrated = 0
+local legacy = redis.call("ZRANGE", prefix .. ":finished", 0, limit - 1, "WITHSCORES")
+for i = 1, #legacy, 2 do
+  local id = legacy[i]
+  local state = redis.call("HGET", jobKey(id), "state")
+  if state == "completed" or state == "failed" or state == "cancelled" then
+    redis.call("ZADD", prefix .. ":finished:" .. state, tonumber(legacy[i + 1]), id)
+  end
+  redis.call("ZREM", prefix .. ":finished", id)
+  migrated = migrated + 1
+end
+local index = prefix .. ":dedupes"
+local expired = redis.call("ZRANGEBYSCORE", index, "-inf", now, "LIMIT", 0, limit)
+for _, member in ipairs(expired) do
+  redis.call("DEL", prefix .. ":dedupe:" .. member)
+  redis.call("ZREM", index, member)
+end
+local removedPending = 0
+local pendings = redis.call("ZRANGEBYSCORE", index, "inf", "inf", "LIMIT", 0, limit)
+for _, member in ipairs(pendings) do
+  local sk = prefix .. ":dedupe:" .. member
+  local jobId = redis.call("HGET", sk, "jobId")
+  local state = jobId and redis.call("HGET", jobKey(jobId), "state")
+  if not state or state == "completed" or state == "failed" or state == "cancelled" then
+    redis.call("DEL", sk)
+    redis.call("ZREM", index, member)
+    removedPending = removedPending + 1
+  end
+end
+return tostring(migrated + #expired + removedPending)
 `
 }).withReturnType();
 //# sourceMappingURL=scripts.js.map

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;AAgChE;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,SACxB,MAAM,cACA,MAAM,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAC/C,IAm/BF,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;AAiChE;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,SACxB,MAAM,cACA,MAAM,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAC/C,IAiuCF,CAAA"}

package/dist/testing/conformance.js

@@ -32,6 +32,7 @@ const baseRequest = (overrides) => ({
     backoff: undefined,
     keep: undefined,
     timeoutMs: undefined,
+    dedupe: undefined,
     delayMs: 0,
     ...overrides
 });
@@ -319,7 +320,7 @@ export const jobStoreConformance = (name, storeLayer) => {
         })));
         it.effect("keep count prunes older terminal records of the same name and state", () => withStore((store) => Effect.gen(function* () {
             for (let i = 0; i < 4; i++) {
-                const { id } = yield* store.enqueue(baseRequest({ payload: { n: i }, keep: { count: 2, ageMs: undefined } }));
+                const { id } = yield* store.enqueue(baseRequest({ payload: { n: i }, keep: { completed: { count: 2, ageMs: undefined } } }));
                 const claim = yield* store.claim(claimOptions({ token: `t-${i}` }));
                 assert(claim._tag === "Claimed");
                 yield* store.ack(id, `t-${i}`, { _tag: "Complete", exit: null });
@@ -330,7 +331,7 @@ export const jobStoreConformance = (name, storeLayer) => {
             expect(listed.items.map((job) => job.payload)).toEqual([{ n: 3 }, { n: 2 }]);
         })));
         it.effect("keep age prunes terminal records older than the window", () => withStore((store) => Effect.gen(function* () {
-            const keep = { count: undefined, ageMs: 10_000 };
+            const keep = { completed: { count: undefined, ageMs: 10_000 } };
             const first = yield* store.enqueue(baseRequest({ payload: { n: 1 }, keep }));
             const claim1 = yield* store.claim(claimOptions());
             assert(claim1._tag === "Claimed");
@@ -370,8 +371,8 @@ export const jobStoreConformance = (name, storeLayer) => {
         it.effect("keep count ties on finishedAt keep the most recently acked records", () => withStore((store) => Effect.gen(function* () {
             // Two jobs acked at the SAME TestClock instant: the tie must break
             // on enqueue/seq order identically in every driver.
-            const first = yield* store.enqueue(baseRequest({ payload: { n: 1 }, keep: { count: 1, ageMs: undefined } }));
-            const second = yield* store.enqueue(baseRequest({ payload: { n: 2 }, keep: { count: 1, ageMs: undefined } }));
+            const first = yield* store.enqueue(baseRequest({ payload: { n: 1 }, keep: { completed: { count: 1, ageMs: undefined } } }));
+            const second = yield* store.enqueue(baseRequest({ payload: { n: 2 }, keep: { completed: { count: 1, ageMs: undefined } } }));
             const claimA = yield* store.claim(claimOptions({ token: "t-a" }));
             const claimB = yield* store.claim(claimOptions({ token: "t-b" }));
             assert(claimA._tag === "Claimed" && claimB._tag === "Claimed");
@@ -381,7 +382,7 @@ export const jobStoreConformance = (name, storeLayer) => {
             expect(Option.isSome(yield* store.getJob(second.id))).toBe(true);
         })));
         it.effect("keep applies count and age together", () => withStore((store) => Effect.gen(function* () {
-            const keep = { count: 2, ageMs: 10_000 };
+            const keep = { completed: { count: 2, ageMs: 10_000 } };
             const ids = [];
             for (let i = 0; i < 3; i++) {
                 const { id } = yield* store.enqueue(baseRequest({ payload: { n: i }, keep }));
@@ -626,7 +627,7 @@ export const jobStoreConformance = (name, storeLayer) => {
             expect(job.value.cancelRequested).toBe(true);
         })));
         it.effect("cancel applies the keep retention policy", () => withStore((store) => Effect.gen(function* () {
-            const keep = { count: 1 };
+            const keep = { cancelled: { count: 1 } };
             const ids = [];
             for (let i = 0; i < 3; i++) {
                 const { id } = yield* store.enqueue(baseRequest({ payload: { n: i }, keep }));
@@ -711,7 +712,7 @@ export const jobStoreConformance = (name, storeLayer) => {
         it.effect("counts stay consistent across cancel, retry, keep pruning, and remove", () => withStore((store) => Effect.gen(function* () {
             // Three completions with keep {count: 1}: two get pruned.
             for (let i = 0; i < 3; i++) {
-                const { id } = yield* store.enqueue(baseRequest({ payload: { n: i }, keep: { count: 1 } }));
+                const { id } = yield* store.enqueue(baseRequest({ payload: { n: i }, keep: { completed: { count: 1 } } }));
                 const claim = yield* store.claim(claimOptions({ token: `t-${i}` }));
                 assert(claim._tag === "Claimed");
                 yield* store.ack(id, `t-${i}`, { _tag: "Complete", exit: undefined });
@@ -765,6 +766,170 @@ export const jobStoreConformance = (name, storeLayer) => {
             const stored = (yield* store.listSchedules())[0];
             expect(stored?.payload).toEqual(payload);
         })));
+        it.effect("dedupe never changes the job id, and keys are scoped per name", () => withStore((store) => Effect.gen(function* () {
+            const dedupe = { key: "emp-1", ttlMs: undefined, extend: false, replace: false };
+            const first = yield* store.enqueue(baseRequest({ id: JobId("my-ulid-1"), dedupe }));
+            expect(first).toEqual({ id: "my-ulid-1", duplicate: false });
+            const job = yield* store.getJob(first.id);
+            assert(Option.isSome(job));
+            expect(job.value.dedupeKey).toBe("emp-1");
+            // Same key, same name: deduplicated to the FIRST job's id.
+            const second = yield* store.enqueue(baseRequest({ id: JobId("my-ulid-2"), dedupe }));
+            expect(second).toEqual({ id: "my-ulid-1", duplicate: true });
+            expect(Option.isNone(yield* store.getJob(JobId("my-ulid-2")))).toBe(true);
+            // Same key, different name: no interference.
+            const other = yield* store.enqueue(baseRequest({ name: "OtherJob", dedupe }));
+            expect(other.duplicate).toBe(false);
+        })));
+        it.effect("pending dedupe holds while the keyed job is unfinished and frees on completion", () => withStore((store) => Effect.gen(function* () {
+            const dedupe = { key: "k", ttlMs: undefined, extend: false, replace: false };
+            const first = yield* store.enqueue(baseRequest({ dedupe }));
+            expect((yield* store.enqueue(baseRequest({ dedupe }))).duplicate).toBe(true);
+            // Still deduped while active.
+            const claim = yield* store.claim(claimOptions());
+            assert(claim._tag === "Claimed");
+            expect((yield* store.enqueue(baseRequest({ dedupe }))).duplicate).toBe(true);
+            // A terminal ack frees the key immediately.
+            yield* store.ack(first.id, "t-1", { _tag: "Complete", exit: undefined });
+            const fresh = yield* store.enqueue(baseRequest({ dedupe }));
+            expect(fresh.duplicate).toBe(false);
+            expect(fresh.id).not.toBe(first.id);
+        })));
+        it.effect("cancellation also frees a pending dedupe key", () => withStore((store) => Effect.gen(function* () {
+            const dedupe = { key: "k", ttlMs: undefined, extend: false, replace: false };
+            const first = yield* store.enqueue(baseRequest({ dedupe }));
+            yield* store.cancel(first.id);
+            expect((yield* store.enqueue(baseRequest({ dedupe }))).duplicate).toBe(false);
+        })));
+        it.effect("a ttl dedupe window throttles even past completion, then expires", () => withStore((store) => Effect.gen(function* () {
+            const dedupe = { key: "k", ttlMs: 60_000, extend: false, replace: false };
+            const first = yield* store.enqueue(baseRequest({ dedupe }));
+            const claim = yield* store.claim(claimOptions());
+            assert(claim._tag === "Claimed");
+            yield* store.ack(first.id, "t-1", { _tag: "Complete", exit: undefined });
+            // Completed, but the window still throttles...
+            yield* TestClock.adjust(30_000);
+            expect((yield* store.enqueue(baseRequest({ dedupe }))).duplicate).toBe(true);
+            // ...and a plain (non-extend) window is NOT pushed out by drops.
+            yield* TestClock.adjust(30_000);
+            const fresh = yield* store.enqueue(baseRequest({ dedupe }));
+            expect(fresh.duplicate).toBe(false);
+            expect(fresh.id).not.toBe(first.id);
+        })));
+        it.effect("an extend dedupe window is pushed out by each deduplicated enqueue", () => withStore((store) => Effect.gen(function* () {
+            const dedupe = { key: "k", ttlMs: 60_000, extend: true, replace: false };
+            yield* store.enqueue(baseRequest({ dedupe }));
+            yield* TestClock.adjust(45_000);
+            expect((yield* store.enqueue(baseRequest({ dedupe }))).duplicate).toBe(true);
+            // 75s after the FIRST enqueue — past the original window, inside
+            // the extended one.
+            yield* TestClock.adjust(30_000);
+            expect((yield* store.enqueue(baseRequest({ dedupe }))).duplicate).toBe(true);
+            // Past the latest extension: free again.
+            yield* TestClock.adjust(60_001);
+            expect((yield* store.enqueue(baseRequest({ dedupe }))).duplicate).toBe(false);
+        })));
+        it.effect("replace dedupe rewrites a still-delayed job in place, latest content wins", () => withStore((store) => Effect.gen(function* () {
+            const dedupe = { key: "k", ttlMs: undefined, extend: false, replace: true };
+            const first = yield* store.enqueue(baseRequest({ dedupe, payload: { n: 1 }, priority: 1, delayMs: 60_000 }));
+            const replaced = yield* store.enqueue(baseRequest({ dedupe, payload: { n: 2 }, priority: 7, delayMs: 5_000 }));
+            expect(replaced).toEqual({ id: first.id, duplicate: true });
+            const job = yield* store.getJob(first.id);
+            assert(Option.isSome(job));
+            expect(job.value.payload).toEqual({ n: 2 });
+            expect(job.value.priority).toBe(7);
+            expect(job.value.state).toBe("delayed");
+            // The rewritten delay is live: due after 5s, not the original 60s.
+            yield* TestClock.adjust(5_000);
+            const claim = yield* store.claim(claimOptions());
+            assert(claim._tag === "Claimed");
+            expect(claim.job.id).toBe(first.id);
+            expect(claim.job.payload).toEqual({ n: 2 });
+            // Once claimed (active), replace degrades to plain dedup.
+            const during = yield* store.enqueue(baseRequest({ dedupe, payload: { n: 3 } }));
+            expect(during).toEqual({ id: first.id, duplicate: true });
+            const active = yield* store.getJob(first.id);
+            assert(Option.isSome(active));
+            expect(active.value.payload).toEqual({ n: 2 });
+        })));
+        it.effect("an existing explicit id wins over the dedup tree in every driver", () => withStore((store) => Effect.gen(function* () {
+            const key = { key: "k", ttlMs: undefined, extend: false, replace: false };
+            // X runs under key k and completes, freeing the key but staying in
+            // history.
+            const x = yield* store.enqueue(baseRequest({ id: JobId("X"), dedupe: key }));
+            const claim = yield* store.claim(claimOptions());
+            assert(claim._tag === "Claimed");
+            yield* store.ack(x.id, "t-1", { _tag: "Complete", exit: undefined });
+            // J takes over the key, delayed.
+            const j = yield* store.enqueue(baseRequest({ dedupe: key, payload: { n: 9 }, delayMs: 60_000 }));
+            // A retried enqueue of X (id exists) must return X untouched — the
+            // id check precedes the dedup tree, so J is neither returned nor
+            // replaced.
+            const retried = yield* store.enqueue(baseRequest({
+                id: JobId("X"),
+                payload: { n: 1 },
+                dedupe: { ...key, replace: true }
+            }));
+            expect(retried).toEqual({ id: "X", duplicate: true });
+            const job = yield* store.getJob(j.id);
+            assert(Option.isSome(job));
+            expect(job.value.payload).toEqual({ n: 9 });
+            expect(job.value.state).toBe("delayed");
+        })));
+        it.effect("a landed replace re-arms the ttl window", () => withStore((store) => Effect.gen(function* () {
+            const dedupe = { key: "k", ttlMs: 60_000, extend: false, replace: true };
+            const first = yield* store.enqueue(baseRequest({ dedupe, delayMs: 300_000 }));
+            // 50s in: replace lands; the window restarts from here.
+            yield* TestClock.adjust(50_000);
+            const replaced = yield* store.enqueue(baseRequest({ dedupe, payload: { n: 2 }, delayMs: 300_000 }));
+            expect(replaced).toEqual({ id: first.id, duplicate: true });
+            // 100s after the FIRST enqueue — past the original window, inside
+            // the re-armed one: still the same job.
+            yield* TestClock.adjust(50_000);
+            const again = yield* store.enqueue(baseRequest({ dedupe, payload: { n: 3 }, delayMs: 300_000 }));
+            expect(again).toEqual({ id: first.id, duplicate: true });
+        })));
+        it.effect("keep policies are independent per terminal state", () => withStore((store) => Effect.gen(function* () {
+            // Completed records keep only the newest 1; failed keep everything.
+            const keep = { completed: { count: 1 } };
+            const completed = [];
+            const failed = [];
+            for (let i = 0; i < 2; i++) {
+                const done = yield* store.enqueue(baseRequest({ payload: { n: i }, keep }));
+                const claimA = yield* store.claim(claimOptions({ token: `tc-${i}` }));
+                assert(claimA._tag === "Claimed");
+                yield* store.ack(done.id, `tc-${i}`, { _tag: "Complete", exit: undefined });
+                completed.push(done.id);
+                const bad = yield* store.enqueue(baseRequest({ payload: { n: 10 + i }, keep }));
+                const claimB = yield* store.claim(claimOptions({ token: `tf-${i}` }));
+                assert(claimB._tag === "Claimed");
+                yield* store.ack(bad.id, `tf-${i}`, { _tag: "Fail", exit: undefined });
+                failed.push(bad.id);
+                yield* TestClock.adjust(10);
+            }
+            const counts = yield* store.counts();
+            expect(counts.completed).toBe(1);
+            expect(counts.failed).toBe(2);
+            expect(Option.isNone(yield* store.getJob(completed[0] ?? JobId("?")))).toBe(true);
+            expect(Option.isSome(yield* store.getJob(failed[0] ?? JobId("?")))).toBe(true);
+        })));
+        it.effect("an enqueue wakes only waiters watching its queue", () => withStore((store) => Effect.gen(function* () {
+            const empty = yield* store.claim(claimOptions());
+            assert(empty._tag === "Empty");
+            let woke = false;
+            const waiter = yield* Effect.forkChild(store.awaitWake([QueueName("default")], empty.wakeToken).pipe(Effect.tap(() => Effect.sync(() => void (woke = true)))));
+            yield* Effect.yieldNow;
+            // Work on ANOTHER queue must not wake the default-queue waiter.
+            yield* store.enqueue(baseRequest({ queue: QueueName("other") }));
+            for (let i = 0; i < 10; i++) {
+                yield* Effect.yieldNow;
+            }
+            expect(woke).toBe(false);
+            // Matching-queue work does.
+            yield* store.enqueue(baseRequest());
+            yield* Fiber.join(waiter);
+            expect(woke).toBe(true);
+        })));
         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"));