queue-jobs-worker 1.0.1 → 1.0.3

package/dist/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var crypto = require('crypto');
+var croner = require('croner');
 var events = require('events');
 
 var __defProp = Object.defineProperty;
@@ -76,7 +77,7 @@ function hashToJob(h) {
   if (h["cron"]) job.cron = h["cron"];
   return job;
 }
-var PREFIX, k, CLAIM_LUA; exports.RedisStorageAdapter = void 0;
+var PREFIX, k, CLAIM_LUA, RECOVER_STALLED_LUA, RENEW_LOCK_LUA; exports.RedisStorageAdapter = void 0;
 var init_redis_adapter = __esm({
   "src/storage/redis.adapter.ts"() {
     PREFIX = "qjw:";
@@ -118,6 +119,66 @@ redis.call('HSET', prefix .. 'job:' .. job_id,
   'updatedAt',     ARGV[2]
 )
 return job_id
+`;
+    RECOVER_STALLED_LUA = `
+local job_key        = KEYS[1]
+local active_set     = KEYS[2]
+local waiting_zset   = KEYS[3]
+
+local job_id         = ARGV[1]
+local expected_exp   = ARGV[2]
+local expected_lock  = ARGV[3]
+local recovery_ts    = ARGV[4]
+local priority_score = tonumber(ARGV[5])
+
+-- Re-read the three guard fields in one atomic HMGET.
+local fields = redis.call('HMGET', job_key, 'lockExpiresAt', 'lockId', 'status')
+local current_exp    = fields[1] or ''
+local current_lock   = fields[2] or ''
+local current_status = fields[3] or ''
+
+-- Guard 1: job must still be active.
+-- If the worker already completed, failed, or moved to DLQ, skip.
+if current_status ~= 'active' then return 0 end
+
+-- Guard 2: lockId must not have changed.
+-- A different worker may have claimed the job after the original lock expired
+-- and before this script runs.
+if current_lock ~= expected_lock then return 0 end
+
+-- Guard 3: lockExpiresAt must be exactly what the caller observed.
+-- If the worker renewed its lock the timestamp will be later than observed;
+-- the CAS mismatch catches that without needing ISO\u2192epoch conversion in Lua.
+if current_exp ~= expected_exp then return 0 end
+
+-- All guards passed \u2014 recover atomically.
+redis.call('HSET', job_key,
+  'status',        'waiting',
+  'lockId',        '',
+  'lockExpiresAt', '',
+  'updatedAt',     recovery_ts
+)
+redis.call('SREM', active_set,   job_id)
+redis.call('ZADD', waiting_zset, priority_score, job_id)
+return 1
+`;
+    RENEW_LOCK_LUA = `
+local job_key = KEYS[1]
+local lock_id = ARGV[1]
+local new_exp = ARGV[2]
+local now_iso = ARGV[3]
+
+local fields = redis.call('HMGET', job_key, 'status', 'lockId', 'lockExpiresAt')
+local status = fields[1] or ''
+local current_lock = fields[2] or ''
+local current_exp = fields[3] or ''
+
+if status ~= 'active' then return 0 end
+if current_lock ~= lock_id then return 0 end
+if current_exp == '' or current_exp <= now_iso then return 0 end
+
+redis.call('HSET', job_key, 'lockExpiresAt', new_exp, 'updatedAt', now_iso)
+return 1
 `;
     exports.RedisStorageAdapter = class {
       client;
@@ -208,12 +269,28 @@ return job_id
         return hashToJob(hash);
       }
       // -------------------------------------------------------------------------
+      // Renew lock
+      // -------------------------------------------------------------------------
+      async renewLock(jobId, lockId, lockDuration) {
+        const nowMs = Date.now();
+        const nowIso = new Date(nowMs).toISOString();
+        const newExpiresAt = new Date(nowMs + lockDuration).toISOString();
+        const res = await this.client.eval(RENEW_LOCK_LUA, {
+          keys: [k.job(jobId)],
+          arguments: [lockId, newExpiresAt, nowIso]
+        });
+        return Number(res) === 1;
+      }
+      // -------------------------------------------------------------------------
       // Complete
       // -------------------------------------------------------------------------
-      async complete(jobId) {
+      async complete(jobId, lockId) {
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const hash = await this.client.hGetAll(k.job(jobId));
-        if (!hash) return;
+        if (!hash || Object.keys(hash).length === 0) return;
+        if (lockId !== void 0) {
+          if (hash["status"] !== "active" || hash["lockId"] !== lockId) return;
+        }
         const queue = hash["queue"] ?? "";
         const multi = this.client.multi();
         multi.hSet(k.job(jobId), {
@@ -233,7 +310,10 @@ return job_id
       async requeue(input) {
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const hash = await this.client.hGetAll(k.job(input.jobId));
-        if (!hash) return;
+        if (!hash || Object.keys(hash).length === 0) return;
+        if (input.lockId !== void 0) {
+          if (hash["status"] !== "active" || hash["lockId"] !== input.lockId) return;
+        }
         const queue = hash["queue"] ?? "";
         const attempts = JSON.parse(hash["attempts"] ?? "[]");
         attempts.push({
@@ -266,7 +346,10 @@ return job_id
       async moveToDlq(input) {
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const hash = await this.client.hGetAll(k.job(input.jobId));
-        if (!hash) return;
+        if (!hash || Object.keys(hash).length === 0) return;
+        if (input.lockId !== void 0) {
+          if (hash["status"] !== "active" || hash["lockId"] !== input.lockId) return;
+        }
         const queue = hash["queue"] ?? "";
         const attempts = JSON.parse(hash["attempts"] ?? "[]");
         attempts.push({
@@ -293,7 +376,12 @@ return job_id
       // -------------------------------------------------------------------------
       // Release lock
       // -------------------------------------------------------------------------
-      async releaseLock(jobId) {
+      async releaseLock(jobId, lockId) {
+        const hash = await this.client.hGetAll(k.job(jobId));
+        if (!hash || Object.keys(hash).length === 0) return;
+        if (lockId !== void 0) {
+          if (hash["status"] !== "active" || hash["lockId"] !== lockId) return;
+        }
         const now = (/* @__PURE__ */ new Date()).toISOString();
         await this.client.hSet(k.job(jobId), {
           lockId: "",
@@ -302,7 +390,18 @@ return job_id
         });
       }
       // -------------------------------------------------------------------------
-      // Recover stalled jobs  (batched — one pipeline per stalled job)
+      // Recover stalled jobs  (atomic compare-and-swap per job via Lua)
+      //
+      // Previous implementation: two-phase read pipeline → write pipeline.
+      // Race condition: a worker could complete or renew its lock between the two
+      // phases, causing recovery to overwrite a legitimately-active job.
+      //
+      // Fix (issue #6): for each candidate job the RECOVER_STALLED_LUA script
+      // re-reads lockExpiresAt, lockId, and status atomically and only applies
+      // the recovery if all three still match what was observed in the read phase
+      // (compare-and-swap).  If the worker renewed or completed the job in the
+      // window between the read and the Lua call, the CAS mismatch causes the
+      // script to return 0 and the job is left untouched.
       // -------------------------------------------------------------------------
       async recoverStalledJobs(queue, now) {
         const nowMs = new Date(now).getTime();
@@ -310,32 +409,29 @@ return job_id
         if (activeIds.length === 0) return [];
         const fetchPipeline = this.client.multi();
         for (const jobId of activeIds) {
-          fetchPipeline.hmGet(k.job(jobId), ["lockExpiresAt", "priority"]);
+          fetchPipeline.hmGet(k.job(jobId), ["lockExpiresAt", "lockId", "priority"]);
         }
         const fetchResults = await fetchPipeline.exec();
         const recovered = [];
-        const recoverPipeline = this.client.multi();
+        const evalPromises = [];
         for (let i = 0; i < activeIds.length; i++) {
           const jobId = activeIds[i];
           const fields = fetchResults[i];
           if (!fields) continue;
-          const [lockExpiresAt, priorityStr] = fields;
+          const [lockExpiresAt, lockId, priorityStr] = fields;
           if (!lockExpiresAt) continue;
           if (new Date(lockExpiresAt).getTime() > nowMs) continue;
           const priority = Number(priorityStr ?? "0");
-          recoverPipeline.hSet(k.job(jobId), {
-            status: "waiting",
-            lockId: "",
-            lockExpiresAt: "",
-            updatedAt: now
+          const priorityScore = String(-priority);
+          const p = this.client.eval(RECOVER_STALLED_LUA, {
+            keys: [k.job(jobId), k.active(queue), k.waiting(queue)],
+            arguments: [jobId, lockExpiresAt, lockId ?? "", now, priorityScore]
+          }).then((result) => {
+            if (result === 1) recovered.push(jobId);
           });
-          recoverPipeline.sRem(k.active(queue), jobId);
-          recoverPipeline.zAdd(k.waiting(queue), { score: -priority, value: jobId });
-          recovered.push(jobId);
-        }
-        if (recovered.length > 0) {
-          await recoverPipeline.exec();
+          evalPromises.push(p);
         }
+        await Promise.all(evalPromises);
         return recovered;
       }
       // -------------------------------------------------------------------------
@@ -612,16 +708,40 @@ CREATE TABLE IF NOT EXISTS qjw_rate_limits (
         }
       }
       // -------------------------------------------------------------------------
-      // Complete
+      // Renew lock
       // -------------------------------------------------------------------------
-      async complete(jobId) {
-        await this.pool.query(
+      async renewLock(jobId, lockId, lockDuration) {
+        const newLockExpiresAt = new Date(Date.now() + lockDuration).toISOString();
+        const res = await this.pool.query(
           `UPDATE qjw_jobs
-       SET status = 'completed', lock_id = NULL, lock_expires_at = NULL,
-           completed_at = NOW(), updated_at = NOW()
-       WHERE id = $1`,
-          [jobId]
+       SET lock_expires_at = $1::timestamptz,
+           updated_at = NOW()
+       WHERE id = $2 AND status = 'active' AND lock_id = $3 AND lock_expires_at > NOW()`,
+          [newLockExpiresAt, jobId, lockId]
         );
+        return (res.rowCount ?? 0) > 0;
+      }
+      // -------------------------------------------------------------------------
+      // Complete
+      // -------------------------------------------------------------------------
+      async complete(jobId, lockId) {
+        if (lockId !== void 0) {
+          await this.pool.query(
+            `UPDATE qjw_jobs
+         SET status = 'completed', lock_id = NULL, lock_expires_at = NULL,
+             completed_at = NOW(), updated_at = NOW()
+         WHERE id = $1 AND status = 'active' AND lock_id = $2`,
+            [jobId, lockId]
+          );
+        } else {
+          await this.pool.query(
+            `UPDATE qjw_jobs
+         SET status = 'completed', lock_id = NULL, lock_expires_at = NULL,
+             completed_at = NOW(), updated_at = NOW()
+         WHERE id = $1`,
+            [jobId]
+          );
+        }
       }
       // -------------------------------------------------------------------------
       // Requeue
@@ -635,18 +755,33 @@ CREATE TABLE IF NOT EXISTS qjw_rate_limits (
           error: input.error,
           ...input.stack !== void 0 ? { stack: input.stack } : {}
         };
-        await this.pool.query(
-          `UPDATE qjw_jobs
-       SET status         = 'waiting',
-           attempts_made  = attempts_made + 1,
-           attempts       = attempts || $1::jsonb,
-           run_at         = $2::timestamptz,
-           lock_id        = NULL,
-           lock_expires_at = NULL,
-           updated_at     = NOW()
-       WHERE id = $3`,
-          [JSON.stringify([attempt]), input.runAt, input.jobId]
-        );
+        if (input.lockId !== void 0) {
+          await this.pool.query(
+            `UPDATE qjw_jobs
+         SET status          = 'waiting',
+             attempts_made   = $1,
+             attempts        = attempts || $2::jsonb,
+             run_at          = $3::timestamptz,
+             lock_id         = NULL,
+             lock_expires_at = NULL,
+             updated_at      = NOW()
+         WHERE id = $4 AND status = 'active' AND lock_id = $5`,
+            [input.attemptNumber, JSON.stringify([attempt]), input.runAt, input.jobId, input.lockId]
+          );
+        } else {
+          await this.pool.query(
+            `UPDATE qjw_jobs
+         SET status         = 'waiting',
+             attempts_made  = $1,
+             attempts       = attempts || $2::jsonb,
+             run_at         = $3::timestamptz,
+             lock_id        = NULL,
+             lock_expires_at = NULL,
+             updated_at     = NOW()
+         WHERE id = $4`,
+            [input.attemptNumber, JSON.stringify([attempt]), input.runAt, input.jobId]
+          );
+        }
       }
       // -------------------------------------------------------------------------
       // Move to DLQ
@@ -660,29 +795,53 @@ CREATE TABLE IF NOT EXISTS qjw_rate_limits (
           error: input.error,
           ...input.stack !== void 0 ? { stack: input.stack } : {}
         };
-        await this.pool.query(
-          `UPDATE qjw_jobs
-       SET status          = 'dead',
-           attempts_made   = attempts_made + 1,
-           attempts        = attempts || $1::jsonb,
-           lock_id         = NULL,
-           lock_expires_at = NULL,
-           failed_at       = NOW(),
-           updated_at      = NOW()
-       WHERE id = $2`,
-          [JSON.stringify([attempt]), input.jobId]
-        );
+        if (input.lockId !== void 0) {
+          await this.pool.query(
+            `UPDATE qjw_jobs
+         SET status          = 'dead',
+             attempts_made   = $1,
+             attempts        = attempts || $2::jsonb,
+             lock_id         = NULL,
+             lock_expires_at = NULL,
+             failed_at       = NOW(),
+             updated_at      = NOW()
+         WHERE id = $3 AND status = 'active' AND lock_id = $4`,
+            [input.attemptNumber, JSON.stringify([attempt]), input.jobId, input.lockId]
+          );
+        } else {
+          await this.pool.query(
+            `UPDATE qjw_jobs
+         SET status          = 'dead',
+             attempts_made   = $1,
+             attempts        = attempts || $2::jsonb,
+             lock_id         = NULL,
+             lock_expires_at = NULL,
+             failed_at       = NOW(),
+             updated_at      = NOW()
+         WHERE id = $3`,
+            [input.attemptNumber, JSON.stringify([attempt]), input.jobId]
+          );
+        }
       }
       // -------------------------------------------------------------------------
       // Release lock
       // -------------------------------------------------------------------------
-      async releaseLock(jobId) {
-        await this.pool.query(
-          `UPDATE qjw_jobs
-       SET lock_id = NULL, lock_expires_at = NOW(), updated_at = NOW()
-       WHERE id = $1`,
-          [jobId]
-        );
+      async releaseLock(jobId, lockId) {
+        if (lockId !== void 0) {
+          await this.pool.query(
+            `UPDATE qjw_jobs
+         SET lock_id = NULL, lock_expires_at = NOW(), updated_at = NOW()
+         WHERE id = $1 AND status = 'active' AND lock_id = $2`,
+            [jobId, lockId]
+          );
+        } else {
+          await this.pool.query(
+            `UPDATE qjw_jobs
+         SET lock_id = NULL, lock_expires_at = NOW(), updated_at = NOW()
+         WHERE id = $1`,
+            [jobId]
+          );
+        }
       }
       // -------------------------------------------------------------------------
       // Recover stalled jobs
@@ -963,16 +1122,39 @@ CREATE TABLE IF NOT EXISTS qjw_rate_limits (
         }
       }
       // -------------------------------------------------------------------------
-      // Complete
+      // Renew lock
       // -------------------------------------------------------------------------
-      async complete(jobId) {
-        await this.pool.query(
+      async renewLock(jobId, lockId, lockDuration) {
+        const newLockExpiresAt = new Date(Date.now() + lockDuration).toISOString().slice(0, 23).replace("T", " ");
+        const [result] = await this.pool.query(
           `UPDATE qjw_jobs
-       SET status = 'completed', lock_id = NULL, lock_expires_at = NULL,
-           completed_at = NOW(3), updated_at = NOW(3)
-       WHERE id = ?`,
-          [jobId]
+       SET lock_expires_at = ?, updated_at = NOW(3)
+       WHERE id = ? AND status = 'active' AND lock_id = ? AND lock_expires_at > NOW(3)`,
+          [newLockExpiresAt, jobId, lockId]
         );
+        return result.affectedRows > 0;
+      }
+      // -------------------------------------------------------------------------
+      // Complete
+      // -------------------------------------------------------------------------
+      async complete(jobId, lockId) {
+        if (lockId !== void 0) {
+          await this.pool.query(
+            `UPDATE qjw_jobs
+         SET status = 'completed', lock_id = NULL, lock_expires_at = NULL,
+             completed_at = NOW(3), updated_at = NOW(3)
+         WHERE id = ? AND status = 'active' AND lock_id = ?`,
+            [jobId, lockId]
+          );
+        } else {
+          await this.pool.query(
+            `UPDATE qjw_jobs
+         SET status = 'completed', lock_id = NULL, lock_expires_at = NULL,
+             completed_at = NOW(3), updated_at = NOW(3)
+         WHERE id = ?`,
+            [jobId]
+          );
+        }
       }
       // -------------------------------------------------------------------------
       // Requeue
@@ -986,18 +1168,33 @@ CREATE TABLE IF NOT EXISTS qjw_rate_limits (
           error: input.error,
           ...input.stack !== void 0 ? { stack: input.stack } : {}
         });
-        await this.pool.query(
-          `UPDATE qjw_jobs
-       SET status          = 'waiting',
-           attempts_made   = attempts_made + 1,
-           attempts        = JSON_ARRAY_APPEND(attempts, '$', CAST(? AS JSON)),
-           run_at          = ?,
-           lock_id         = NULL,
-           lock_expires_at = NULL,
-           updated_at      = NOW(3)
-       WHERE id = ?`,
-          [attempt, input.runAt, input.jobId]
-        );
+        if (input.lockId !== void 0) {
+          await this.pool.query(
+            `UPDATE qjw_jobs
+         SET status          = 'waiting',
+             attempts_made   = attempts_made + 1,
+             attempts        = JSON_ARRAY_APPEND(attempts, '$', CAST(? AS JSON)),
+             run_at          = ?,
+             lock_id         = NULL,
+             lock_expires_at = NULL,
+             updated_at      = NOW(3)
+         WHERE id = ? AND status = 'active' AND lock_id = ?`,
+            [attempt, input.runAt, input.jobId, input.lockId]
+          );
+        } else {
+          await this.pool.query(
+            `UPDATE qjw_jobs
+         SET status          = 'waiting',
+             attempts_made   = attempts_made + 1,
+             attempts        = JSON_ARRAY_APPEND(attempts, '$', CAST(? AS JSON)),
+             run_at          = ?,
+             lock_id         = NULL,
+             lock_expires_at = NULL,
+             updated_at      = NOW(3)
+         WHERE id = ?`,
+            [attempt, input.runAt, input.jobId]
+          );
+        }
       }
       // -------------------------------------------------------------------------
       // Move to DLQ
@@ -1011,29 +1208,53 @@ CREATE TABLE IF NOT EXISTS qjw_rate_limits (
           error: input.error,
           ...input.stack !== void 0 ? { stack: input.stack } : {}
         });
-        await this.pool.query(
-          `UPDATE qjw_jobs
-       SET status          = 'dead',
-           attempts_made   = attempts_made + 1,
-           attempts        = JSON_ARRAY_APPEND(attempts, '$', CAST(? AS JSON)),
-           lock_id         = NULL,
-           lock_expires_at = NULL,
-           failed_at       = NOW(3),
-           updated_at      = NOW(3)
-       WHERE id = ?`,
-          [attempt, input.jobId]
-        );
+        if (input.lockId !== void 0) {
+          await this.pool.query(
+            `UPDATE qjw_jobs
+         SET status          = 'dead',
+             attempts_made   = attempts_made + 1,
+             attempts        = JSON_ARRAY_APPEND(attempts, '$', CAST(? AS JSON)),
+             lock_id         = NULL,
+             lock_expires_at = NULL,
+             failed_at       = NOW(3),
+             updated_at      = NOW(3)
+         WHERE id = ? AND status = 'active' AND lock_id = ?`,
+            [attempt, input.jobId, input.lockId]
+          );
+        } else {
+          await this.pool.query(
+            `UPDATE qjw_jobs
+         SET status          = 'dead',
+             attempts_made   = attempts_made + 1,
+             attempts        = JSON_ARRAY_APPEND(attempts, '$', CAST(? AS JSON)),
+             lock_id         = NULL,
+             lock_expires_at = NULL,
+             failed_at       = NOW(3),
+             updated_at      = NOW(3)
+         WHERE id = ?`,
+            [attempt, input.jobId]
+          );
+        }
       }
       // -------------------------------------------------------------------------
       // Release lock
       // -------------------------------------------------------------------------
-      async releaseLock(jobId) {
-        await this.pool.query(
-          `UPDATE qjw_jobs
-       SET lock_id = NULL, lock_expires_at = NOW(3), updated_at = NOW(3)
-       WHERE id = ?`,
-          [jobId]
-        );
+      async releaseLock(jobId, lockId) {
+        if (lockId !== void 0) {
+          await this.pool.query(
+            `UPDATE qjw_jobs
+         SET lock_id = NULL, lock_expires_at = NOW(3), updated_at = NOW(3)
+         WHERE id = ? AND status = 'active' AND lock_id = ?`,
+            [jobId, lockId]
+          );
+        } else {
+          await this.pool.query(
+            `UPDATE qjw_jobs
+         SET lock_id = NULL, lock_expires_at = NOW(3), updated_at = NOW(3)
+         WHERE id = ?`,
+            [jobId]
+          );
+        }
       }
       // -------------------------------------------------------------------------
       // Recover stalled jobs  (atomic — SELECT … FOR UPDATE inside transaction)
@@ -1424,7 +1645,7 @@ var Worker = class {
     if (this.activeJobIds.size > 0) {
       await Promise.all(
         Array.from(this.activeJobIds).map(
-          (jobId) => this.storage.releaseLock(jobId).catch(() => {
+          (jobId) => this.storage.releaseLock(jobId, this.id).catch(() => {
           })
         )
       );
@@ -1461,6 +1682,13 @@ var Worker = class {
   // -------------------------------------------------------------------------
   async claimNext() {
     const now = (/* @__PURE__ */ new Date()).toISOString();
+    const raw = await this.storage.claim({
+      queue: this.queueName,
+      lockId: this.id,
+      lockDuration: this.config.lockDuration,
+      now
+    });
+    if (!raw) return false;
     if (this.config.rateLimit) {
       const allowed = await this.storage.checkAndIncrementRateLimit(
         this.queueName,
@@ -1468,15 +1696,11 @@ var Worker = class {
         this.config.rateLimit.duration,
         now
       );
-      if (!allowed) return false;
+      if (!allowed) {
+        await this.storage.releaseLock(raw.id, this.id);
+        return false;
+      }
     }
-    const raw = await this.storage.claim({
-      queue: this.queueName,
-      lockId: this.id,
-      lockDuration: this.config.lockDuration,
-      now
-    });
-    if (!raw) return false;
     const job = new Job(raw);
     this.activeCount += 1;
     this.activeJobIds.add(job.id);
@@ -1493,16 +1717,35 @@ var Worker = class {
       await this.handleFailure(job, error);
       return;
     }
+    const abortController = new AbortController();
     let timeoutHandle = null;
+    let lockRenewTimer = null;
+    const lockRenewInterval = Math.max(100, Math.floor(this.config.lockDuration / 2));
+    lockRenewTimer = setInterval(async () => {
+      try {
+        const renewed = await this.storage.renewLock(job.id, this.id, this.config.lockDuration);
+        if (!renewed && lockRenewTimer) {
+          clearInterval(lockRenewTimer);
+          lockRenewTimer = null;
+        }
+      } catch {
+      }
+    }, lockRenewInterval);
     try {
       await new Promise((resolve, reject) => {
         timeoutHandle = setTimeout(() => {
-          reject(new Error(`Job timed out after ${job.timeout}ms`));
+          const timeoutError = new Error(`Job timed out after ${job.timeout}ms`);
+          abortController.abort(timeoutError);
+          reject(timeoutError);
         }, job.timeout);
-        Promise.resolve(processor(job)).then(resolve, reject);
+        Promise.resolve(processor(job, abortController.signal)).then(resolve, reject);
       });
       if (timeoutHandle) clearTimeout(timeoutHandle);
-      await this.storage.complete(job.id);
+      if (lockRenewTimer) {
+        clearInterval(lockRenewTimer);
+        lockRenewTimer = null;
+      }
+      await this.storage.complete(job.id, this.id);
       const completedData = await this.storage.getJob(job.id) ?? job._data;
       this.emitter.emit("job:completed", completedData);
       if (job.cron) {
@@ -1510,9 +1753,17 @@ var Worker = class {
       }
     } catch (err) {
       if (timeoutHandle) clearTimeout(timeoutHandle);
+      if (lockRenewTimer) {
+        clearInterval(lockRenewTimer);
+        lockRenewTimer = null;
+      }
       const error = err instanceof Error ? err : new Error(String(err));
       await this.handleFailure(job, error);
     } finally {
+      if (lockRenewTimer) {
+        clearInterval(lockRenewTimer);
+        lockRenewTimer = null;
+      }
       this.activeJobIds.delete(job.id);
       this.activeCount -= 1;
       if (this.activeCount === 0 && this.drainResolve) {
@@ -1526,25 +1777,25 @@ var Worker = class {
   // -------------------------------------------------------------------------
   async enqueueCronNext(job) {
     try {
-      let nextMs;
+      let nextDate;
       try {
-        const specifier = "croner";
-        const croner = await import(
-          /* @vite-ignore */
-          specifier
+        const cronInstance = new croner.Cron(job.cron);
+        nextDate = cronInstance.nextRun();
+      } catch (cronErr) {
+        const error = cronErr instanceof Error ? cronErr : new Error(
+          `croner failed to initialize for expression "${job.cron}": ${String(cronErr)}`
         );
-        const CronClass = croner.Cron ?? croner.default?.Cron ?? croner.default;
-        if (typeof CronClass === "function") {
-          const cronInstance = new CronClass(job.cron);
-          const nextDate = cronInstance.nextRun();
-          nextMs = nextDate ? nextDate.getTime() : Date.now() + 6e4;
-        } else {
-          nextMs = Date.now() + 6e4;
-        }
-      } catch {
-        nextMs = Date.now() + 6e4;
+        this.emitter.emit("worker:error", this.id, error);
+        return;
+      }
+      if (nextDate === null) {
+        const error = new Error(
+          `Cron expression "${job.cron}" has no future occurrences \u2014 job "${job.id}" will not be re-enqueued`
+        );
+        this.emitter.emit("worker:error", this.id, error);
+        return;
       }
-      const runAt = new Date(nextMs).toISOString();
+      const runAt = nextDate.toISOString();
       await this.storage.enqueue({
         id: generateJobId(),
         queue: this.queueName,
@@ -1578,6 +1829,7 @@ var Worker = class {
         runAt,
         error: error.message,
         attemptNumber,
+        lockId: this.id,
         ...error.stack !== void 0 && { stack: error.stack }
       });
       const updated = await this.storage.getJob(job.id);
@@ -1589,6 +1841,7 @@ var Worker = class {
         jobId: job.id,
         error: error.message,
         attemptNumber,
+        lockId: this.id,
         ...error.stack !== void 0 && { stack: error.stack }
       });
       const dead = await this.storage.getJob(job.id);
@@ -1848,10 +2101,29 @@ var InMemoryStorageAdapter = class {
     return job;
   }
   // -------------------------------------------------------------------------
+  // Renew lock
+  // -------------------------------------------------------------------------
+  async renewLock(jobId, lockId, lockDuration) {
+    const job = this.jobs.get(jobId);
+    if (!job) return false;
+    if (job.status !== "active" || job.lockId !== lockId) return false;
+    const nowMs = Date.now();
+    if (job.lockExpiresAt !== null && new Date(job.lockExpiresAt).getTime() <= nowMs) {
+      return false;
+    }
+    job.lockExpiresAt = new Date(nowMs + lockDuration).toISOString();
+    job.updatedAt = new Date(nowMs).toISOString();
+    return true;
+  }
+  // -------------------------------------------------------------------------
   // Complete
   // -------------------------------------------------------------------------
-  async complete(jobId) {
-    const job = this.requireJob(jobId);
+  async complete(jobId, lockId) {
+    const job = this.jobs.get(jobId);
+    if (!job) return;
+    if (lockId !== void 0 && (job.status !== "active" || job.lockId !== lockId)) {
+      return;
+    }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     job.status = "completed";
     job.lockId = null;
@@ -1863,7 +2135,11 @@ var InMemoryStorageAdapter = class {
   // Requeue (retry)
   // -------------------------------------------------------------------------
   async requeue(input) {
-    const job = this.requireJob(input.jobId);
+    const job = this.jobs.get(input.jobId);
+    if (!job) return;
+    if (input.lockId !== void 0 && (job.status !== "active" || job.lockId !== input.lockId)) {
+      return;
+    }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     job.attempts.push({
       attempt: input.attemptNumber,
@@ -1883,7 +2159,11 @@ var InMemoryStorageAdapter = class {
   // Move to DLQ
   // -------------------------------------------------------------------------
   async moveToDlq(input) {
-    const job = this.requireJob(input.jobId);
+    const job = this.jobs.get(input.jobId);
+    if (!job) return;
+    if (input.lockId !== void 0 && (job.status !== "active" || job.lockId !== input.lockId)) {
+      return;
+    }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     job.attempts.push({
       attempt: input.attemptNumber,
@@ -1902,9 +2182,12 @@ var InMemoryStorageAdapter = class {
   // -------------------------------------------------------------------------
   // Release lock
   // -------------------------------------------------------------------------
-  async releaseLock(jobId) {
+  async releaseLock(jobId, lockId) {
     const job = this.jobs.get(jobId);
     if (!job) return;
+    if (lockId !== void 0 && (job.status !== "active" || job.lockId !== lockId)) {
+      return;
+    }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     job.lockId = null;
     job.lockExpiresAt = now;
@@ -1912,6 +2195,12 @@ var InMemoryStorageAdapter = class {
   }
   // -------------------------------------------------------------------------
   // Recover stalled jobs
+  //
+  // Fix (issue #6): snapshot lockId and lockExpiresAt before the eligibility
+  // check, then re-validate both values at write time.  In a single-process
+  // scenario all operations are synchronous within one event-loop tick, so
+  // the race is theoretical — but the guard makes the adapter consistent with
+  // the Redis CAS semantics and protects against any future async paths.
   // -------------------------------------------------------------------------
   async recoverStalledJobs(queue, now) {
     const nowMs = new Date(now).getTime();
@@ -1921,13 +2210,17 @@ var InMemoryStorageAdapter = class {
       if (job.status !== "active") continue;
       if (job.lockExpiresAt === null) continue;
       const lockExpiry = new Date(job.lockExpiresAt).getTime();
-      if (lockExpiry <= nowMs) {
-        job.status = "waiting";
-        job.lockId = null;
-        job.lockExpiresAt = null;
-        job.updatedAt = now;
-        recovered.push(job.id);
-      }
+      if (lockExpiry > nowMs) continue;
+      const snapshotLockId = job.lockId;
+      const snapshotLockExpiresAt = job.lockExpiresAt;
+      if (job.status !== "active") continue;
+      if (job.lockId !== snapshotLockId) continue;
+      if (job.lockExpiresAt !== snapshotLockExpiresAt) continue;
+      job.status = "waiting";
+      job.lockId = null;
+      job.lockExpiresAt = null;
+      job.updatedAt = now;
+      recovered.push(job.id);
     }
     return recovered;
   }