bunqueue 1.9.1 → 1.9.3

package/dist/application/queueManager.js

@@ -2,7 +2,7 @@
  * Queue Manager
  * Core orchestrator for all queue operations
  */
-import { calculateBackoff } from '../domain/types/job';
+import { calculateBackoff, createJobLock, isLockExpired, renewLock, DEFAULT_LOCK_TTL, } from '../domain/types/job';
 import { queueLog } from '../shared/logger';
 import { getStallAction, incrementStallCount } from '../domain/types/stall';
 import { Shard } from '../domain/queue/shard';
@@ -55,6 +55,15 @@ export class QueueManager {
     // Deferred dependency resolution queue (to avoid lock order violations)
     pendingDepChecks = new Set();
     depCheckInterval = null;
+    // Two-phase stall detection (like BullMQ)
+    // Jobs are added here on first check, confirmed stalled on second check
+    stalledCandidates = new Set();
+    // Lock-based job ownership tracking (BullMQ-style)
+    // Maps jobId to lock info (token, owner, expiration)
+    jobLocks = new Map();
+    // Client-job tracking for connection-based release
+    // When a TCP connection closes, all jobs owned by that client are released
+    clientJobs = new Map();
     // Cron scheduler
     cronScheduler;
     // Managers
@@ -76,6 +85,7 @@ export class QueueManager {
     timeoutInterval = null;
     stallCheckInterval = null;
     dlqMaintenanceInterval = null;
+    lockCheckInterval = null;
     // Queue names cache for O(1) listQueues instead of O(32 * queues)
     queueNamesCache = new Set();
     constructor(config = {}) {
@@ -224,29 +234,98 @@ export class QueueManager {
     async pull(queue, timeoutMs = 0) {
         return pullJob(queue, timeoutMs, this.getPullContext());
     }
+    /**
+     * Pull a job and create a lock for it (BullMQ-style).
+     * Returns both the job and its lock token for ownership verification.
+     */
+    async pullWithLock(queue, owner, timeoutMs = 0, lockTtl = DEFAULT_LOCK_TTL) {
+        const job = await pullJob(queue, timeoutMs, this.getPullContext());
+        if (!job)
+            return { job: null, token: null };
+        const token = this.createLock(job.id, owner, lockTtl);
+        return { job, token };
+    }
     /** Pull multiple jobs in single lock acquisition - O(1) instead of O(n) locks */
     async pullBatch(queue, count, timeoutMs = 0) {
         return pullJobBatch(queue, count, timeoutMs, this.getPullContext());
     }
-    async ack(jobId, result) {
-        return ackJob(jobId, result, this.getAckContext());
+    /**
+     * Pull multiple jobs and create locks for them (BullMQ-style).
+     * Returns both jobs and their lock tokens for ownership verification.
+     */
+    async pullBatchWithLock(queue, count, owner, timeoutMs = 0, lockTtl = DEFAULT_LOCK_TTL) {
+        const jobs = await pullJobBatch(queue, count, timeoutMs, this.getPullContext());
+        const tokens = [];
+        for (const job of jobs) {
+            const token = this.createLock(job.id, owner, lockTtl);
+            tokens.push(token ?? '');
+        }
+        return { jobs, tokens };
+    }
+    async ack(jobId, result, token) {
+        // If token provided, verify ownership before acknowledging
+        if (token && !this.verifyLock(jobId, token)) {
+            throw new Error(`Invalid or expired lock token for job ${jobId}`);
+        }
+        await ackJob(jobId, result, this.getAckContext());
+        // Release lock after successful ack
+        this.releaseLock(jobId, token);
     }
     /** Acknowledge multiple jobs in parallel with Promise.all */
-    async ackBatch(jobIds) {
-        return ackJobBatch(jobIds, this.getAckContext());
+    async ackBatch(jobIds, tokens) {
+        // Verify all tokens first if provided
+        if (tokens?.length === jobIds.length) {
+            for (let i = 0; i < jobIds.length; i++) {
+                const t = tokens[i];
+                if (t && !this.verifyLock(jobIds[i], t)) {
+                    throw new Error(`Invalid or expired lock token for job ${jobIds[i]}`);
+                }
+            }
+        }
+        await ackJobBatch(jobIds, this.getAckContext());
+        // Release locks after successful ack
+        if (tokens) {
+            for (let i = 0; i < jobIds.length; i++) {
+                this.releaseLock(jobIds[i], tokens[i]);
+            }
+        }
     }
     /** Acknowledge multiple jobs with individual results - batch optimized */
     async ackBatchWithResults(items) {
-        return ackJobBatchWithResults(items, this.getAckContext());
+        // Verify all tokens first if provided
+        for (const item of items) {
+            if (item.token && !this.verifyLock(item.id, item.token)) {
+                throw new Error(`Invalid or expired lock token for job ${item.id}`);
+            }
+        }
+        await ackJobBatchWithResults(items, this.getAckContext());
+        // Release locks after successful ack
+        for (const item of items) {
+            this.releaseLock(item.id, item.token);
+        }
     }
-    async fail(jobId, error) {
-        return failJob(jobId, error, this.getAckContext());
+    async fail(jobId, error, token) {
+        // If token provided, verify ownership before failing
+        if (token && !this.verifyLock(jobId, token)) {
+            throw new Error(`Invalid or expired lock token for job ${jobId}`);
+        }
+        await failJob(jobId, error, this.getAckContext());
+        // Release lock after fail
+        this.releaseLock(jobId, token);
     }
-    /** Update job heartbeat for stall detection (single job) */
-    jobHeartbeat(jobId) {
+    /**
+     * Update job heartbeat for stall detection (single job).
+     * If token is provided, also renews the lock.
+     */
+    jobHeartbeat(jobId, token) {
         const loc = this.jobIndex.get(jobId);
         if (loc?.type !== 'processing')
             return false;
+        // If token provided, renew lock (which also updates heartbeat)
+        if (token) {
+            return this.renewJobLock(jobId, token);
+        }
+        // Legacy mode: just update heartbeat without token verification
         const processing = this.processingShards[loc.shardIdx];
         const job = processing.get(jobId);
         if (job) {
@@ -255,15 +334,263 @@ export class QueueManager {
         }
         return false;
     }
-    /** Update job heartbeat for multiple jobs (batch) */
-    jobHeartbeatBatch(jobIds) {
+    /**
+     * Update job heartbeat for multiple jobs (batch).
+     * If tokens are provided, also renews the locks.
+     */
+    jobHeartbeatBatch(jobIds, tokens) {
         let count = 0;
-        for (const id of jobIds) {
-            if (this.jobHeartbeat(id))
+        for (let i = 0; i < jobIds.length; i++) {
+            const token = tokens?.[i];
+            if (this.jobHeartbeat(jobIds[i], token))
                 count++;
         }
         return count;
     }
+    // ============ Lock Management (BullMQ-style) ============
+    /**
+     * Create a lock for a job when it's pulled for processing.
+     * @returns The lock token, or null if job not in processing
+     */
+    createLock(jobId, owner, ttl = DEFAULT_LOCK_TTL) {
+        const loc = this.jobIndex.get(jobId);
+        if (loc?.type !== 'processing')
+            return null;
+        // Check if lock already exists (shouldn't happen, but defensive)
+        if (this.jobLocks.has(jobId)) {
+            queueLog.warn('Lock already exists for job', { jobId: String(jobId), owner });
+            return null;
+        }
+        const lock = createJobLock(jobId, owner, ttl);
+        this.jobLocks.set(jobId, lock);
+        return lock.token;
+    }
+    /**
+     * Verify that a token is valid for a job.
+     * @returns true if token matches the active lock
+     */
+    verifyLock(jobId, token) {
+        const lock = this.jobLocks.get(jobId);
+        if (!lock)
+            return false;
+        if (lock.token !== token)
+            return false;
+        if (isLockExpired(lock))
+            return false;
+        return true;
+    }
+    /**
+     * Renew a lock with the given token.
+     * @returns true if renewal succeeded, false if token invalid or lock expired
+     */
+    renewJobLock(jobId, token, newTtl) {
+        const lock = this.jobLocks.get(jobId);
+        if (!lock)
+            return false;
+        if (lock.token !== token)
+            return false;
+        if (isLockExpired(lock)) {
+            // Lock already expired, remove it
+            this.jobLocks.delete(jobId);
+            return false;
+        }
+        renewLock(lock, newTtl);
+        // Also update lastHeartbeat on the job (for legacy stall detection compatibility)
+        const loc = this.jobIndex.get(jobId);
+        if (loc?.type === 'processing') {
+            const job = this.processingShards[loc.shardIdx].get(jobId);
+            if (job)
+                job.lastHeartbeat = Date.now();
+        }
+        return true;
+    }
+    /**
+     * Renew locks for multiple jobs (batch operation).
+     * @returns Array of jobIds that were successfully renewed
+     */
+    renewJobLockBatch(items) {
+        const renewed = [];
+        for (const item of items) {
+            if (this.renewJobLock(item.id, item.token, item.ttl)) {
+                renewed.push(String(item.id));
+            }
+        }
+        return renewed;
+    }
+    /**
+     * Release a lock when job is completed or failed.
+     * Should be called by ACK/FAIL operations.
+     */
+    releaseLock(jobId, token) {
+        const lock = this.jobLocks.get(jobId);
+        if (!lock)
+            return true; // No lock to release
+        // If token provided, verify it matches
+        if (token && lock.token !== token) {
+            queueLog.warn('Token mismatch on lock release', {
+                jobId: String(jobId),
+                expected: lock.token.substring(0, 8),
+                got: token.substring(0, 8),
+            });
+            return false;
+        }
+        this.jobLocks.delete(jobId);
+        return true;
+    }
+    /**
+     * Get lock info for a job (for debugging/monitoring).
+     */
+    getLockInfo(jobId) {
+        return this.jobLocks.get(jobId) ?? null;
+    }
+    // ============ Client-Job Tracking ============
+    /**
+     * Register a job as owned by a client (called on PULL).
+     */
+    registerClientJob(clientId, jobId) {
+        let jobs = this.clientJobs.get(clientId);
+        if (!jobs) {
+            jobs = new Set();
+            this.clientJobs.set(clientId, jobs);
+        }
+        jobs.add(jobId);
+    }
+    /**
+     * Unregister a job from a client (called on ACK/FAIL).
+     */
+    unregisterClientJob(clientId, jobId) {
+        if (!clientId)
+            return;
+        const jobs = this.clientJobs.get(clientId);
+        if (jobs) {
+            jobs.delete(jobId);
+            if (jobs.size === 0) {
+                this.clientJobs.delete(clientId);
+            }
+        }
+    }
+    /**
+     * Release all jobs owned by a client back to queue (called on TCP disconnect).
+     * Returns the number of jobs released.
+     */
+    releaseClientJobs(clientId) {
+        const jobs = this.clientJobs.get(clientId);
+        if (!jobs || jobs.size === 0) {
+            this.clientJobs.delete(clientId);
+            return 0;
+        }
+        let released = 0;
+        const now = Date.now();
+        for (const jobId of jobs) {
+            const loc = this.jobIndex.get(jobId);
+            if (loc?.type !== 'processing')
+                continue;
+            const procIdx = loc.shardIdx;
+            const job = this.processingShards[procIdx].get(jobId);
+            if (!job)
+                continue;
+            // Remove from processing
+            this.processingShards[procIdx].delete(jobId);
+            // Release lock if exists
+            this.jobLocks.delete(jobId);
+            // Release concurrency
+            const idx = shardIndex(job.queue);
+            const shard = this.shards[idx];
+            shard.releaseConcurrency(job.queue);
+            // Release group if active
+            if (job.groupId) {
+                shard.releaseGroup(job.queue, job.groupId);
+            }
+            // Reset job state for retry
+            job.startedAt = null;
+            job.lastHeartbeat = now;
+            // Re-queue the job
+            shard.getQueue(job.queue).push(job);
+            const isDelayed = job.runAt > now;
+            shard.incrementQueued(jobId, isDelayed, job.createdAt, job.queue, job.runAt);
+            this.jobIndex.set(jobId, { type: 'queue', shardIdx: idx, queueName: job.queue });
+            released++;
+        }
+        // Clear client tracking
+        this.clientJobs.delete(clientId);
+        if (released > 0) {
+            queueLog.info('Released client jobs', { clientId: clientId.substring(0, 8), released });
+        }
+        return released;
+    }
+    /**
+     * Check and handle expired locks.
+     * Jobs with expired locks are requeued for retry.
+     */
+    checkExpiredLocks() {
+        const now = Date.now();
+        const expired = [];
+        for (const [jobId, lock] of this.jobLocks) {
+            if (isLockExpired(lock, now)) {
+                expired.push({ jobId, lock });
+            }
+        }
+        for (const { jobId, lock } of expired) {
+            const procIdx = processingShardIndex(String(jobId));
+            const job = this.processingShards[procIdx].get(jobId);
+            if (job) {
+                const idx = shardIndex(job.queue);
+                const shard = this.shards[idx];
+                const queue = shard.getQueue(job.queue);
+                // Remove from processing
+                this.processingShards[procIdx].delete(jobId);
+                // Increment attempts and reset state
+                job.attempts++;
+                job.startedAt = null;
+                job.lastHeartbeat = now;
+                job.stallCount++;
+                // Check if max stalls exceeded
+                const stallConfig = shard.getStallConfig(job.queue);
+                if (stallConfig.maxStalls > 0 && job.stallCount >= stallConfig.maxStalls) {
+                    // Move to DLQ using shard's addToDlq method
+                    shard.addToDlq(job, "stalled" /* FailureReason.Stalled */, `Lock expired after ${lock.renewalCount} renewals`);
+                    this.jobIndex.set(jobId, { type: 'dlq', queueName: job.queue });
+                    queueLog.warn('Job moved to DLQ due to lock expiration', {
+                        jobId: String(jobId),
+                        queue: job.queue,
+                        owner: lock.owner,
+                        renewals: lock.renewalCount,
+                        stallCount: job.stallCount,
+                    });
+                    this.eventsManager.broadcast({
+                        eventType: "failed" /* EventType.Failed */,
+                        jobId,
+                        queue: job.queue,
+                        timestamp: now,
+                        error: 'Lock expired (max stalls reached)',
+                    });
+                }
+                else {
+                    // Requeue for retry (always push - priority queue handles ordering)
+                    queue.push(job);
+                    this.jobIndex.set(jobId, { type: 'queue', shardIdx: idx, queueName: job.queue });
+                    queueLog.info('Job requeued due to lock expiration', {
+                        jobId: String(jobId),
+                        queue: job.queue,
+                        owner: lock.owner,
+                        renewals: lock.renewalCount,
+                        attempt: job.attempts,
+                    });
+                    this.eventsManager.broadcast({
+                        eventType: "stalled" /* EventType.Stalled */,
+                        jobId,
+                        queue: job.queue,
+                        timestamp: now,
+                    });
+                }
+            }
+            // Remove the expired lock
+            this.jobLocks.delete(jobId);
+        }
+        if (expired.length > 0) {
+            queueLog.info('Processed expired locks', { count: expired.length });
+        }
+    }
     // ============ Query Operations (delegated) ============
     async getJob(jobId) {
         return queryOps.getJob(jobId, this.getQueryContext());
@@ -528,6 +855,10 @@ export class QueueManager {
         this.dlqMaintenanceInterval = setInterval(() => {
             this.performDlqMaintenance();
         }, this.config.dlqMaintenanceMs);
+        // Lock expiration check runs at same interval as stall check
+        this.lockCheckInterval = setInterval(() => {
+            this.checkExpiredLocks();
+        }, this.config.stallCheckMs);
         this.cronScheduler.start();
     }
     checkJobTimeouts() {
@@ -547,31 +878,61 @@ export class QueueManager {
     }
     /**
      * Check for stalled jobs and handle them
-     * Stalled = active job with no heartbeat for too long
+     * Uses two-phase detection (like BullMQ) to prevent false positives:
+     * - Phase 1: Jobs marked as candidates in previous check are confirmed stalled
+     * - Phase 2: Current processing jobs are marked as candidates for next check
      */
     checkStalledJobs() {
         const now = Date.now();
+        const confirmedStalled = [];
+        // Phase 1: Check jobs that were candidates from previous cycle
+        // If still in processing and still meets stall criteria → confirmed stalled
+        for (const jobId of this.stalledCandidates) {
+            // Find job in processing shards
+            const procIdx = processingShardIndex(String(jobId));
+            const job = this.processingShards[procIdx].get(jobId);
+            if (!job) {
+                // Job completed between checks - not stalled (false positive avoided!)
+                this.stalledCandidates.delete(jobId);
+                continue;
+            }
+            const stallConfig = this.shards[shardIndex(job.queue)].getStallConfig(job.queue);
+            if (!stallConfig.enabled) {
+                this.stalledCandidates.delete(jobId);
+                continue;
+            }
+            // Re-check stall criteria (job might have received heartbeat)
+            const action = getStallAction(job, stallConfig, now);
+            if (action !== "keep" /* StallAction.Keep */) {
+                // Confirmed stalled - was candidate AND still meets criteria
+                confirmedStalled.push({ job, action });
+            }
+            // Remove from candidates (will be re-added in phase 2 if still processing)
+            this.stalledCandidates.delete(jobId);
+        }
+        // Phase 2: Mark current processing jobs as candidates for NEXT check
         for (let i = 0; i < SHARD_COUNT; i++) {
             const procShard = this.processingShards[i];
-            const stalledJobs = [];
-            for (const [_jobId, job] of procShard) {
+            for (const [jobId, job] of procShard) {
                 const stallConfig = this.shards[shardIndex(job.queue)].getStallConfig(job.queue);
                 if (!stallConfig.enabled)
                     continue;
+                // Only mark as candidate if past grace period and no recent heartbeat
                 const action = getStallAction(job, stallConfig, now);
                 if (action !== "keep" /* StallAction.Keep */) {
-                    stalledJobs.push({ job, action });
+                    // Add to candidates - will be checked in NEXT cycle
+                    this.stalledCandidates.add(jobId);
                 }
             }
-            // Process stalled jobs
-            for (const { job, action } of stalledJobs) {
-                this.handleStalledJob(job, action).catch((err) => {
-                    queueLog.error('Failed to handle stalled job', {
-                        jobId: String(job.id),
-                        error: String(err),
-                    });
+        }
+        // Process confirmed stalled jobs
+        for (const { job, action } of confirmedStalled) {
+            this.handleStalledJob(job, action).catch((err) => {
+                queueLog.error('Failed to handle stalled job', {
+                    jobId: String(job.id),
+                    error: String(err),
                 });
-            }
+            });
         }
     }
     /**
@@ -786,6 +1147,77 @@ export class QueueManager {
                 }
             }
         }
+        // Clean stale stalledCandidates (jobs no longer in processing)
+        for (const jobId of this.stalledCandidates) {
+            const loc = this.jobIndex.get(jobId);
+            if (loc?.type !== 'processing') {
+                this.stalledCandidates.delete(jobId);
+            }
+        }
+        // Clean orphaned jobIndex entries (pointing to invalid locations)
+        // This is expensive so only run if index is large
+        if (this.jobIndex.size > 100_000) {
+            let orphanedCount = 0;
+            for (const [jobId, loc] of this.jobIndex) {
+                if (loc.type === 'processing') {
+                    const procIdx = processingShardIndex(String(jobId));
+                    if (!this.processingShards[procIdx].has(jobId)) {
+                        this.jobIndex.delete(jobId);
+                        orphanedCount++;
+                    }
+                }
+                else if (loc.type === 'queue') {
+                    // Check if job still exists in shard
+                    const shard = this.shards[loc.shardIdx];
+                    if (!shard.getQueue(loc.queueName).has(jobId)) {
+                        this.jobIndex.delete(jobId);
+                        orphanedCount++;
+                    }
+                }
+            }
+            if (orphanedCount > 0) {
+                queueLog.info('Cleaned orphaned jobIndex entries', { count: orphanedCount });
+            }
+        }
+        // Clean orphaned job locks (locks for jobs no longer in processing)
+        for (const jobId of this.jobLocks.keys()) {
+            const loc = this.jobIndex.get(jobId);
+            if (loc?.type !== 'processing') {
+                this.jobLocks.delete(jobId);
+            }
+        }
+        // Remove empty queues to free memory (like obliterate but only for empty queues)
+        for (let i = 0; i < SHARD_COUNT; i++) {
+            const shard = this.shards[i];
+            const emptyQueues = [];
+            for (const [queueName, queue] of shard.queues) {
+                // Queue is empty and has no DLQ entries
+                const dlqEntries = shard.dlq.get(queueName);
+                if (queue.size === 0 && (!dlqEntries || dlqEntries.length === 0)) {
+                    emptyQueues.push(queueName);
+                }
+            }
+            for (const queueName of emptyQueues) {
+                shard.queues.delete(queueName);
+                shard.dlq.delete(queueName);
+                shard.uniqueKeys.delete(queueName);
+                shard.queueState.delete(queueName);
+                shard.activeGroups.delete(queueName);
+                shard.rateLimiters.delete(queueName);
+                shard.concurrencyLimiters.delete(queueName);
+                shard.stallConfig.delete(queueName);
+                shard.dlqConfig.delete(queueName);
+                this.unregisterQueueName(queueName);
+            }
+            if (emptyQueues.length > 0) {
+                queueLog.info('Removed empty queues', { shard: i, count: emptyQueues.length });
+            }
+            // Clean orphaned temporal index entries (memory leak fix)
+            const cleanedTemporal = shard.cleanOrphanedTemporalEntries();
+            if (cleanedTemporal > 0) {
+                queueLog.info('Cleaned orphaned temporal entries', { shard: i, count: cleanedTemporal });
+            }
+        }
     }
     // ============ Lifecycle ============
     shutdown() {
@@ -802,6 +1234,8 @@ export class QueueManager {
             clearInterval(this.stallCheckInterval);
         if (this.dlqMaintenanceInterval)
             clearInterval(this.dlqMaintenanceInterval);
+        if (this.lockCheckInterval)
+            clearInterval(this.lockCheckInterval);
         this.storage?.close();
         // Clear in-memory collections
         this.jobIndex.clear();
@@ -811,6 +1245,9 @@ export class QueueManager {
         this.customIdMap.clear();
         this.pendingDepChecks.clear();
         this.queueNamesCache.clear();
+        this.jobLocks.clear();
+        this.stalledCandidates.clear();
+        this.clientJobs.clear();
         for (const shard of this.processingShards) {
             shard.clear();
         }
@@ -851,5 +1288,77 @@ export class QueueManager {
             cronPending: cronStats.pending,
         };
     }
+    /**
+     * Get detailed memory statistics for debugging memory issues.
+     * Returns counts of entries in all major collections.
+     */
+    getMemoryStats() {
+        let processingTotal = 0;
+        let queuedTotal = 0;
+        let waitingDepsTotal = 0;
+        let temporalIndexTotal = 0;
+        let delayedHeapTotal = 0;
+        for (let i = 0; i < SHARD_COUNT; i++) {
+            processingTotal += this.processingShards[i].size;
+            const shardStats = this.shards[i].getStats();
+            queuedTotal += shardStats.queuedJobs;
+            waitingDepsTotal += this.shards[i].waitingDeps.size;
+            // Get internal structure sizes
+            const internalSizes = this.shards[i].getInternalSizes();
+            temporalIndexTotal += internalSizes.temporalIndex;
+            delayedHeapTotal += internalSizes.delayedHeap;
+        }
+        // Count total jobs across all clients
+        let clientJobsTotal = 0;
+        for (const jobs of this.clientJobs.values()) {
+            clientJobsTotal += jobs.size;
+        }
+        return {
+            jobIndex: this.jobIndex.size,
+            completedJobs: this.completedJobs.size,
+            jobResults: this.jobResults.size,
+            jobLogs: this.jobLogs.size,
+            customIdMap: this.customIdMap.size,
+            jobLocks: this.jobLocks.size,
+            clientJobs: this.clientJobs.size,
+            clientJobsTotal,
+            pendingDepChecks: this.pendingDepChecks.size,
+            stalledCandidates: this.stalledCandidates.size,
+            processingTotal,
+            queuedTotal,
+            waitingDepsTotal,
+            temporalIndexTotal,
+            delayedHeapTotal,
+        };
+    }
+    /**
+     * Force compact all collections to reduce memory usage.
+     * Use after large batch operations or when memory pressure is high.
+     */
+    compactMemory() {
+        // Compact priority queues that have high stale ratios
+        for (let i = 0; i < SHARD_COUNT; i++) {
+            for (const q of this.shards[i].queues.values()) {
+                if (q.needsCompaction(0.1)) {
+                    // More aggressive: 10% stale threshold
+                    q.compact();
+                }
+            }
+        }
+        // Clean up empty client tracking entries
+        for (const [clientId, jobs] of this.clientJobs) {
+            if (jobs.size === 0) {
+                this.clientJobs.delete(clientId);
+            }
+        }
+        // Clean orphaned job locks (jobs no longer in processing)
+        for (const jobId of this.jobLocks.keys()) {
+            const loc = this.jobIndex.get(jobId);
+            if (loc?.type !== 'processing') {
+                this.jobLocks.delete(jobId);
+            }
+        }
+        queueLog.info('Memory compacted');
+    }
 }
 //# sourceMappingURL=queueManager.js.map