groupmq-plus 1.1.0

package/dist/lua/complete.lua

@@ -0,0 +1,51 @@
+-- Complete a job by removing from processing and unlocking the group
+-- Does NOT record job metadata - that's handled separately by record-job-result.lua
+-- argv: ns, jobId, groupId
+local ns = KEYS[1]
+local jobId = ARGV[1]
+local gid = ARGV[2]
+
+-- Remove from processing
+redis.call("DEL", ns .. ":processing:" .. jobId)
+redis.call("ZREM", ns .. ":processing", jobId)
+
+-- Check if this job holds the lock
+local lockKey = ns .. ":lock:" .. gid
+local val = redis.call("GET", lockKey)
+if val == jobId then
+  redis.call("DEL", lockKey)
+  
+  -- Check if there are more jobs in this group
+  local gZ = ns .. ":g:" .. gid
+  local jobCount = redis.call("ZCARD", gZ)
+  if jobCount == 0 then
+    -- Remove empty group zset and from groups tracking set
+    redis.call("DEL", gZ)
+    redis.call("SREM", ns .. ":groups", gid)
+    -- Remove from ready queue
+    redis.call("ZREM", ns .. ":ready", gid)
+    -- Clean up any buffering state (shouldn't exist but be safe)
+    redis.call("DEL", ns .. ":buffer:" .. gid)
+    redis.call("ZREM", ns .. ":buffering", gid)
+  else
+    -- Group has more jobs, re-add to ready set
+    -- Note: If the group was buffering, it will be handled by the buffering logic
+    -- If it's not buffering, add to ready immediately
+    local groupBufferKey = ns .. ":buffer:" .. gid
+    local isBuffering = redis.call("EXISTS", groupBufferKey)
+    
+    if isBuffering == 0 then
+      -- Not buffering, add to ready immediately
+      local nextHead = redis.call("ZRANGE", gZ, 0, 0, "WITHSCORES")
+      if nextHead and #nextHead >= 2 then
+        local nextScore = tonumber(nextHead[2])
+        local readyKey = ns .. ":ready"
+        redis.call("ZADD", readyKey, nextScore, gid)
+      end
+    end
+    -- If buffering, the scheduler will promote when ready
+  end
+  
+  return 1
+end
+return 0

package/dist/lua/dead-letter.lua

@@ -0,0 +1,86 @@
+-- argv: ns, jobId, groupId
+local ns = KEYS[1]
+local jobId = ARGV[1]
+local groupId = ARGV[2]
+local gZ = ns .. ":g:" .. groupId
+local readyKey = ns .. ":ready"
+
+local jobKey = ns .. ":job:" .. jobId
+
+-- [FLOW SUPPORT: Get parentId before any cleanup]
+local parentId = redis.call("HGET", jobKey, "parentId")
+
+-- Remove job from group
+redis.call("ZREM", gZ, jobId)
+
+-- Remove from processing if it's there
+redis.call("DEL", ns .. ":processing:" .. jobId)
+redis.call("ZREM", ns .. ":processing", jobId)
+
+-- No counter operations - use ZCARD for counts
+
+-- Remove idempotence mapping to allow reuse
+redis.call("DEL", ns .. ":unique:" .. jobId)
+
+-- BullMQ-style: Remove from group active list if present
+local groupActiveKey = ns .. ":g:" .. groupId .. ":active"
+redis.call("LREM", groupActiveKey, 1, jobId)
+
+-- Check if group is now empty or should be removed from ready queue
+local jobCount = redis.call("ZCARD", gZ)
+if jobCount == 0 then
+  -- Group is empty, remove from ready queue and clean up
+  redis.call("ZREM", readyKey, groupId)
+  redis.call("DEL", gZ)
+  redis.call("DEL", groupActiveKey)
+  redis.call("SREM", ns .. ":groups", groupId)
+else
+  -- Group still has jobs, update ready queue with new head
+  local head = redis.call("ZRANGE", gZ, 0, 0, "WITHSCORES")
+  if head and #head >= 2 then
+    local headScore = tonumber(head[2])
+    redis.call("ZADD", readyKey, headScore, groupId)
+  end
+end
+
+-- Optionally store in dead letter queue (uncomment if needed)
+-- redis.call("LPUSH", ns .. ":dead", jobId)
+
+-- [FLOW SUPPORT: Update parent if this job is a child in a flow]
+if parentId then
+  local parentKey = ns .. ":job:" .. parentId
+  -- 1. Store error result in flow:results hash
+  local flowResultsKey = ns .. ":flow:results:" .. parentId
+  redis.call("HSET", flowResultsKey, jobId, '{"error":"dead-lettered"}')
+  
+  -- 2. Decrement remaining counter
+  local remaining = redis.call("HINCRBY", parentKey, "flowRemaining", -1)
+  
+  -- 3. If all children done, move parent to waiting
+  if remaining <= 0 then
+    local parentStatus = redis.call("HGET", parentKey, "status")
+    if parentStatus == "waiting-children" then
+      redis.call("HSET", parentKey, "status", "waiting")
+      
+      local parentGroupId = redis.call("HGET", parentKey, "groupId")
+      local parentScore = tonumber(redis.call("HGET", parentKey, "score"))
+      if not parentScore then
+        parentScore = tonumber(redis.call("TIME")[1]) * 1000
+      end
+      
+      local pGZ = ns .. ":g:" .. parentGroupId
+      redis.call("ZADD", pGZ, parentScore, parentId)
+      redis.call("SADD", ns .. ":groups", parentGroupId)
+      
+      -- Add to ready if head
+      local pHead = redis.call("ZRANGE", pGZ, 0, 0, "WITHSCORES")
+      if pHead and #pHead >= 2 then
+         local pHeadScore = tonumber(pHead[2])
+         redis.call("ZADD", readyKey, pHeadScore, parentGroupId)
+      end
+    end
+  end
+end
+
+return 1
+

package/dist/lua/enqueue-batch.lua

@@ -0,0 +1,149 @@
+-- Batch enqueue multiple jobs atomically
+-- argv: ns, jobsJson, keepCompleted, clientTimestamp, orderingDelayMs
+local ns = KEYS[1]
+local jobsJson = ARGV[1]
+local keepCompleted = tonumber(ARGV[2]) or 0
+local clientTimestamp = tonumber(ARGV[3])
+local orderingDelayMs = tonumber(ARGV[4]) or 0
+
+local jobs = cjson.decode(jobsJson)
+
+-- Get Redis server time
+local timeResult = redis.call("TIME")
+local now = tonumber(timeResult[1]) * 1000 + math.floor(tonumber(timeResult[2]) / 1000)
+
+-- Keys
+local stageKey = ns .. ":stage"
+local readyKey = ns .. ":ready"
+local delayedKey = ns .. ":delayed"
+local groupsKey = ns .. ":groups"
+local timerKey = ns .. ":stage:timer"
+
+local baseEpoch = 1704067200000
+local daysSinceEpoch = math.floor(clientTimestamp / 86400000)
+local seqKey = ns .. ":seq:" .. daysSinceEpoch
+
+-- Track groups that need ready queue updates
+local groupsToUpdate = {}
+local results = {}
+
+-- Process all jobs in batch
+for i, job in ipairs(jobs) do
+  local jobId = job.jobId
+  local groupId = job.groupId
+  local data = job.data
+  local maxAttempts = tonumber(job.maxAttempts)
+  local orderMs = tonumber(job.orderMs) or clientTimestamp
+  local delayUntil = job.delayMs and (now + tonumber(job.delayMs)) or 0
+  
+  -- Idempotence check
+  local uniqueKey = ns .. ":unique:" .. jobId
+  local uniqueSet = redis.call("SET", uniqueKey, jobId, "NX")
+  
+  if uniqueSet then
+    -- Generate sequence and score
+    local seq = redis.call("INCR", seqKey)
+    local relativeMs = orderMs - baseEpoch
+    local score = relativeMs * 1000 + seq
+    
+    -- Create job hash
+    local jobKey = ns .. ":job:" .. jobId
+    redis.call("HMSET", jobKey,
+      "id", jobId,
+      "groupId", groupId,
+      "data", data,
+      "attempts", "0",
+      "maxAttempts", tostring(maxAttempts),
+      "seq", tostring(seq),
+      "timestamp", tostring(clientTimestamp),
+      "orderMs", tostring(orderMs),
+      "score", tostring(score),
+      "delayUntil", tostring(delayUntil)
+    )
+    
+    -- Add to groups set
+    redis.call("SADD", groupsKey, groupId)
+    
+    -- Add to group sorted set
+    local gZ = ns .. ":g:" .. groupId
+    redis.call("ZADD", gZ, score, jobId)
+    
+    -- Determine job placement
+    local jobStatus = "waiting"
+    
+    if delayUntil > 0 and delayUntil > now then
+      -- Delayed job
+      redis.call("ZADD", delayedKey, delayUntil, jobId)
+      jobStatus = "delayed"
+      redis.call("HSET", jobKey, "status", jobStatus)
+    elseif orderMs and orderingDelayMs > 0 then
+      -- Staged job (ordering)
+      local releaseAt = orderMs + orderingDelayMs
+      redis.call("ZADD", stageKey, releaseAt, jobId)
+      jobStatus = "staged"
+      redis.call("HSET", jobKey, "status", jobStatus)
+    else
+      -- Ready to process
+      jobStatus = "waiting"
+      redis.call("HSET", jobKey, "status", jobStatus)
+      -- Mark group for ready queue update (batch later)
+      groupsToUpdate[groupId] = true
+    end
+    
+    -- Store job metadata to return
+    table.insert(results, {
+      jobId,
+      groupId,
+      data,
+      "0", -- attempts
+      tostring(maxAttempts),
+      tostring(clientTimestamp),
+      tostring(orderMs),
+      tostring(delayUntil),
+      jobStatus,
+    })
+  else
+    -- Job ID already exists (idempotence) - fetch existing job data
+    local jobKey = ns .. ":job:" .. jobId
+    local jobData = redis.call("HMGET", jobKey, "id", "groupId", "data", "attempts", "maxAttempts", "timestamp", "orderMs", "delayUntil", "status")
+    if jobData[1] then
+      table.insert(results, jobData)
+    else
+      -- Shouldn't happen but handle gracefully
+      table.insert(results, {
+        jobId,
+        groupId,
+        data,
+        "0",
+        tostring(maxAttempts),
+        tostring(clientTimestamp),
+        tostring(orderMs),
+        tostring(delayUntil),
+        "waiting",
+      })
+    end
+  end
+end
+
+-- Batch update ready queue for all affected groups
+for groupId, _ in pairs(groupsToUpdate) do
+  local gZ = ns .. ":g:" .. groupId
+  local head = redis.call("ZRANGE", gZ, 0, 0, "WITHSCORES")
+  if head and #head >= 2 then
+    local headScore = tonumber(head[2])
+    redis.call("ZADD", readyKey, headScore, groupId)
+  end
+end
+
+-- Update staging timer if needed
+if orderingDelayMs > 0 then
+  local currentHead = redis.call("ZRANGE", stageKey, 0, 0, "WITHSCORES")
+  if currentHead and #currentHead >= 2 then
+    local headReleaseAt = tonumber(currentHead[2])
+    local ttlMs = math.max(1, headReleaseAt - now)
+    redis.call("SET", timerKey, "1", "PX", ttlMs)
+  end
+end
+
+return results
+

package/dist/lua/enqueue-flow.lua

@@ -0,0 +1,107 @@
+-- Atomic Flow Creation
+-- KEYS: [ns]
+-- ARGV: [parentId, parentGroupId, parentData, parentMaxAttempts, parentOrderMs, now, ...childrenArgs]
+-- childrenArgs: [id, groupId, data, maxAttempts, orderMs, delay, ...] (6 fields per child)
+
+local ns = KEYS[1]
+local parentId = ARGV[1]
+local parentGroupId = ARGV[2]
+local parentData = ARGV[3]
+local parentMaxAttempts = ARGV[4]
+local parentOrderMs = tonumber(ARGV[5])
+local now = tonumber(ARGV[6])
+
+local baseEpoch = 1704067200000
+local parentKey = ns .. ":job:" .. parentId
+local uniqueKey = ns .. ":unique:" .. parentId
+
+-- Check idempotence for parent
+if redis.call("EXISTS", uniqueKey) == 1 then
+  return nil -- Already exists
+end
+redis.call("SET", uniqueKey, parentId)
+
+local childrenCount = (#ARGV - 6) / 6
+
+-- 1. Setup Parent Job
+-- Status is 'waiting-children', NOT 'waiting'. It is NOT added to ready queue yet.
+local parentRelativeMs = parentOrderMs - baseEpoch
+local parentDaysSinceEpoch = math.floor(parentOrderMs / 86400000)
+local parentSeqKey = ns .. ":seq:" .. parentDaysSinceEpoch
+local parentSeq = redis.call("INCR", parentSeqKey)
+local parentScore = parentRelativeMs * 1000 + parentSeq
+
+redis.call("HMSET", parentKey,
+  "id", parentId,
+  "groupId", parentGroupId,
+  "data", parentData,
+  "attempts", "0",
+  "maxAttempts", parentMaxAttempts,
+  "timestamp", tostring(now),
+  "orderMs", tostring(parentOrderMs),
+  "score", tostring(parentScore),
+  "seq", tostring(parentSeq),
+  "status", "waiting-children", 
+  "flowRemaining", tostring(childrenCount)
+)
+
+-- 2. Setup Children Jobs
+local results = {}
+
+for i = 0, childrenCount - 1 do
+  local offset = 6 + (i * 6)
+  local childId = ARGV[offset + 1]
+  local childGroupId = ARGV[offset + 2]
+  local childData = ARGV[offset + 3]
+  local childMaxAttempts = ARGV[offset + 4]
+  local childOrderMs = tonumber(ARGV[offset + 5])
+  local childDelay = tonumber(ARGV[offset + 6])
+  
+  local childKey = ns .. ":job:" .. childId
+  
+  -- Generate score (replicate enqueue.lua logic)
+  local relativeMs = childOrderMs - baseEpoch
+  local daysSinceEpoch = math.floor(childOrderMs / 86400000)
+  local seqKey = ns .. ":seq:" .. daysSinceEpoch
+  local seq = redis.call("INCR", seqKey)
+  local score = relativeMs * 1000 + seq
+
+  -- Create Child Hash
+  redis.call("HMSET", childKey,
+    "id", childId,
+    "groupId", childGroupId,
+    "parentId", parentId, -- The link to parent
+    "data", childData,
+    "attempts", "0",
+    "maxAttempts", childMaxAttempts,
+    "timestamp", tostring(now),
+    "orderMs", tostring(childOrderMs),
+    "score", tostring(score),
+    "seq", tostring(seq),
+    "status", "waiting"
+  )
+  
+  redis.call("SET", ns .. ":unique:" .. childId, childId)
+  
+  -- Handle delay or immediate waiting
+  if childDelay > 0 then
+    local delayUntil = now + childDelay
+    redis.call("HSET", childKey, "delayUntil", tostring(delayUntil), "status", "delayed")
+    redis.call("ZADD", ns .. ":delayed", delayUntil, childId)
+  else
+    -- Add to group ZSET
+    local gZ = ns .. ":g:" .. childGroupId
+    redis.call("ZADD", gZ, score, childId)
+    
+    -- Update ready queue if this is the new head
+    local head = redis.call("ZRANGE", gZ, 0, 0, "WITHSCORES")
+    if head and #head >= 2 then
+      local headScore = tonumber(head[2])
+      redis.call("ZADD", ns .. ":ready", headScore, childGroupId)
+    end
+  end
+  
+  table.insert(results, childId)
+end
+
+return results

package/dist/lua/enqueue.lua

@@ -0,0 +1,154 @@
+-- argv: ns, groupId, dataJson, maxAttempts, orderMs, delayUntil, jobId, keepCompleted, clientTimestamp, orderingDelayMs
+local ns = KEYS[1]
+local groupId = ARGV[1]
+local data = ARGV[2]
+local maxAttempts = tonumber(ARGV[3])
+local orderMs = tonumber(ARGV[4])
+local delayUntil = tonumber(ARGV[5])
+local jobId = ARGV[6]
+local keepCompleted = tonumber(ARGV[7]) or 0
+local clientTimestamp = tonumber(ARGV[8])
+local orderingDelayMs = tonumber(ARGV[9]) or 0
+
+local readyKey = ns .. ":ready"
+local delayedKey = ns .. ":delayed"
+local stageKey = ns .. ":stage"
+local timerKey = ns .. ":stage:timer"
+local jobKey = ns .. ":job:" .. jobId
+local groupsKey = ns .. ":groups"
+
+-- Idempotence: ensure unique jobId per queue namespace with stale-key recovery
+local uniqueKey = ns .. ":unique:" .. jobId
+local uniqueSet = redis.call("SET", uniqueKey, jobId, "NX")
+if not uniqueSet then
+  -- Duplicate detected. Check for stale unique mapping
+  local exists = redis.call("EXISTS", jobKey)
+  if exists == 0 then
+    -- Job doesn't exist but unique key does (stale), clean up and proceed
+    redis.call("DEL", uniqueKey)
+    redis.call("SET", uniqueKey, jobId)
+  else
+    -- Job exists, check its status and location
+    local gid = redis.call("HGET", jobKey, "groupId")
+    local inProcessing = redis.call("ZSCORE", ns .. ":processing", jobId)
+    local inDelayed = redis.call("ZSCORE", ns .. ":delayed", jobId)
+    local inGroup = nil
+    if gid then
+      inGroup = redis.call("ZSCORE", ns .. ":g:" .. gid, jobId)
+    end
+    if (not inProcessing) and (not inDelayed) and (not inGroup) then
+      if keepCompleted == 0 then
+        redis.call("DEL", jobKey)
+        redis.call("DEL", uniqueKey)
+        redis.call("SET", uniqueKey, jobId)
+      else
+        -- Job hash exists and we're keeping completed jobs, ensure unique key exists
+        redis.call("SET", uniqueKey, jobId)
+        return jobId
+      end
+    else
+      if keepCompleted == 0 then
+        local status = redis.call("HGET", jobKey, "status")
+        if status == "completed" then
+          redis.call("DEL", jobKey)
+          redis.call("DEL", uniqueKey)
+          redis.call("SET", uniqueKey, jobId)
+        else
+          -- Job is still active, ensure unique key exists
+          redis.call("SET", uniqueKey, jobId)
+          return jobId
+        end
+      end
+      local activeAgain = redis.call("ZSCORE", ns .. ":processing", jobId)
+      local delayedAgain = redis.call("ZSCORE", ns .. ":delayed", jobId)
+      local inGroupAgain = nil
+      if gid then
+        inGroupAgain = redis.call("ZSCORE", ns .. ":g:" .. gid, jobId)
+      end
+      local jobStillExists = redis.call("EXISTS", jobKey)
+      if jobStillExists == 1 and (activeAgain or delayedAgain or inGroupAgain) then
+        return jobId
+      end
+    end
+  end
+end
+
+local gZ = ns .. ":g:" .. groupId
+
+if not orderMs then
+  orderMs = tonumber(redis.call("TIME")[1]) * 1000
+end
+local baseEpoch = 1704067200000
+local relativeMs = orderMs - baseEpoch
+
+-- Use date-based sequence key to auto-reset daily (prevents max int overflow)
+local daysSinceEpoch = math.floor(orderMs / 86400000)
+local seqKey = ns .. ":seq:" .. daysSinceEpoch
+local seq = redis.call("INCR", seqKey)
+local score = relativeMs * 1000 + seq
+
+-- Get Redis server time for buffering logic (to be consistent with server time)
+local timeResult = redis.call("TIME")
+local now = tonumber(timeResult[1]) * 1000 + math.floor(tonumber(timeResult[2]) / 1000)
+
+-- Use client timestamp for the job hash so timing calculations are accurate from client perspective
+local timestamp = clientTimestamp or now
+
+redis.call("HMSET", jobKey,
+  "id", jobId,
+  "groupId", groupId,
+  "data", data,
+  "attempts", "0",
+  "maxAttempts", tostring(maxAttempts),
+  "seq", tostring(seq),
+  "timestamp", tostring(timestamp),
+  "orderMs", tostring(orderMs),
+  "score", tostring(score),
+  "delayUntil", tostring(delayUntil)
+)
+
+-- Track group membership (idempotent)
+redis.call("SADD", groupsKey, groupId)
+
+-- Determine job status and placement
+local jobStatus = "waiting"
+
+if delayUntil > 0 and delayUntil > now then
+  -- Job is delayed, add to delayed set and group set
+  redis.call("ZADD", gZ, score, jobId)
+  redis.call("ZADD", delayedKey, delayUntil, jobId)
+  jobStatus = "delayed"
+  redis.call("HSET", jobKey, "status", jobStatus)
+elseif orderMs and orderingDelayMs > 0 then
+  -- Job should be staged for ordering (orderMs provided and orderingDelayMs > 0)
+  -- NOTE: Do NOT add to group ZSET yet - only to staging
+  local releaseAt = orderMs + orderingDelayMs
+  redis.call("ZADD", stageKey, releaseAt, jobId)
+  jobStatus = "staged"
+  redis.call("HSET", jobKey, "status", jobStatus)
+  
+  -- Update/set timer to earliest staged job
+  local currentHead = redis.call("ZRANGE", stageKey, 0, 0, "WITHSCORES")
+  if currentHead and #currentHead >= 2 then
+    local headReleaseAt = tonumber(currentHead[2])
+    -- Set timer to expire when the earliest job is ready
+    local ttlMs = math.max(1, headReleaseAt - now)
+    redis.call("SET", timerKey, "1", "PX", ttlMs)
+  end
+else
+  -- Job is not delayed and not staged, add to group set and make ready
+  redis.call("ZADD", gZ, score, jobId)
+  jobStatus = "waiting"
+  redis.call("HSET", jobKey, "status", jobStatus)
+  local head = redis.call("ZRANGE", gZ, 0, 0, "WITHSCORES")
+  if head and #head >= 2 then
+    local headScore = tonumber(head[2])
+    redis.call("ZADD", readyKey, headScore, groupId)
+  end
+end
+
+-- Return job data to avoid race condition where job might be processed & cleaned up
+-- before getJob() is called
+return {jobId, groupId, data, "0", tostring(maxAttempts), tostring(timestamp), tostring(orderMs), tostring(delayUntil), jobStatus}
+
+

package/dist/lua/get-active-count.lua

@@ -0,0 +1,6 @@
+-- argv: ns
+local ns = KEYS[1]
+local processingKey = ns .. ":processing"
+return redis.call("ZCARD", processingKey)
+
+

package/dist/lua/get-active-jobs.lua

@@ -0,0 +1,6 @@
+-- argv: ns
+local ns = KEYS[1]
+local processingKey = ns .. ":processing"
+return redis.call("ZRANGE", processingKey, 0, -1)
+
+

package/dist/lua/get-delayed-count.lua

@@ -0,0 +1,5 @@
+local ns = KEYS[1]
+local delayedKey = ns .. ":delayed"
+return redis.call("ZCARD", delayedKey)
+
+

package/dist/lua/get-delayed-jobs.lua

@@ -0,0 +1,5 @@
+local ns = KEYS[1]
+local delayedKey = ns .. ":delayed"
+return redis.call("ZRANGE", delayedKey, 0, -1)
+
+

package/dist/lua/get-unique-groups-count.lua

@@ -0,0 +1,13 @@
+-- argv: ns
+local ns = KEYS[1]
+local groupsKey = ns .. ":groups"
+local groupIds = redis.call("SMEMBERS", groupsKey)
+local count = 0
+for _, groupId in ipairs(groupIds) do
+  local gZ = ns .. ":g:" .. groupId
+  local jobCount = redis.call("ZCARD", gZ)
+  if jobCount > 0 then
+    count = count + 1
+  end
+end
+return count

package/dist/lua/get-unique-groups.lua

@@ -0,0 +1,15 @@
+-- argv: ns
+local ns = KEYS[1]
+local groupsKey = ns .. ":groups"
+local groupIds = redis.call("SMEMBERS", groupsKey)
+local groups = {}
+for _, groupId in ipairs(groupIds) do
+  local gZ = ns .. ":g:" .. groupId
+  local jobCount = redis.call("ZCARD", gZ)
+  if jobCount > 0 then
+    table.insert(groups, groupId)
+  end
+end
+return groups
+
+

package/dist/lua/get-waiting-count.lua

@@ -0,0 +1,11 @@
+local ns = KEYS[1]
+local groupsKey = ns .. ":groups"
+local groupIds = redis.call("SMEMBERS", groupsKey)
+local total = 0
+for _, gid in ipairs(groupIds) do
+  local gk = ns .. ":g:" .. gid
+  total = total + (redis.call("ZCARD", gk) or 0)
+end
+return total
+
+

package/dist/lua/get-waiting-jobs.lua

@@ -0,0 +1,15 @@
+-- argv: ns
+local ns = KEYS[1]
+local groupsKey = ns .. ":groups"
+local groupIds = redis.call("SMEMBERS", groupsKey)
+local jobs = {}
+for _, gid in ipairs(groupIds) do
+  local gZ = ns .. ":g:" .. gid
+  local groupJobs = redis.call("ZRANGE", gZ, 0, -1)
+  for _, jobId in ipairs(groupJobs) do
+    table.insert(jobs, jobId)
+  end
+end
+return jobs
+
+

package/dist/lua/heartbeat.lua

@@ -0,0 +1,22 @@
+-- argv: ns, jobId, groupId, extendMs
+local ns = KEYS[1]
+local jobId = ARGV[1]
+local gid = ARGV[2]
+local extendMs = tonumber(ARGV[3])
+
+-- BullMQ-style: only extend processing deadline, no group lock
+local procKey = ns .. ":processing:" .. jobId
+local exists = redis.call("EXISTS", procKey)
+if exists == 1 then
+  local now = tonumber(redis.call("TIME")[1]) * 1000
+  local newDeadline = now + extendMs
+  redis.call("HSET", procKey, "deadlineAt", tostring(newDeadline))
+  
+  -- Also update the processing ZSET score
+  local processingKey = ns .. ":processing"
+  redis.call("ZADD", processingKey, newDeadline, jobId)
+  return 1
+end
+return 0
+
+