bunqueue 2.8.54 → 2.8.56

package/dist/application/dlqManager.d.ts

@@ -19,20 +19,13 @@ export interface DlqContext {
     };
     storage: SqliteStorage | null;
 }
+export { processAutoRetry, retryDlqByFilter, retryDlqJob, retryDlqJobs, } from './dlqRetry';
 /** Get jobs from DLQ (backward compatible) */
 export declare function getDlqJobs(queue: string, ctx: DlqContext, count?: number): Job[];
 /** Get DLQ entries with full metadata */
 export declare function getDlqEntries(queue: string, ctx: DlqContext, filter?: DlqFilter): DlqEntry[];
 /** Get DLQ statistics */
 export declare function getDlqStats(queue: string, ctx: DlqContext): DlqStats;
-/** Retry a single job from DLQ */
-export declare function retryDlqJob(queue: string, jobId: JobId, ctx: DlqContext): Job | null;
-/** Retry jobs from DLQ (backward compatible) */
-export declare function retryDlqJobs(queue: string, ctx: DlqContext, jobId?: JobId, limit?: number): number;
-/** Retry jobs by filter */
-export declare function retryDlqByFilter(queue: string, ctx: DlqContext, filter: DlqFilter): number;
-/** Process auto-retry for a queue */
-export declare function processAutoRetry(queue: string, ctx: DlqContext): number;
 /** Purge expired entries from DLQ */
 export declare function purgeExpiredDlq(queue: string, ctx: DlqContext): number;
 /** Purge all jobs from DLQ */
@@ -49,6 +42,7 @@ export interface RetryCompletedContext extends DlqContext {
     } & Iterable<JobId>;
     completedJobsData: {
         get(id: JobId): Job | undefined;
+        delete(id: JobId): boolean;
     };
     jobResults: {
         delete(id: JobId): boolean;

package/dist/application/dlqManager.js

@@ -3,8 +3,9 @@
  * Dead Letter Queue operations with auto-retry, metadata, and lifecycle management
  */
 import { MAX_TIMELINE_ENTRIES } from '../domain/types/job';
-import { scheduleNextRetry } from '../domain/types/dlq';
+import { setDlqRetryState } from '../domain/types/dlq';
 import { shardIndex } from '../shared/hash';
+export { processAutoRetry, retryDlqByFilter, retryDlqJob, retryDlqJobs, } from './dlqRetry';
 /** Get jobs from DLQ (backward compatible) */
 export function getDlqJobs(queue, ctx, count) {
     const idx = shardIndex(queue);
@@ -59,152 +60,6 @@ export function getDlqStats(queue, ctx) {
     }
     return stats;
 }
-/** Retry a single job from DLQ */
-export function retryDlqJob(queue, jobId, ctx) {
-    const idx = shardIndex(queue);
-    const shard = ctx.shards[idx];
-    const now = Date.now();
-    const entry = shard.removeFromDlq(queue, jobId);
-    if (!entry)
-        return null;
-    // Delete from SQLite
-    ctx.storage?.deleteDlqEntry(jobId);
-    const job = entry.job;
-    job.attempts = 0;
-    job.runAt = now;
-    job.stallCount = 0;
-    job.lastHeartbeat = now;
-    if (job.timeline.length < MAX_TIMELINE_ENTRIES) {
-        job.timeline.push({ state: 'waiting', timestamp: now });
-    }
-    shard.getQueue(queue).push(job);
-    const isDelayed = job.runAt > now;
-    shard.incrementQueued(job.id, isDelayed, job.createdAt, queue, job.runAt);
-    ctx.jobIndex.set(job.id, { type: 'queue', shardIdx: idx, queueName: queue });
-    // Re-insert jobs row (deleted when job entered DLQ) so retry survives restart
-    ctx.storage?.insertJob(job, true);
-    return job;
-}
-/** Retry jobs from DLQ (backward compatible) */
-export function retryDlqJobs(queue, ctx, jobId, limit) {
-    if (jobId) {
-        return retryDlqJob(queue, jobId, ctx) ? 1 : 0;
-    }
-    // Bounded retry (#111-class: `retryJobs({ state:'failed', count })`). Retry
-    // only the first `limit` DLQ entries, reusing the tested single-entry path so
-    // the remaining entries stay in the DLQ (memory + SQLite) instead of the
-    // clear-all fast path below wrongly draining the whole queue. Any provided
-    // `limit` engages the bounded path; a negative/NaN/fractional cap is clamped
-    // to a safe non-negative integer so it can never fall through to clear-all
-    // (skeptic: `limit >= 0` let `-1`/`NaN` drain the entire DLQ). `undefined`
-    // (no cap requested) still means "retry all" via the fast path below.
-    if (limit !== undefined) {
-        const cap = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 0;
-        const idx = shardIndex(queue);
-        const shard = ctx.shards[idx];
-        // Snapshot ids first: retryDlqJob mutates the DLQ as it goes.
-        const ids = shard
-            .getDlqEntries(queue)
-            .slice(0, cap)
-            .map((e) => e.job.id);
-        let retried = 0;
-        for (const id of ids) {
-            if (retryDlqJob(queue, id, ctx))
-                retried++;
-        }
-        return retried;
-    }
-    const idx = shardIndex(queue);
-    const shard = ctx.shards[idx];
-    const entries = shard.getDlqEntries(queue);
-    const count = entries.length;
-    // Clear all entries from memory
-    shard.clearDlq(queue);
-    // Clear from SQLite
-    ctx.storage?.clearDlqQueue(queue);
-    const now = Date.now();
-    for (const entry of entries) {
-        const job = entry.job;
-        job.attempts = 0;
-        job.runAt = now;
-        job.stallCount = 0;
-        job.lastHeartbeat = now;
-        if (job.timeline.length < MAX_TIMELINE_ENTRIES) {
-            job.timeline.push({ state: 'waiting', timestamp: now });
-        }
-        shard.getQueue(queue).push(job);
-        const isDelayed = job.runAt > now;
-        shard.incrementQueued(job.id, isDelayed, job.createdAt, queue, job.runAt);
-        ctx.jobIndex.set(job.id, { type: 'queue', shardIdx: idx, queueName: queue });
-        ctx.storage?.insertJob(job, true);
-    }
-    return count;
-}
-/** Retry jobs by filter */
-export function retryDlqByFilter(queue, ctx, filter) {
-    const idx = shardIndex(queue);
-    const shard = ctx.shards[idx];
-    const entries = shard.getDlqFiltered(queue, filter);
-    let count = 0;
-    const now = Date.now();
-    for (const entry of entries) {
-        const removed = shard.removeFromDlq(queue, entry.job.id);
-        if (!removed)
-            continue;
-        // Delete from SQLite
-        ctx.storage?.deleteDlqEntry(entry.job.id);
-        const job = entry.job;
-        job.attempts = 0;
-        job.runAt = now;
-        job.stallCount = 0;
-        job.lastHeartbeat = now;
-        if (job.timeline.length < MAX_TIMELINE_ENTRIES) {
-            job.timeline.push({ state: 'waiting', timestamp: now });
-        }
-        shard.getQueue(queue).push(job);
-        const isDelayed = job.runAt > now;
-        shard.incrementQueued(job.id, isDelayed, job.createdAt, queue, job.runAt);
-        ctx.jobIndex.set(job.id, { type: 'queue', shardIdx: idx, queueName: queue });
-        ctx.storage?.insertJob(job, true);
-        count++;
-    }
-    return count;
-}
-/** Process auto-retry for a queue */
-export function processAutoRetry(queue, ctx) {
-    const idx = shardIndex(queue);
-    const shard = ctx.shards[idx];
-    const config = shard.getDlqConfig(queue);
-    if (!config.autoRetry)
-        return 0;
-    const now = Date.now();
-    const entries = shard.getAutoRetryEntries(queue, now);
-    let count = 0;
-    for (const entry of entries) {
-        // Update retry tracking
-        scheduleNextRetry(entry, config);
-        // Remove from DLQ
-        const removed = shard.removeFromDlq(queue, entry.job.id);
-        if (!removed)
-            continue;
-        // Re-queue job
-        const job = entry.job;
-        job.attempts = 0;
-        job.runAt = now;
-        job.stallCount = 0;
-        job.lastHeartbeat = now;
-        if (job.timeline.length < MAX_TIMELINE_ENTRIES) {
-            job.timeline.push({ state: 'waiting', timestamp: now });
-        }
-        shard.getQueue(queue).push(job);
-        const isDelayed = job.runAt > now;
-        shard.incrementQueued(job.id, isDelayed, job.createdAt, queue, job.runAt);
-        ctx.jobIndex.set(job.id, { type: 'queue', shardIdx: idx, queueName: queue });
-        ctx.storage?.insertJob(job, true);
-        count++;
-    }
-    return count;
-}
 /** Purge expired entries from DLQ */
 export function purgeExpiredDlq(queue, ctx) {
     const idx = shardIndex(queue);
@@ -290,22 +145,38 @@ export function retryCompletedJobs(queue, ctx, jobId, options = {}) {
 }
 /** Requeue a single completed job */
 function requeueCompletedJob(job, ctx) {
-    job.attempts = 0;
-    job.startedAt = null;
-    job.completedAt = null;
-    job.runAt = Date.now();
-    job.progress = 0;
-    if (job.timeline.length < MAX_TIMELINE_ENTRIES) {
-        job.timeline.push({ state: 'waiting', timestamp: job.runAt });
+    const now = Date.now();
+    const timeline = [...job.timeline];
+    if (timeline.length < MAX_TIMELINE_ENTRIES) {
+        timeline.push({ state: 'waiting', timestamp: now });
     }
-    const idx = shardIndex(job.queue);
+    const requeued = {
+        ...job,
+        attempts: 0,
+        startedAt: null,
+        completedAt: null,
+        runAt: now,
+        progress: 0,
+        progressMessage: null,
+        lastHeartbeat: now,
+        timeline,
+    };
+    setDlqRetryState(requeued, null);
+    // Commit the durable transition before publishing the new in-memory state.
+    // A SQLite failure therefore leaves the completed generation authoritative.
+    ctx.storage?.requeueCompletedJob(requeued);
+    const idx = shardIndex(requeued.queue);
     const shard = ctx.shards[idx];
-    shard.getQueue(job.queue).push(job);
-    shard.incrementQueued(job.id, false, job.createdAt, job.queue, job.runAt);
-    ctx.jobIndex.set(job.id, { type: 'queue', shardIdx: idx, queueName: job.queue });
-    ctx.completedJobs.delete(job.id);
-    ctx.jobResults.delete(job.id);
-    ctx.storage?.updateForRetry(job);
-    shard.notify(job.queue);
+    shard.getQueue(requeued.queue).push(requeued);
+    shard.incrementQueued(requeued.id, false, requeued.createdAt, requeued.queue, requeued.runAt);
+    ctx.jobIndex.set(requeued.id, {
+        type: 'queue',
+        shardIdx: idx,
+        queueName: requeued.queue,
+    });
+    ctx.completedJobs.delete(requeued.id);
+    ctx.completedJobsData.delete(requeued.id);
+    ctx.jobResults.delete(requeued.id);
+    shard.notify(requeued.queue);
     return 1;
 }

package/dist/application/dlqRetry.d.ts

@@ -0,0 +1,12 @@
+/** DLQ manual and automatic retry transitions. */
+import { type Job, type JobId } from '../domain/types/job';
+import type { DlqFilter } from '../domain/types/dlq';
+import type { DlqContext } from './dlqManager';
+/** Retry a single job from DLQ and reset the automatic retry generation. */
+export declare function retryDlqJob(queue: string, jobId: JobId, ctx: DlqContext): Job | null;
+/** Retry jobs from DLQ, optionally bounded to the oldest `limit` entries. */
+export declare function retryDlqJobs(queue: string, ctx: DlqContext, jobId?: JobId, limit?: number): number;
+/** Retry all DLQ entries selected by a metadata filter. */
+export declare function retryDlqByFilter(queue: string, ctx: DlqContext, filter: DlqFilter): number;
+/** Dispatch due auto-retries while preserving their bounded retry chain. */
+export declare function processAutoRetry(queue: string, ctx: DlqContext): number;

package/dist/application/dlqRetry.js

@@ -0,0 +1,97 @@
+/** DLQ manual and automatic retry transitions. */
+import { MAX_TIMELINE_ENTRIES } from '../domain/types/job';
+import { retainDlqRetryState, scheduleNextRetry, setDlqRetryState } from '../domain/types/dlq';
+import { shardIndex } from '../shared/hash';
+function prepareRetry(job, now) {
+    job.attempts = 0;
+    job.runAt = now;
+    job.startedAt = null;
+    job.stallCount = 0;
+    job.lastHeartbeat = now;
+    if (job.timeline.length < MAX_TIMELINE_ENTRIES) {
+        job.timeline.push({ state: 'waiting', timestamp: now });
+    }
+}
+function enqueueRetry(queue, job, now, ctx) {
+    const idx = shardIndex(queue);
+    const shard = ctx.shards[idx];
+    prepareRetry(job, now);
+    shard.getQueue(queue).push(job);
+    shard.incrementQueued(job.id, job.runAt > now, job.createdAt, queue, job.runAt);
+    ctx.jobIndex.set(job.id, { type: 'queue', shardIdx: idx, queueName: queue });
+    ctx.storage?.requeueDlqJob(job);
+}
+/** Retry a single job from DLQ and reset the automatic retry generation. */
+export function retryDlqJob(queue, jobId, ctx) {
+    const shard = ctx.shards[shardIndex(queue)];
+    const entry = shard.removeFromDlq(queue, jobId);
+    if (!entry)
+        return null;
+    setDlqRetryState(entry.job, null);
+    enqueueRetry(queue, entry.job, Date.now(), ctx);
+    return entry.job;
+}
+/** Retry jobs from DLQ, optionally bounded to the oldest `limit` entries. */
+export function retryDlqJobs(queue, ctx, jobId, limit) {
+    if (jobId)
+        return retryDlqJob(queue, jobId, ctx) ? 1 : 0;
+    const shard = ctx.shards[shardIndex(queue)];
+    if (limit !== undefined) {
+        const cap = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 0;
+        const ids = shard
+            .getDlqEntries(queue)
+            .slice(0, cap)
+            .map((entry) => entry.job.id);
+        let retried = 0;
+        for (const id of ids) {
+            if (retryDlqJob(queue, id, ctx))
+                retried++;
+        }
+        return retried;
+    }
+    const entries = [...shard.getDlqEntries(queue)];
+    shard.clearDlq(queue);
+    ctx.storage?.clearDlqQueue(queue);
+    const now = Date.now();
+    for (const entry of entries) {
+        setDlqRetryState(entry.job, null);
+        enqueueRetry(queue, entry.job, now, ctx);
+    }
+    return entries.length;
+}
+/** Retry all DLQ entries selected by a metadata filter. */
+export function retryDlqByFilter(queue, ctx, filter) {
+    const shard = ctx.shards[shardIndex(queue)];
+    const entries = [...shard.getDlqFiltered(queue, filter)];
+    const now = Date.now();
+    let retried = 0;
+    for (const entry of entries) {
+        const removed = shard.removeFromDlq(queue, entry.job.id);
+        if (!removed)
+            continue;
+        setDlqRetryState(removed.job, null);
+        enqueueRetry(queue, removed.job, now, ctx);
+        retried++;
+    }
+    return retried;
+}
+/** Dispatch due auto-retries while preserving their bounded retry chain. */
+export function processAutoRetry(queue, ctx) {
+    const shard = ctx.shards[shardIndex(queue)];
+    const config = shard.getDlqConfig(queue);
+    if (!config.autoRetry)
+        return 0;
+    const now = Date.now();
+    const entries = [...shard.getAutoRetryEntries(queue, now)];
+    let retried = 0;
+    for (const entry of entries) {
+        const removed = shard.removeFromDlq(queue, entry.job.id);
+        if (!removed)
+            continue;
+        scheduleNextRetry(removed, config);
+        retainDlqRetryState(removed.job, removed);
+        enqueueRetry(queue, removed.job, now, ctx);
+        retried++;
+    }
+    return retried;
+}

package/dist/application/lockManager.js

@@ -3,6 +3,7 @@
  * Handles BullMQ-style lock-based job ownership
  */
 import { isLockExpired } from '../domain/types/job';
+import { recordJobFailureAttempt } from '../domain/types/dlq';
 import { shardIndex, processingShardIndex } from '../shared/hash';
 import { withWriteLock } from '../shared/lock';
 // Re-export lock operations
@@ -59,6 +60,13 @@ export async function checkExpiredLocks(ctx) {
             for (const [procIdx, items] of procMap) {
                 await withWriteLock(ctx.processingLocks[procIdx], async () => {
                     for (const { jobId, lock, job } of items) {
+                        const currentJob = ctx.processingShards[procIdx].get(jobId);
+                        const currentLock = ctx.jobLocks.get(jobId);
+                        if (currentJob !== job ||
+                            currentLock !== lock ||
+                            !isLockExpired(currentLock, Date.now())) {
+                            continue;
+                        }
                         processExpiredLockInner(jobId, lock, job, shardIdx, procIdx, ctx, now);
                     }
                 });
@@ -76,11 +84,13 @@ function processExpiredLockInner(jobId, lock, job, shardIdx, procIdx, ctx, now)
     const queue = shard.getQueue(job.queue);
     // Remove from processing
     ctx.processingShards[procIdx].delete(jobId);
+    ctx.timeoutScheduler.cancel(jobId);
     // Discard cron jobs with preventOverlap instead of re-queuing (#75).
     // During graceful shutdown, heartbeats stop and the lock expires before
     // the job finishes. Re-queuing would cause "starts right away on reconnect".
     // The cron scheduler will re-create the job at the next scheduled tick.
     if (job.uniqueKey?.startsWith('cron:')) {
+        ctx.retiredCronLeaseTokens.set(jobId, lock.token);
         shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
         ctx.jobIndex.delete(jobId);
         ctx.storage?.deleteJob(jobId);
@@ -89,7 +99,6 @@ function processExpiredLockInner(jobId, lock, job, shardIdx, procIdx, ctx, now)
     }
     // Increment attempts and reset state
     job.attempts++;
-    job.startedAt = null;
     job.lastHeartbeat = now;
     job.stallCount++;
     // A lost lock consumes both retry budgets. Never requeue beyond either bound.
@@ -128,6 +137,7 @@ function handleRecoveryBoundExceeded(opts) {
     const entry = shard.addToDlq(job, attemptsExhausted ? "max_attempts_exceeded" /* FailureReason.MaxAttemptsExceeded */ : "stalled" /* FailureReason.Stalled */, attemptsExhausted
         ? `Lock expired at max attempts (${job.maxAttempts})`
         : `Lock expired after ${lock.renewalCount} renewals`);
+    job.startedAt = null;
     ctx.jobIndex.set(jobId, { type: 'dlq', queueName: job.queue });
     // Persist the DLQ move like the sibling paths (ack.moveFailedJobToDlq,
     // stallDetection.moveStalliedJobToDlq, backgroundTasks startup-recovery).
@@ -136,6 +146,13 @@ function handleRecoveryBoundExceeded(opts) {
     // surviving row and throws `UNIQUE constraint failed: jobs.id` (#97).
     ctx.storage?.saveDlqEntry(entry);
     ctx.storage?.deleteJob(jobId);
+    ctx.eventsManager.broadcast({
+        eventType: "stalled" /* EventType.Stalled */,
+        jobId,
+        queue: job.queue,
+        timestamp: now,
+        data: { stallCount: job.stallCount, action: "move_to_dlq" /* StallAction.MoveToDlq */ },
+    });
     ctx.eventsManager.broadcast({
         eventType: "failed" /* EventType.Failed */,
         jobId,
@@ -150,6 +167,8 @@ function handleRecoveryBoundExceeded(opts) {
 function requeueExpiredJob(opts) {
     const { jobId, job, queue, idx, ctx, now } = opts;
     const shard = ctx.shards[idx];
+    recordJobFailureAttempt(job, "stalled" /* FailureReason.Stalled */, 'Lock expired', now);
+    job.startedAt = null;
     // Release the concurrency slot (+group+uniqueKey) acquired at pull before
     // re-pushing — otherwise the slot leaks and the queue wedges (mirrors
     // stallDetection.retryStalliedJob).
@@ -158,6 +177,7 @@ function requeueExpiredJob(opts) {
     const isDelayed = job.runAt > now;
     shard.incrementQueued(jobId, isDelayed, job.createdAt, job.queue, job.runAt);
     ctx.jobIndex.set(jobId, { type: 'queue', shardIdx: idx, queueName: job.queue });
+    ctx.storage?.updateForRetry(job);
     shard.notify(job.queue);
     ctx.eventsManager.broadcast({
         eventType: "stalled" /* EventType.Stalled */,

package/dist/application/lockOperations.js

@@ -10,9 +10,22 @@ export function createLock(jobId, owner, ctx, ttl = DEFAULT_LOCK_TTL) {
     const loc = ctx.jobIndex.get(jobId);
     if (loc?.type !== 'processing')
         return null;
-    // Check if lock already exists (shouldn't happen, but defensive)
-    if (ctx.jobLocks.has(jobId)) {
-        return null;
+    const existing = ctx.jobLocks.get(jobId);
+    if (existing) {
+        const job = ctx.processingShards[loc.shardIdx].get(jobId);
+        const isNewGeneration = job?.startedAt !== null && job?.startedAt !== undefined && job.startedAt > existing.createdAt;
+        if (!isNewGeneration)
+            return null;
+        // Stall retry deliberately leaves the previous lease as a stale-outcome
+        // guard. Once that job is pulled again, replace the lease and detach the
+        // old connection before the new connection registers ownership.
+        ctx.jobLocks.delete(jobId);
+        for (const [clientId, jobs] of ctx.clientJobs) {
+            if (!jobs.delete(jobId))
+                continue;
+            if (jobs.size === 0)
+                ctx.clientJobs.delete(clientId);
+        }
     }
     const lock = createJobLock(jobId, owner, ttl);
     ctx.jobLocks.set(jobId, lock);

package/dist/application/operations/ack/batch.d.ts

@@ -0,0 +1,8 @@
+import type { JobId } from '../../../domain/types/job';
+import type { AckContext, CompletionOptions } from '../../types/ack';
+export declare function ackJobBatch(jobIds: JobId[], ctx: AckContext, leaseTokens?: Array<string | undefined>): Promise<boolean[]>;
+export declare function ackJobBatchWithResults(items: Array<{
+    id: JobId;
+    result: unknown;
+    token?: string;
+} & CompletionOptions>, ctx: AckContext): Promise<boolean[]>;

package/dist/application/operations/ack/batch.js

@@ -0,0 +1,64 @@
+import { extractJobs, extractJobsWithResults, finalizeBatchAck, groupByProcShard, groupByQueueShard, groupItemsByProcShard, releaseResources, } from '../ackHelpers';
+import { ackJob } from './completion';
+function notifyReleasedQueues(shard, jobs) {
+    const releasedByQueue = new Map();
+    for (const job of jobs) {
+        releasedByQueue.set(job.queue, (releasedByQueue.get(job.queue) ?? 0) + 1);
+    }
+    for (const [queue, count] of releasedByQueue)
+        shard.notifyBatch(queue, count);
+}
+function alignApplied(jobIds, appliedIds) {
+    const counts = new Map();
+    for (const id of appliedIds)
+        counts.set(id, (counts.get(id) ?? 0) + 1);
+    return jobIds.map((id) => {
+        const remaining = counts.get(id) ?? 0;
+        if (remaining === 0)
+            return false;
+        counts.set(id, remaining - 1);
+        return true;
+    });
+}
+export async function ackJobBatch(jobIds, ctx, leaseTokens) {
+    if (jobIds.length === 0)
+        return [];
+    if (jobIds.length <= 4) {
+        return Promise.all(jobIds.map((id, index) => ackJob(id, undefined, ctx, { leaseToken: leaseTokens?.[index] })));
+    }
+    const batchContext = {
+        processingShards: ctx.processingShards,
+        processingLocks: ctx.processingLocks,
+        shards: ctx.shards,
+        shardLocks: ctx.shardLocks,
+    };
+    const byProcessingShard = groupByProcShard(jobIds);
+    const extractedJobs = await extractJobs(byProcessingShard, batchContext);
+    const byQueueShard = groupByQueueShard(extractedJobs);
+    await releaseResources(byQueueShard, batchContext);
+    for (const [index, jobs] of byQueueShard)
+        notifyReleasedQueues(ctx.shards[index], jobs);
+    finalizeBatchAck(extractedJobs, ctx, false);
+    return alignApplied(jobIds, extractedJobs.map((entry) => entry.id));
+}
+export async function ackJobBatchWithResults(items, ctx) {
+    if (items.length === 0)
+        return [];
+    if (items.length <= 4) {
+        return Promise.all(items.map((item) => ackJob(item.id, item.result, ctx, { ...item, leaseToken: item.token })));
+    }
+    const batchContext = {
+        processingShards: ctx.processingShards,
+        processingLocks: ctx.processingLocks,
+        shards: ctx.shards,
+        shardLocks: ctx.shardLocks,
+    };
+    const byProcessingShard = groupItemsByProcShard(items);
+    const extractedJobs = await extractJobsWithResults(byProcessingShard, batchContext);
+    const byQueueShard = groupByQueueShard(extractedJobs);
+    await releaseResources(byQueueShard, batchContext);
+    for (const [index, jobs] of byQueueShard)
+        notifyReleasedQueues(ctx.shards[index], jobs);
+    finalizeBatchAck(extractedJobs, ctx, true);
+    return alignApplied(items.map((item) => item.id), extractedJobs.map((entry) => entry.id));
+}

package/dist/application/operations/ack/completion.d.ts

@@ -0,0 +1,3 @@
+import { type JobId } from '../../../domain/types/job';
+import type { AckContext, CompletionOptions } from '../../types/ack';
+export declare function ackJob(jobId: JobId, result: unknown, ctx: AckContext, options?: CompletionOptions): Promise<boolean>;

package/dist/application/operations/ack/completion.js

@@ -0,0 +1,74 @@
+import { setDlqRetryState } from '../../../domain/types/dlq';
+import { MAX_TIMELINE_ENTRIES } from '../../../domain/types/job';
+import { processingShardIndex, shardIndex } from '../../../shared/hash';
+import { withWriteLock } from '../../../shared/lock';
+import { commitRemovedCompletion } from '../../dependencyCompletions';
+import { latencyTracker } from '../../latencyTracker';
+import { throughputTracker } from '../../throughputTracker';
+export async function ackJob(jobId, result, ctx, options = {}) {
+    const startNs = Bun.nanoseconds();
+    const processingIndex = processingShardIndex(jobId);
+    const job = await withWriteLock(ctx.processingLocks[processingIndex], () => {
+        const job = ctx.processingShards[processingIndex].get(jobId);
+        if (job)
+            ctx.processingShards[processingIndex].delete(jobId);
+        return job;
+    });
+    if (!job)
+        return false;
+    const index = shardIndex(job.queue);
+    await withWriteLock(ctx.shardLocks[index], () => {
+        const shard = ctx.shards[index];
+        shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
+        shard.notify(job.queue);
+    });
+    if (job.customId && ctx.customIdMap)
+        ctx.customIdMap.delete(job.customId);
+    setDlqRetryState(job, null);
+    if (!(job.removeOnComplete || options.removeOnComplete === true)) {
+        const now = Date.now();
+        job.completedAt = now;
+        if (job.timeline.length < MAX_TIMELINE_ENTRIES) {
+            job.timeline.push({ state: 'completed', timestamp: now });
+        }
+        ctx.completedJobs.add(jobId);
+        ctx.completedJobsData.set(jobId, job);
+        if (result !== undefined) {
+            ctx.jobResults.set(jobId, result);
+            ctx.storage?.storeResult(jobId, result);
+        }
+        ctx.jobIndex.set(jobId, { type: 'completed', queueName: job.queue });
+        ctx.storage?.markCompleted(jobId, now, job.timeline);
+    }
+    else {
+        commitRemovedCompletion(job, ctx);
+        ctx.jobIndex.delete(jobId);
+    }
+    if (result !== undefined)
+        ctx.dependencyResults.retain(jobId, result);
+    ctx.dependencyResults.releaseConsumer(jobId);
+    ctx.totalCompleted.value++;
+    if (ctx.perQueueMetrics) {
+        const queueMetrics = ctx.perQueueMetrics.get(job.queue);
+        if (queueMetrics)
+            queueMetrics.totalCompleted++;
+        else
+            ctx.perQueueMetrics.set(job.queue, { totalCompleted: 1n, totalFailed: 0n });
+    }
+    throughputTracker.completeRate.increment();
+    ctx.broadcast({
+        eventType: 'completed',
+        queue: job.queue,
+        jobId,
+        timestamp: Date.now(),
+        data: result,
+    });
+    ctx.onJobCompleted(jobId);
+    if (job.repeat && ctx.onRepeat) {
+        const shouldRepeat = job.repeat.limit === undefined || job.repeat.count < job.repeat.limit;
+        if (shouldRepeat)
+            ctx.onRepeat(job);
+    }
+    latencyTracker.ack.observe((Bun.nanoseconds() - startNs) / 1e6);
+    return true;
+}

package/dist/application/operations/ack/failure.d.ts

@@ -0,0 +1,3 @@
+import { type JobId } from '../../../domain/types/job';
+import type { AckContext, FailJobOptions } from '../../types/ack';
+export declare function failJob(jobId: JobId, error: string | undefined, ctx: AckContext, options?: FailJobOptions): Promise<void>;