bullmq 6.3.5 → 6.3.7

package/dist/cjs/classes/bun-redis-client.js

@@ -218,11 +218,11 @@ class BunRedisAdapter extends events_1.EventEmitter {
     async connect() {
         var _a, _b;
         // A duplicate created with a `rawFactory` builds its raw client lazily on
-        // the first connect (Bun's native `duplicate()` is async).
-        if (!this.raw && this.rawFactory) {
-            this.raw = await this.rawFactory();
-            this.rawFactory = undefined;
-            this._setupCallbacks();
+        // the first connect (Bun's native `duplicate()` is async). Concurrent
+        // connect()/_ensureRaw() share one in-flight materialization so we don't
+        // create two native clients and overwrite an unclosed raw.
+        if (!this.raw && (this.rawFactory || this.materializing)) {
+            await this._materializeRaw();
         }
         const replaceRaw = this.hasConnected && (this.closed || !this.raw.connected);
         if (this.reconnectTimer) {
@@ -394,6 +394,36 @@ class BunRedisAdapter extends events_1.EventEmitter {
         const Ctor = src.constructor;
         return new Ctor(src.url);
     }
+    /**
+     * Materialize a lazily-created raw client (duplicate `rawFactory`).
+     * Concurrent callers share the in-flight promise so the factory runs once.
+     */
+    _materializeRaw() {
+        if (this.raw) {
+            return Promise.resolve(this.raw);
+        }
+        if (this.materializing) {
+            return this.materializing;
+        }
+        const factory = this.rawFactory;
+        if (!factory) {
+            return Promise.resolve(this.raw);
+        }
+        const materializing = factory()
+            .then(raw => {
+            this.raw = raw;
+            this.rawFactory = undefined;
+            this._setupCallbacks();
+            return raw;
+        })
+            .finally(() => {
+            if (this.materializing === materializing) {
+                this.materializing = undefined;
+            }
+        });
+        this.materializing = materializing;
+        return materializing;
+    }
     /**
      * Return the raw client, materializing it first when this adapter is a
      * lazily-initialized duplicate (created via `duplicate()` with a
@@ -413,9 +443,13 @@ class BunRedisAdapter extends events_1.EventEmitter {
         // on first connect. Rebuilding from `this.raw.url` is not possible because
         // Bun never exposes the URL, which previously sent duplicates to the
         // wrong (default) server (#4582).
-        const parentRaw = this.raw;
+        //
+        // Do not close over `this.raw`: a duplicate may not have materialized its
+        // raw client yet, so nested `duplicate().duplicate()` would capture
+        // undefined and throw in `_duplicateRaw` (#4706). Resolve the parent raw
+        // lazily, matching reconnect's fallback to `rawFactory`.
         const adapter = new BunRedisAdapter(undefined, {
-            rawFactory: () => this._duplicateRaw(parentRaw),
+            rawFactory: async () => this._duplicateRaw(await this._ensureRaw()),
         });
         // Copy registered scripts to the duplicate
         for (const [name, script] of this.scripts) {

package/dist/cjs/commands/includes/deduplicateJob.lua

@@ -3,6 +3,7 @@
 ]]
 -- Includes
 --- @include "deduplicateJobWithoutReplace"
+--- @include "recoverStaleDeduplicationKey"
 --- @include "removeJobKeys"
 --- @include "setDeduplicationKey"
 --- @include "storeDeduplicatedNextJob"
@@ -33,6 +34,11 @@ local function deduplicateJob(deduplicationOpts, jobId, delayedKey, deduplicatio
                 local isRemoved = removeDelayedJob(delayedKey, deduplicationKey, eventsKey, maxEvents,
                     currentDeduplicatedJobId, jobId, deduplicationId, prefix)
                 if isRemoved then
+                    -- Discard any pending next-job payload stored while the replaced
+                    -- job was active, otherwise it would be resurrected when the
+                    -- incoming job finalizes.
+                    rcall('DEL', prefix .. "dn:" .. deduplicationId)
+
                     if deduplicationOpts['keepLastIfActive'] then
                         rcall('SET', deduplicationKey, jobId)
                     else
@@ -45,6 +51,11 @@ local function deduplicateJob(deduplicationOpts, jobId, delayedKey, deduplicatio
                     end
                     return
                 else
+                    if recoverStaleDeduplicationKey(deduplicationKey, prefix, currentDeduplicatedJobId,
+                        jobId, deduplicationId, deduplicationOpts) then
+                        return
+                    end
+
                     storeDeduplicatedNextJob(deduplicationOpts, currentDeduplicatedJobId, prefix,
                         deduplicationId, jobName, jobData, fullOpts, eventsKey, maxEvents, jobId,
                         parentKey, parentData, parentDependenciesKey, repeatJobKey)

package/dist/cjs/commands/includes/deduplicateJobWithoutReplace.lua

@@ -1,6 +1,7 @@
 --[[
   Function to deduplicate a job.
 ]]
+--- @include "recoverStaleDeduplicationKey"
 --- @include "setDeduplicationKey"
 --- @include "storeDeduplicatedNextJob"
 
@@ -9,10 +10,15 @@ local function deduplicateJobWithoutReplace(deduplicationId, deduplicationOpts,
     parentKey, parentData, parentDependenciesKey, repeatJobKey)
     local ttl = deduplicationOpts['ttl']
     local deduplicationKeyExists
+
     if ttl and ttl > 0 then
         if deduplicationOpts['extend'] then
             local currentDeduplicatedJobId = rcall('GET', deduplicationKey)
             if currentDeduplicatedJobId then
+                if recoverStaleDeduplicationKey(deduplicationKey, prefix, currentDeduplicatedJobId,
+                    jobId, deduplicationId, deduplicationOpts) then
+                    return
+                end
                 if storeDeduplicatedNextJob(deduplicationOpts, currentDeduplicatedJobId, prefix,
                     deduplicationId, jobName, jobData, fullOpts, eventsKey, maxEvents, jobId,
                     parentKey, parentData, parentDependenciesKey, repeatJobKey) then
@@ -48,6 +54,11 @@ local function deduplicateJobWithoutReplace(deduplicationId, deduplicationOpts,
     if deduplicationKeyExists then
         local currentDeduplicatedJobId = rcall('GET', deduplicationKey)
 
+        if recoverStaleDeduplicationKey(deduplicationKey, prefix, currentDeduplicatedJobId,
+            jobId, deduplicationId, deduplicationOpts) then
+            return
+        end
+
         if storeDeduplicatedNextJob(deduplicationOpts, currentDeduplicatedJobId, prefix,
             deduplicationId, jobName, jobData, fullOpts, eventsKey, maxEvents, jobId,
             parentKey, parentData, parentDependenciesKey, repeatJobKey) then

package/dist/cjs/commands/includes/recoverStaleDeduplicationKey.lua

@@ -0,0 +1,28 @@
+--[[
+  Function to recover a stale deduplication key.
+  When the existing deduplication key has no expiry (simple mode, or
+  keepLastIfActive after the key was persisted), it should disappear
+  when the winning job finishes. If that job key no longer exists
+  because of an outage, the deduplication key is stale, so we discard it
+  and start a new deduplication window with the incoming job.
+  Returns true if the stale key was recovered, false otherwise.
+]]
+--- @include "setDeduplicationKey"
+
+local function recoverStaleDeduplicationKey(deduplicationKey, prefix, currentDeduplicatedJobId, jobId,
+    deduplicationId, deduplicationOpts)
+    if currentDeduplicatedJobId and rcall('PTTL', deduplicationKey) == -1 and
+        rcall('EXISTS', prefix .. currentDeduplicatedJobId) == 0 then
+        rcall('DEL', deduplicationKey)
+        -- Discard any pending next-job payload stored for the stale winner,
+        -- otherwise it would be resurrected when this job finalizes.
+        rcall('DEL', prefix .. "dn:" .. deduplicationId)
+        if deduplicationOpts['keepLastIfActive'] then
+            rcall('SET', deduplicationKey, jobId)
+        else
+            setDeduplicationKey(deduplicationKey, jobId, deduplicationOpts)
+        end
+        return true
+    end
+    return false
+end

package/dist/cjs/postgres/migrations/0003_dedup_stale_key.sql

@@ -0,0 +1,147 @@
+-- BullMQ PostgreSQL backend — deduplication stale-key recovery.
+--
+-- Replaces `deduplicate_job` (created in 0002_functions.sql) to fix two ways a
+-- deduplication key could outlive the job it points at:
+--
+--   1. Stale key: a key with no expiry is meant to disappear when its winner
+--      finishes, but `clean`, `drain`, `obliterate` (and outages) delete the
+--      job row without clearing the `dedup` row. Every later add then matched
+--      that dead winner and was silently dropped, forever. Mirrors the Redis
+--      `recoverStaleDeduplicationKey` include.
+--   2. Orphaned proto-next: replacing a *delayed* winner left behind any
+--      `dedup_next` payload stashed while that winner was previously active,
+--      so it got resurrected when the replacement finished.
+--
+-- Only the function body changes — no schema/DDL change — so the signature is
+-- identical and older clients keep working against the updated schema.
+
+CREATE OR REPLACE FUNCTION deduplicate_job(
+  p_queue text, p_dedup jsonb, p_job_id text, p_now bigint,
+  p_name text, p_data jsonb, p_opts jsonb
+) RETURNS text
+LANGUAGE plpgsql
+SET search_path FROM CURRENT
+AS $$
+DECLARE
+  v_id       text    := p_dedup->>'id';
+  v_ttl      bigint  := NULLIF(p_dedup->>'ttl', '')::bigint;
+  v_extend   boolean := COALESCE((p_dedup->>'extend')::boolean, false);
+  v_replace  boolean := COALESCE((p_dedup->>'replace')::boolean, false);
+  v_keeplast boolean := COALESCE((p_dedup->>'keepLastIfActive')::boolean, false);
+  v_cur      text;
+  v_exp      bigint;
+  v_state    job_state;
+BEGIN
+  IF v_id IS NULL OR v_id = '' THEN
+    RETURN NULL;
+  END IF;
+
+  -- The current winner (only if the key is still live).
+  SELECT job_id, expire_at_ms INTO v_cur, v_exp
+    FROM dedup WHERE queue = p_queue AND dedup_id = v_id;
+  IF v_cur IS NULL OR (v_exp IS NOT NULL AND v_exp <= p_now) THEN
+    v_cur := NULL;
+  ELSIF v_exp IS NULL AND NOT EXISTS (
+    SELECT 1 FROM job WHERE queue = p_queue AND id = v_cur
+  ) THEN
+    -- Stale key recovery (mirrors recoverStaleDeduplicationKey): a key with no
+    -- expiry is meant to disappear when its winner finishes. If the job row is
+    -- gone (clean, drain, obliterate, an outage…) the key is stale, so discard
+    -- it together with any pending proto-next (which would otherwise be
+    -- resurrected) and start a new window with the incoming job.
+    DELETE FROM dedup WHERE queue = p_queue AND dedup_id = v_id;
+    DELETE FROM dedup_next WHERE queue = p_queue AND dedup_id = v_id;
+    v_cur := NULL;
+  END IF;
+
+  IF v_replace THEN
+    IF v_cur IS NOT NULL THEN
+      SELECT state INTO v_state
+        FROM job WHERE queue = p_queue AND id = v_cur;
+      IF v_state = 'delayed' THEN
+        -- Drop the previous delayed job and take its place.
+        DELETE FROM job WHERE queue = p_queue AND id = v_cur;
+        PERFORM publish_event(p_queue, 'removed',
+          jsonb_build_object('jobId', v_cur, 'prev', 'delayed'));
+        PERFORM publish_event(p_queue, 'deduplicated',
+          jsonb_build_object('jobId', p_job_id, 'deduplicationId', v_id,
+            'deduplicatedJobId', v_cur));
+        -- Discard any pending proto-next stashed while the replaced job was
+        -- active, otherwise it would be resurrected when p_job_id finalizes.
+        DELETE FROM dedup_next WHERE queue = p_queue AND dedup_id = v_id;
+        IF v_keeplast THEN
+          UPDATE dedup SET job_id = p_job_id, expire_at_ms = NULL
+           WHERE queue = p_queue AND dedup_id = v_id;
+        ELSIF NOT v_extend AND COALESCE(v_ttl, 0) > 0 THEN
+          -- KEEPTTL: keep the existing window, just swap the winner.
+          UPDATE dedup SET job_id = p_job_id
+           WHERE queue = p_queue AND dedup_id = v_id;
+        ELSE
+          UPDATE dedup
+             SET job_id = p_job_id,
+                 expire_at_ms = CASE WHEN COALESCE(v_ttl, 0) > 0
+                                     THEN p_now + v_ttl ELSE NULL END
+           WHERE queue = p_queue AND dedup_id = v_id;
+        END IF;
+        RETURN NULL;
+      ELSE
+        -- Winner is not a removable delayed job: stash proto-next if it is
+        -- active + keepLastIfActive, then deduplicate.
+        PERFORM dedup_store_next(p_queue, v_id, v_cur, p_job_id,
+          v_keeplast, p_name, p_data, p_opts);
+        RETURN v_cur;
+      END IF;
+    ELSE
+      INSERT INTO dedup (queue, dedup_id, job_id, expire_at_ms)
+        VALUES (p_queue, v_id, p_job_id,
+          CASE WHEN NOT v_keeplast AND COALESCE(v_ttl, 0) > 0
+               THEN p_now + v_ttl ELSE NULL END)
+      ON CONFLICT (queue, dedup_id) DO UPDATE
+        SET job_id = EXCLUDED.job_id, expire_at_ms = EXCLUDED.expire_at_ms;
+      RETURN NULL;
+    END IF;
+  END IF;
+
+  -- Without replace.
+  IF COALESCE(v_ttl, 0) > 0 AND v_extend THEN
+    IF v_cur IS NOT NULL THEN
+      -- Stash proto-next if active+keepLast; else extend the window (or
+      -- persist when keepLastIfActive). Either way keep the current winner.
+      IF NOT dedup_store_next(p_queue, v_id, v_cur, p_job_id,
+               v_keeplast, p_name, p_data, p_opts) THEN
+        UPDATE dedup
+           SET expire_at_ms = CASE WHEN v_keeplast THEN NULL ELSE p_now + v_ttl END
+         WHERE queue = p_queue AND dedup_id = v_id;
+      END IF;
+      PERFORM publish_event(p_queue, 'deduplicated',
+        jsonb_build_object('jobId', v_cur, 'deduplicationId', v_id,
+          'deduplicatedJobId', p_job_id));
+      RETURN v_cur;
+    END IF;
+    INSERT INTO dedup (queue, dedup_id, job_id, expire_at_ms)
+      VALUES (p_queue, v_id, p_job_id,
+        CASE WHEN v_keeplast THEN NULL ELSE p_now + v_ttl END)
+    ON CONFLICT (queue, dedup_id) DO UPDATE
+      SET job_id = EXCLUDED.job_id, expire_at_ms = EXCLUDED.expire_at_ms;
+    RETURN NULL;
+  END IF;
+
+  -- SET NX semantics (ttl>0 non-extend, or no ttl at all).
+  IF v_cur IS NOT NULL THEN
+    PERFORM dedup_store_next(p_queue, v_id, v_cur, p_job_id,
+      v_keeplast, p_name, p_data, p_opts);
+    PERFORM publish_event(p_queue, 'deduplicated',
+      jsonb_build_object('jobId', v_cur, 'deduplicationId', v_id,
+        'deduplicatedJobId', p_job_id));
+    RETURN v_cur;
+  END IF;
+
+  INSERT INTO dedup (queue, dedup_id, job_id, expire_at_ms)
+    VALUES (p_queue, v_id, p_job_id,
+      CASE WHEN NOT v_keeplast AND COALESCE(v_ttl, 0) > 0
+           THEN p_now + v_ttl ELSE NULL END)
+  ON CONFLICT (queue, dedup_id) DO UPDATE
+    SET job_id = EXCLUDED.job_id, expire_at_ms = EXCLUDED.expire_at_ms;
+  RETURN NULL;
+END;
+$$;

package/dist/cjs/postgres/migrations/index.js

@@ -21,6 +21,14 @@ exports.MIGRATIONS = [
         minClientVersion: 6,
         load: () => (0, sql_loader_1.loadMigrationSql)('0002_functions.sql'),
     },
+    {
+        version: 3,
+        name: '0003_dedup_stale_key',
+        // Function-body fix only (CREATE OR REPLACE, identical signature, no DDL),
+        // so clients from the same major keep working against the updated schema.
+        minClientVersion: 6,
+        load: () => (0, sql_loader_1.loadMigrationSql)('0003_dedup_stale_key.sql'),
+    },
 ];
 /**
  * The highest schema version this BullMQ build knows how to produce. Explicit

package/dist/cjs/scripts/addDelayedJob-6.js

@@ -118,6 +118,15 @@ end
 --[[
   Function to deduplicate a job.
 ]]
+--[[
+  Function to recover a stale deduplication key.
+  When the existing deduplication key has no expiry (simple mode, or
+  keepLastIfActive after the key was persisted), it should disappear
+  when the winning job finishes. If that job key no longer exists
+  because of an outage, the deduplication key is stale, so we discard it
+  and start a new deduplication window with the incoming job.
+  Returns true if the stale key was recovered, false otherwise.
+]]
 --[[
   Function to set the deduplication key for a job.
   Uses TTL from deduplication opts if provided.
@@ -130,6 +139,23 @@ local function setDeduplicationKey(deduplicationKey, jobId, deduplicationOpts)
         rcall('SET', deduplicationKey, jobId)
     end
 end
+local function recoverStaleDeduplicationKey(deduplicationKey, prefix, currentDeduplicatedJobId, jobId,
+    deduplicationId, deduplicationOpts)
+    if currentDeduplicatedJobId and rcall('PTTL', deduplicationKey) == -1 and
+        rcall('EXISTS', prefix .. currentDeduplicatedJobId) == 0 then
+        rcall('DEL', deduplicationKey)
+        -- Discard any pending next-job payload stored for the stale winner,
+        -- otherwise it would be resurrected when this job finalizes.
+        rcall('DEL', prefix .. "dn:" .. deduplicationId)
+        if deduplicationOpts['keepLastIfActive'] then
+            rcall('SET', deduplicationKey, jobId)
+        else
+            setDeduplicationKey(deduplicationKey, jobId, deduplicationOpts)
+        end
+        return true
+    end
+    return false
+end
 --[[
   Function to store a deduplicated next job if the existing job is active
   and keepLastIfActive is set. When the active job finishes, the stored
@@ -196,6 +222,10 @@ local function deduplicateJobWithoutReplace(deduplicationId, deduplicationOpts,
         if deduplicationOpts['extend'] then
             local currentDeduplicatedJobId = rcall('GET', deduplicationKey)
             if currentDeduplicatedJobId then
+                if recoverStaleDeduplicationKey(deduplicationKey, prefix, currentDeduplicatedJobId,
+                    jobId, deduplicationId, deduplicationOpts) then
+                    return
+                end
                 if storeDeduplicatedNextJob(deduplicationOpts, currentDeduplicatedJobId, prefix,
                     deduplicationId, jobName, jobData, fullOpts, eventsKey, maxEvents, jobId,
                     parentKey, parentData, parentDependenciesKey, repeatJobKey) then
@@ -229,6 +259,10 @@ local function deduplicateJobWithoutReplace(deduplicationId, deduplicationOpts,
     end
     if deduplicationKeyExists then
         local currentDeduplicatedJobId = rcall('GET', deduplicationKey)
+        if recoverStaleDeduplicationKey(deduplicationKey, prefix, currentDeduplicatedJobId,
+            jobId, deduplicationId, deduplicationOpts) then
+            return
+        end
         if storeDeduplicatedNextJob(deduplicationOpts, currentDeduplicatedJobId, prefix,
             deduplicationId, jobName, jobData, fullOpts, eventsKey, maxEvents, jobId,
             parentKey, parentData, parentDependenciesKey, repeatJobKey) then
@@ -268,6 +302,10 @@ local function deduplicateJob(deduplicationOpts, jobId, delayedKey, deduplicatio
                 local isRemoved = removeDelayedJob(delayedKey, deduplicationKey, eventsKey, maxEvents,
                     currentDeduplicatedJobId, jobId, deduplicationId, prefix)
                 if isRemoved then
+                    -- Discard any pending next-job payload stored while the replaced
+                    -- job was active, otherwise it would be resurrected when the
+                    -- incoming job finalizes.
+                    rcall('DEL', prefix .. "dn:" .. deduplicationId)
                     if deduplicationOpts['keepLastIfActive'] then
                         rcall('SET', deduplicationKey, jobId)
                     else
@@ -280,6 +318,10 @@ local function deduplicateJob(deduplicationOpts, jobId, delayedKey, deduplicatio
                     end
                     return
                 else
+                    if recoverStaleDeduplicationKey(deduplicationKey, prefix, currentDeduplicatedJobId,
+                        jobId, deduplicationId, deduplicationOpts) then
+                        return
+                    end
                     storeDeduplicatedNextJob(deduplicationOpts, currentDeduplicatedJobId, prefix,
                         deduplicationId, jobName, jobData, fullOpts, eventsKey, maxEvents, jobId,
                         parentKey, parentData, parentDependenciesKey, repeatJobKey)

package/dist/cjs/scripts/addParentJob-6.js

@@ -49,6 +49,15 @@ local parentData
 --[[
   Function to deduplicate a job.
 ]]
+--[[
+  Function to recover a stale deduplication key.
+  When the existing deduplication key has no expiry (simple mode, or
+  keepLastIfActive after the key was persisted), it should disappear
+  when the winning job finishes. If that job key no longer exists
+  because of an outage, the deduplication key is stale, so we discard it
+  and start a new deduplication window with the incoming job.
+  Returns true if the stale key was recovered, false otherwise.
+]]
 --[[
   Function to set the deduplication key for a job.
   Uses TTL from deduplication opts if provided.
@@ -61,6 +70,23 @@ local function setDeduplicationKey(deduplicationKey, jobId, deduplicationOpts)
         rcall('SET', deduplicationKey, jobId)
     end
 end
+local function recoverStaleDeduplicationKey(deduplicationKey, prefix, currentDeduplicatedJobId, jobId,
+    deduplicationId, deduplicationOpts)
+    if currentDeduplicatedJobId and rcall('PTTL', deduplicationKey) == -1 and
+        rcall('EXISTS', prefix .. currentDeduplicatedJobId) == 0 then
+        rcall('DEL', deduplicationKey)
+        -- Discard any pending next-job payload stored for the stale winner,
+        -- otherwise it would be resurrected when this job finalizes.
+        rcall('DEL', prefix .. "dn:" .. deduplicationId)
+        if deduplicationOpts['keepLastIfActive'] then
+            rcall('SET', deduplicationKey, jobId)
+        else
+            setDeduplicationKey(deduplicationKey, jobId, deduplicationOpts)
+        end
+        return true
+    end
+    return false
+end
 --[[
   Function to store a deduplicated next job if the existing job is active
   and keepLastIfActive is set. When the active job finishes, the stored
@@ -127,6 +153,10 @@ local function deduplicateJobWithoutReplace(deduplicationId, deduplicationOpts,
         if deduplicationOpts['extend'] then
             local currentDeduplicatedJobId = rcall('GET', deduplicationKey)
             if currentDeduplicatedJobId then
+                if recoverStaleDeduplicationKey(deduplicationKey, prefix, currentDeduplicatedJobId,
+                    jobId, deduplicationId, deduplicationOpts) then
+                    return
+                end
                 if storeDeduplicatedNextJob(deduplicationOpts, currentDeduplicatedJobId, prefix,
                     deduplicationId, jobName, jobData, fullOpts, eventsKey, maxEvents, jobId,
                     parentKey, parentData, parentDependenciesKey, repeatJobKey) then
@@ -160,6 +190,10 @@ local function deduplicateJobWithoutReplace(deduplicationId, deduplicationOpts,
     end
     if deduplicationKeyExists then
         local currentDeduplicatedJobId = rcall('GET', deduplicationKey)
+        if recoverStaleDeduplicationKey(deduplicationKey, prefix, currentDeduplicatedJobId,
+            jobId, deduplicationId, deduplicationOpts) then
+            return
+        end
         if storeDeduplicatedNextJob(deduplicationOpts, currentDeduplicatedJobId, prefix,
             deduplicationId, jobName, jobData, fullOpts, eventsKey, maxEvents, jobId,
             parentKey, parentData, parentDependenciesKey, repeatJobKey) then

package/dist/cjs/scripts/addPrioritizedJob-9.js

@@ -83,6 +83,15 @@ end
 --[[
   Function to deduplicate a job.
 ]]
+--[[
+  Function to recover a stale deduplication key.
+  When the existing deduplication key has no expiry (simple mode, or
+  keepLastIfActive after the key was persisted), it should disappear
+  when the winning job finishes. If that job key no longer exists
+  because of an outage, the deduplication key is stale, so we discard it
+  and start a new deduplication window with the incoming job.
+  Returns true if the stale key was recovered, false otherwise.
+]]
 --[[
   Function to set the deduplication key for a job.
   Uses TTL from deduplication opts if provided.
@@ -95,6 +104,23 @@ local function setDeduplicationKey(deduplicationKey, jobId, deduplicationOpts)
         rcall('SET', deduplicationKey, jobId)
     end
 end
+local function recoverStaleDeduplicationKey(deduplicationKey, prefix, currentDeduplicatedJobId, jobId,
+    deduplicationId, deduplicationOpts)
+    if currentDeduplicatedJobId and rcall('PTTL', deduplicationKey) == -1 and
+        rcall('EXISTS', prefix .. currentDeduplicatedJobId) == 0 then
+        rcall('DEL', deduplicationKey)
+        -- Discard any pending next-job payload stored for the stale winner,
+        -- otherwise it would be resurrected when this job finalizes.
+        rcall('DEL', prefix .. "dn:" .. deduplicationId)
+        if deduplicationOpts['keepLastIfActive'] then
+            rcall('SET', deduplicationKey, jobId)
+        else
+            setDeduplicationKey(deduplicationKey, jobId, deduplicationOpts)
+        end
+        return true
+    end
+    return false
+end
 --[[
   Function to store a deduplicated next job if the existing job is active
   and keepLastIfActive is set. When the active job finishes, the stored
@@ -161,6 +187,10 @@ local function deduplicateJobWithoutReplace(deduplicationId, deduplicationOpts,
         if deduplicationOpts['extend'] then
             local currentDeduplicatedJobId = rcall('GET', deduplicationKey)
             if currentDeduplicatedJobId then
+                if recoverStaleDeduplicationKey(deduplicationKey, prefix, currentDeduplicatedJobId,
+                    jobId, deduplicationId, deduplicationOpts) then
+                    return
+                end
                 if storeDeduplicatedNextJob(deduplicationOpts, currentDeduplicatedJobId, prefix,
                     deduplicationId, jobName, jobData, fullOpts, eventsKey, maxEvents, jobId,
                     parentKey, parentData, parentDependenciesKey, repeatJobKey) then
@@ -194,6 +224,10 @@ local function deduplicateJobWithoutReplace(deduplicationId, deduplicationOpts,
     end
     if deduplicationKeyExists then
         local currentDeduplicatedJobId = rcall('GET', deduplicationKey)
+        if recoverStaleDeduplicationKey(deduplicationKey, prefix, currentDeduplicatedJobId,
+            jobId, deduplicationId, deduplicationOpts) then
+            return
+        end
         if storeDeduplicatedNextJob(deduplicationOpts, currentDeduplicatedJobId, prefix,
             deduplicationId, jobName, jobData, fullOpts, eventsKey, maxEvents, jobId,
             parentKey, parentData, parentDependenciesKey, repeatJobKey) then
@@ -233,6 +267,10 @@ local function deduplicateJob(deduplicationOpts, jobId, delayedKey, deduplicatio
                 local isRemoved = removeDelayedJob(delayedKey, deduplicationKey, eventsKey, maxEvents,
                     currentDeduplicatedJobId, jobId, deduplicationId, prefix)
                 if isRemoved then
+                    -- Discard any pending next-job payload stored while the replaced
+                    -- job was active, otherwise it would be resurrected when the
+                    -- incoming job finalizes.
+                    rcall('DEL', prefix .. "dn:" .. deduplicationId)
                     if deduplicationOpts['keepLastIfActive'] then
                         rcall('SET', deduplicationKey, jobId)
                     else
@@ -245,6 +283,10 @@ local function deduplicateJob(deduplicationOpts, jobId, delayedKey, deduplicatio
                     end
                     return
                 else
+                    if recoverStaleDeduplicationKey(deduplicationKey, prefix, currentDeduplicatedJobId,
+                        jobId, deduplicationId, deduplicationOpts) then
+                        return
+                    end
                     storeDeduplicatedNextJob(deduplicationOpts, currentDeduplicatedJobId, prefix,
                         deduplicationId, jobName, jobData, fullOpts, eventsKey, maxEvents, jobId,
                         parentKey, parentData, parentDependenciesKey, repeatJobKey)

package/dist/cjs/scripts/addStandardJob-9.js

@@ -80,6 +80,15 @@ end
 --[[
   Function to deduplicate a job.
 ]]
+--[[
+  Function to recover a stale deduplication key.
+  When the existing deduplication key has no expiry (simple mode, or
+  keepLastIfActive after the key was persisted), it should disappear
+  when the winning job finishes. If that job key no longer exists
+  because of an outage, the deduplication key is stale, so we discard it
+  and start a new deduplication window with the incoming job.
+  Returns true if the stale key was recovered, false otherwise.
+]]
 --[[
   Function to set the deduplication key for a job.
   Uses TTL from deduplication opts if provided.
@@ -92,6 +101,23 @@ local function setDeduplicationKey(deduplicationKey, jobId, deduplicationOpts)
         rcall('SET', deduplicationKey, jobId)
     end
 end
+local function recoverStaleDeduplicationKey(deduplicationKey, prefix, currentDeduplicatedJobId, jobId,
+    deduplicationId, deduplicationOpts)
+    if currentDeduplicatedJobId and rcall('PTTL', deduplicationKey) == -1 and
+        rcall('EXISTS', prefix .. currentDeduplicatedJobId) == 0 then
+        rcall('DEL', deduplicationKey)
+        -- Discard any pending next-job payload stored for the stale winner,
+        -- otherwise it would be resurrected when this job finalizes.
+        rcall('DEL', prefix .. "dn:" .. deduplicationId)
+        if deduplicationOpts['keepLastIfActive'] then
+            rcall('SET', deduplicationKey, jobId)
+        else
+            setDeduplicationKey(deduplicationKey, jobId, deduplicationOpts)
+        end
+        return true
+    end
+    return false
+end
 --[[
   Function to store a deduplicated next job if the existing job is active
   and keepLastIfActive is set. When the active job finishes, the stored
@@ -158,6 +184,10 @@ local function deduplicateJobWithoutReplace(deduplicationId, deduplicationOpts,
         if deduplicationOpts['extend'] then
             local currentDeduplicatedJobId = rcall('GET', deduplicationKey)
             if currentDeduplicatedJobId then
+                if recoverStaleDeduplicationKey(deduplicationKey, prefix, currentDeduplicatedJobId,
+                    jobId, deduplicationId, deduplicationOpts) then
+                    return
+                end
                 if storeDeduplicatedNextJob(deduplicationOpts, currentDeduplicatedJobId, prefix,
                     deduplicationId, jobName, jobData, fullOpts, eventsKey, maxEvents, jobId,
                     parentKey, parentData, parentDependenciesKey, repeatJobKey) then
@@ -191,6 +221,10 @@ local function deduplicateJobWithoutReplace(deduplicationId, deduplicationOpts,
     end
     if deduplicationKeyExists then
         local currentDeduplicatedJobId = rcall('GET', deduplicationKey)
+        if recoverStaleDeduplicationKey(deduplicationKey, prefix, currentDeduplicatedJobId,
+            jobId, deduplicationId, deduplicationOpts) then
+            return
+        end
         if storeDeduplicatedNextJob(deduplicationOpts, currentDeduplicatedJobId, prefix,
             deduplicationId, jobName, jobData, fullOpts, eventsKey, maxEvents, jobId,
             parentKey, parentData, parentDependenciesKey, repeatJobKey) then
@@ -230,6 +264,10 @@ local function deduplicateJob(deduplicationOpts, jobId, delayedKey, deduplicatio
                 local isRemoved = removeDelayedJob(delayedKey, deduplicationKey, eventsKey, maxEvents,
                     currentDeduplicatedJobId, jobId, deduplicationId, prefix)
                 if isRemoved then
+                    -- Discard any pending next-job payload stored while the replaced
+                    -- job was active, otherwise it would be resurrected when the
+                    -- incoming job finalizes.
+                    rcall('DEL', prefix .. "dn:" .. deduplicationId)
                     if deduplicationOpts['keepLastIfActive'] then
                         rcall('SET', deduplicationKey, jobId)
                     else
@@ -242,6 +280,10 @@ local function deduplicateJob(deduplicationOpts, jobId, delayedKey, deduplicatio
                     end
                     return
                 else
+                    if recoverStaleDeduplicationKey(deduplicationKey, prefix, currentDeduplicatedJobId,
+                        jobId, deduplicationId, deduplicationOpts) then
+                        return
+                    end
                     storeDeduplicatedNextJob(deduplicationOpts, currentDeduplicatedJobId, prefix,
                         deduplicationId, jobName, jobData, fullOpts, eventsKey, maxEvents, jobId,
                         parentKey, parentData, parentDependenciesKey, repeatJobKey)