bunqueue 2.8.54 → 2.8.57

package/dist/domain/queue/dlqShard.js

@@ -25,7 +25,28 @@ export class DlqShard {
     /** Set DLQ config for queue */
     setConfig(queue, config) {
         const current = this.getConfig(queue);
-        this.dlqConfig.set(queue, { ...current, ...config });
+        const next = { ...current };
+        if (typeof config.autoRetry === 'boolean')
+            next.autoRetry = config.autoRetry;
+        if (Number.isFinite(config.autoRetryInterval)) {
+            next.autoRetryInterval = Math.max(0, Math.floor(config.autoRetryInterval));
+        }
+        if (Number.isFinite(config.maxAutoRetries)) {
+            next.maxAutoRetries = Math.max(0, Math.floor(config.maxAutoRetries));
+        }
+        if (config.maxAge === null) {
+            next.maxAge = null;
+        }
+        else if (Number.isFinite(config.maxAge)) {
+            next.maxAge = Math.max(0, Math.floor(config.maxAge));
+        }
+        if (Number.isFinite(config.maxEntries)) {
+            next.maxEntries = Math.max(1, Math.floor(config.maxEntries));
+        }
+        this.dlqConfig.set(queue, next);
+        const entries = this.dlq.get(queue);
+        if (entries)
+            this.evictUntil(entries, next.maxEntries, false);
     }
     /** Get stall config for queue */
     getStallConfig(queue) {
@@ -46,10 +67,7 @@ export class DlqShard {
         const config = this.getConfig(job.queue);
         const entry = createDlqEntry(job, reason, error, config);
         // Enforce max entries
-        while (entries.length >= config.maxEntries) {
-            entries.shift(); // Remove oldest
-            this.stats.decrementDlq();
-        }
+        this.evictUntil(entries, config.maxEntries, true);
         entries.push(entry);
         this.stats.incrementDlq();
         return entry;
@@ -63,10 +81,7 @@ export class DlqShard {
         }
         const config = this.getConfig(queue);
         // Enforce max entries (mirror add(): evict oldest-first)
-        while (entries.length >= config.maxEntries) {
-            entries.shift(); // Remove oldest
-            this.stats.decrementDlq();
-        }
+        this.evictUntil(entries, config.maxEntries, true);
         entries.push(entry);
         this.stats.incrementDlq();
     }
@@ -177,4 +192,14 @@ export class DlqShard {
         this.stallConfig.delete(queue);
         return count;
     }
+    evictUntil(entries, maxEntries, reserveSlot) {
+        const target = reserveSlot ? maxEntries - 1 : maxEntries;
+        while (entries.length > target) {
+            const evicted = entries.shift();
+            if (!evicted)
+                break;
+            this.stats.decrementDlq();
+            this.stats.onEvict?.(evicted);
+        }
+    }
 }

package/dist/domain/queue/priorityQueue.js

@@ -3,43 +3,7 @@
  * Combines binary heap for O(log n) priority operations
  * with Map for O(1) lookups by job ID
  */
-/**
- * Compare two heap entries
- * Order: higher priority first, then:
- *   - LIFO: newer jobs first (by jobId descending, since UUID7 is time-ordered)
- *   - FIFO: earlier runAt first, then older jobs first (by jobId ascending)
- *
- * Uses direct string comparison instead of localeCompare for ~10-50x faster performance.
- * This works because UUID7 is ASCII-only and lexicographically sortable.
- */
-function compareEntries(a, b) {
-    // Higher priority first
-    if (a.priority !== b.priority) {
-        return b.priority - a.priority;
-    }
-    // For LIFO: newer jobs (higher UUID7) should come first
-    // UUID7 contains timestamp, so lexicographic comparison gives time order
-    if (a.lifo && b.lifo) {
-        // Direct comparison mimicking localeCompare(b, a) for descending order
-        // b > a means b is newer, should come first (return positive to put b before a)
-        if (b.jobId > a.jobId)
-            return 1;
-        if (b.jobId < a.jobId)
-            return -1;
-        return 0;
-    }
-    // For FIFO or mixed: earlier runAt first
-    if (a.runAt !== b.runAt) {
-        return a.runAt - b.runAt;
-    }
-    // Then by jobId (older first for FIFO)
-    // a < b means a is older, should come first (return negative)
-    if (a.jobId < b.jobId)
-        return -1;
-    if (a.jobId > b.jobId)
-        return 1;
-    return 0;
-}
+import { comparePriorityEntries } from './priorityQueueOrder';
 /**
  * Indexed Priority Queue implementation with 4-ary heap
  * 4-ary provides better cache locality than binary heap
@@ -243,7 +207,7 @@ export class IndexedPriorityQueue {
         const D = IndexedPriorityQueue.D;
         while (idx > 0) {
             const parentIdx = Math.floor((idx - 1) / D);
-            if (compareEntries(this.heap[idx], this.heap[parentIdx]) >= 0) {
+            if (comparePriorityEntries(this.heap[idx], this.heap[parentIdx]) >= 0) {
                 break;
             }
             this.swap(idx, parentIdx);
@@ -263,7 +227,7 @@ export class IndexedPriorityQueue {
             let smallest = idx;
             const lastChild = Math.min(firstChild + D, length);
             for (let c = firstChild; c < lastChild; c++) {
-                if (compareEntries(heap[c], heap[smallest]) < 0) {
+                if (comparePriorityEntries(heap[c], heap[smallest]) < 0) {
                     smallest = c;
                 }
             }

package/dist/domain/queue/priorityQueueOrder.d.ts

@@ -0,0 +1,3 @@
+import type { HeapEntry } from '../types/priorityQueue';
+/** Priority, LIFO/FIFO, run time, then UUIDv7 ordering. */
+export declare function comparePriorityEntries(a: HeapEntry, b: HeapEntry): number;

package/dist/domain/queue/priorityQueueOrder.js

@@ -0,0 +1,21 @@
+/** Priority, LIFO/FIFO, run time, then UUIDv7 ordering. */
+export function comparePriorityEntries(a, b) {
+    if (a.priority !== b.priority)
+        return b.priority - a.priority;
+    if (a.lifo !== b.lifo)
+        return a.lifo ? -1 : 1;
+    if (a.lifo && b.lifo) {
+        if (b.jobId > a.jobId)
+            return 1;
+        if (b.jobId < a.jobId)
+            return -1;
+        return 0;
+    }
+    if (a.runAt !== b.runAt)
+        return a.runAt - b.runAt;
+    if (a.jobId < b.jobId)
+        return -1;
+    if (a.jobId > b.jobId)
+        return 1;
+    return 0;
+}

package/dist/domain/queue/shard/dependencies.d.ts

@@ -0,0 +1,11 @@
+import type { Job, JobId } from '../../types/job';
+import { ShardLimits } from './limits';
+/** Dependency and waiting-children maps. */
+export declare class ShardDependencies extends ShardLimits {
+    get waitingDeps(): Map<JobId, Job>;
+    get dependencyIndex(): Map<JobId, Set<JobId>>;
+    get waitingChildren(): Map<JobId, Job>;
+    registerDependencies(jobId: JobId, dependsOn: JobId[]): void;
+    unregisterDependencies(jobId: JobId, dependsOn: JobId[]): void;
+    getJobsWaitingFor(depId: JobId): Set<JobId> | undefined;
+}

package/dist/domain/queue/shard/dependencies.js

@@ -0,0 +1,22 @@
+import { ShardLimits } from './limits';
+/** Dependency and waiting-children maps. */
+export class ShardDependencies extends ShardLimits {
+    get waitingDeps() {
+        return this.dependencyTracker.waitingDeps;
+    }
+    get dependencyIndex() {
+        return this.dependencyTracker.dependencyIndex;
+    }
+    get waitingChildren() {
+        return this.dependencyTracker.waitingChildren;
+    }
+    registerDependencies(jobId, dependsOn) {
+        this.dependencyTracker.registerDependencies(jobId, dependsOn);
+    }
+    unregisterDependencies(jobId, dependsOn) {
+        this.dependencyTracker.unregisterDependencies(jobId, dependsOn);
+    }
+    getJobsWaitingFor(depId) {
+        return this.dependencyTracker.getJobsWaitingFor(depId);
+    }
+}

package/dist/domain/queue/shard/dlq.d.ts

@@ -0,0 +1,25 @@
+import type { DlqConfig, DlqEntry, DlqFilter } from '../../types/dlq';
+import { FailureReason } from '../../types/dlq';
+import type { Job, JobId } from '../../types/job';
+import type { StallConfig } from '../../types/stall';
+import { ShardDependencies } from './dependencies';
+/** Dead-letter and stall configuration operations. */
+export declare class ShardDlq extends ShardDependencies {
+    get dlq(): Map<string, DlqEntry[]>;
+    get dlqConfig(): Map<string, DlqConfig>;
+    get stallConfig(): Map<string, StallConfig>;
+    getDlqConfig(queue: string): DlqConfig;
+    setDlqConfig(queue: string, config: Partial<DlqConfig>): void;
+    getStallConfig(queue: string): StallConfig;
+    setStallConfig(queue: string, config: Partial<StallConfig>): void;
+    addToDlq(job: Job, reason?: FailureReason, error?: string | null): DlqEntry;
+    restoreDlqEntry(queue: string, entry: DlqEntry): void;
+    getDlqEntries(queue: string): DlqEntry[];
+    getDlq(queue: string, count?: number): Job[];
+    getDlqFiltered(queue: string, filter: DlqFilter): DlqEntry[];
+    removeFromDlq(queue: string, jobId: JobId): DlqEntry | null;
+    getAutoRetryEntries(queue: string, now?: number): DlqEntry[];
+    getExpiredEntries(queue: string, now?: number): DlqEntry[];
+    purgeExpired(queue: string, now?: number): number;
+    clearDlq(queue: string): number;
+}

package/dist/domain/queue/shard/dlq.js

@@ -0,0 +1,71 @@
+import { ShardDependencies } from './dependencies';
+/** Dead-letter and stall configuration operations. */
+export class ShardDlq extends ShardDependencies {
+    get dlq() {
+        const map = new Map();
+        for (const queue of this.dlqManager.getQueueNames()) {
+            map.set(queue, this.dlqManager.getEntries(queue));
+        }
+        for (const queue of this.queues.keys()) {
+            if (!map.has(queue))
+                map.set(queue, []);
+        }
+        return map;
+    }
+    get dlqConfig() {
+        const map = new Map();
+        for (const queue of this.getQueueNames()) {
+            map.set(queue, this.dlqManager.getConfig(queue));
+        }
+        return map;
+    }
+    get stallConfig() {
+        const map = new Map();
+        for (const queue of this.getQueueNames()) {
+            map.set(queue, this.dlqManager.getStallConfig(queue));
+        }
+        return map;
+    }
+    getDlqConfig(queue) {
+        return this.dlqManager.getConfig(queue);
+    }
+    setDlqConfig(queue, config) {
+        this.dlqManager.setConfig(queue, config);
+    }
+    getStallConfig(queue) {
+        return this.dlqManager.getStallConfig(queue);
+    }
+    setStallConfig(queue, config) {
+        this.dlqManager.setStallConfig(queue, config);
+    }
+    addToDlq(job, reason = "unknown" /* FailureReason.Unknown */, error = null) {
+        return this.dlqManager.add(job, reason, error);
+    }
+    restoreDlqEntry(queue, entry) {
+        this.dlqManager.restoreEntry(queue, entry);
+    }
+    getDlqEntries(queue) {
+        return this.dlqManager.getEntries(queue);
+    }
+    getDlq(queue, count) {
+        return this.dlqManager.getJobs(queue, count);
+    }
+    getDlqFiltered(queue, filter) {
+        return this.dlqManager.getFiltered(queue, filter);
+    }
+    removeFromDlq(queue, jobId) {
+        return this.dlqManager.remove(queue, jobId);
+    }
+    getAutoRetryEntries(queue, now = Date.now()) {
+        return this.dlqManager.getAutoRetryEntries(queue, now);
+    }
+    getExpiredEntries(queue, now = Date.now()) {
+        return this.dlqManager.getExpiredEntries(queue, now);
+    }
+    purgeExpired(queue, now = Date.now()) {
+        return this.dlqManager.purgeExpired(queue, now);
+    }
+    clearDlq(queue) {
+        return this.dlqManager.clear(queue);
+    }
+}

package/dist/domain/queue/shard/keys.d.ts

@@ -0,0 +1,18 @@
+import type { UniqueKeyEntry } from '../../types/deduplication';
+import type { JobId } from '../../types/job';
+import { ShardState } from './state';
+/** Deduplication keys and FIFO group ownership. */
+export declare class ShardKeys extends ShardState {
+    isUniqueAvailable(queue: string, key: string): boolean;
+    getUniqueKeyEntry(queue: string, key: string): UniqueKeyEntry | null;
+    registerUniqueKey(queue: string, key: string, jobId: JobId): void;
+    registerUniqueKeyWithTtl(queue: string, key: string, jobId: JobId, ttl?: number): void;
+    extendUniqueKeyTtl(queue: string, key: string, ttl: number): boolean;
+    releaseUniqueKey(queue: string, key: string): boolean;
+    releaseUniqueKeyIfOwned(queue: string, key: string, ownerId: JobId): boolean;
+    cleanExpiredUniqueKeys(): number;
+    get uniqueKeys(): Map<string, Map<string, UniqueKeyEntry>>;
+    isGroupActive(queue: string, groupId: string): boolean;
+    activateGroup(queue: string, groupId: string): void;
+    releaseGroup(queue: string, groupId: string): void;
+}

package/dist/domain/queue/shard/keys.js

@@ -0,0 +1,45 @@
+import { ShardState } from './state';
+/** Deduplication keys and FIFO group ownership. */
+export class ShardKeys extends ShardState {
+    isUniqueAvailable(queue, key) {
+        return this.uniqueKeyManager.isAvailable(queue, key);
+    }
+    getUniqueKeyEntry(queue, key) {
+        return this.uniqueKeyManager.getEntry(queue, key);
+    }
+    registerUniqueKey(queue, key, jobId) {
+        this.uniqueKeyManager.register(queue, key, jobId);
+    }
+    registerUniqueKeyWithTtl(queue, key, jobId, ttl) {
+        this.uniqueKeyManager.registerWithTtl(queue, key, jobId, ttl);
+    }
+    extendUniqueKeyTtl(queue, key, ttl) {
+        return this.uniqueKeyManager.extendTtl(queue, key, ttl);
+    }
+    releaseUniqueKey(queue, key) {
+        return this.uniqueKeyManager.release(queue, key);
+    }
+    releaseUniqueKeyIfOwned(queue, key, ownerId) {
+        return this.uniqueKeyManager.releaseIfOwned(queue, key, ownerId);
+    }
+    cleanExpiredUniqueKeys() {
+        return this.uniqueKeyManager.cleanExpired();
+    }
+    get uniqueKeys() {
+        return this.uniqueKeyManager.getMap();
+    }
+    isGroupActive(queue, groupId) {
+        return this.activeGroups.get(queue)?.has(groupId) ?? false;
+    }
+    activateGroup(queue, groupId) {
+        let groups = this.activeGroups.get(queue);
+        if (!groups) {
+            groups = new Set();
+            this.activeGroups.set(queue, groups);
+        }
+        groups.add(groupId);
+    }
+    releaseGroup(queue, groupId) {
+        this.activeGroups.get(queue)?.delete(groupId);
+    }
+}

package/dist/domain/queue/shard/lifecycle.d.ts

@@ -0,0 +1,10 @@
+import type { JobId } from '../../types/job';
+import { ShardMetrics } from './metrics';
+/** Drain and obliterate transitions across all shard collaborators. */
+export declare class ShardLifecycle extends ShardMetrics {
+    drain(queue: string): {
+        count: number;
+        jobIds: JobId[];
+    };
+    obliterate(queue: string): JobId[];
+}

package/dist/domain/queue/shard/lifecycle.js

@@ -0,0 +1,43 @@
+import { ShardMetrics } from './metrics';
+/** Drain and obliterate transitions across all shard collaborators. */
+export class ShardLifecycle extends ShardMetrics {
+    drain(queue) {
+        const priorityQueue = this.queues.get(queue);
+        if (!priorityQueue)
+            return { count: 0, jobIds: [] };
+        const count = priorityQueue.size;
+        const jobIds = [];
+        for (const job of priorityQueue.values()) {
+            jobIds.push(job.id);
+            this.temporalManager.removeDelayed(job.id);
+        }
+        priorityQueue.clear();
+        this.temporalManager.clearIndexForQueue(queue);
+        this.counters.adjustQueued(-count);
+        this.counters.syncDelayedCount();
+        return { count, jobIds };
+    }
+    obliterate(queue) {
+        const removed = new Set(this.dependencyTracker.removeQueue(queue));
+        const priorityQueue = this.queues.get(queue);
+        if (priorityQueue) {
+            for (const job of priorityQueue.values()) {
+                removed.add(job.id);
+                this.temporalManager.removeDelayed(job.id);
+            }
+            this.counters.adjustQueued(-priorityQueue.size);
+        }
+        for (const entry of this.dlqManager.getEntries(queue))
+            removed.add(entry.job.id);
+        const dlqCount = this.dlqManager.deleteQueue(queue);
+        if (dlqCount > 0)
+            this.counters.adjustDlq(-dlqCount);
+        this.counters.syncDelayedCount();
+        this.temporalManager.clearIndexForQueue(queue);
+        this.queues.delete(queue);
+        this.uniqueKeyManager.clearQueue(queue);
+        this.limiterManager.deleteQueue(queue);
+        this.activeGroups.delete(queue);
+        return Array.from(removed);
+    }
+}

package/dist/domain/queue/shard/limits.d.ts

@@ -0,0 +1,24 @@
+import type { JobId } from '../../types/job';
+import type { QueueState } from '../../types/queue';
+import { ShardKeys } from './keys';
+/** Queue rate, concurrency, and resource ownership operations. */
+export declare class ShardLimits extends ShardKeys {
+    setRateLimit(queue: string, limit: number, durationMs?: number, ttlMs?: number): void;
+    clearRateLimit(queue: string): void;
+    expireRateLimitIfNeeded(queue: string): void;
+    tryAcquireRateLimit(queue: string): boolean;
+    getRateLimit(queue: string): {
+        max: number;
+        duration: number;
+    } | null;
+    getRateLimitTtl(queue: string, maxJobs?: number): number;
+    setConcurrency(queue: string, limit: number): void;
+    clearConcurrency(queue: string): void;
+    tryAcquireConcurrency(queue: string): boolean;
+    releaseConcurrency(queue: string): void;
+    getConcurrency(queue: string): number | null;
+    isConcurrencyMaxed(queue: string): boolean;
+    get queueState(): Map<string, QueueState>;
+    clearQueueLimiters(queue: string): void;
+    releaseJobResources(queue: string, uniqueKey: string | null, groupId: string | null, ownerId?: JobId): void;
+}

package/dist/domain/queue/shard/limits.js

@@ -0,0 +1,57 @@
+import { ShardKeys } from './keys';
+/** Queue rate, concurrency, and resource ownership operations. */
+export class ShardLimits extends ShardKeys {
+    setRateLimit(queue, limit, durationMs, ttlMs) {
+        this.limiterManager.setRateLimit(queue, limit, durationMs, ttlMs);
+    }
+    clearRateLimit(queue) {
+        this.limiterManager.clearRateLimit(queue);
+    }
+    expireRateLimitIfNeeded(queue) {
+        this.limiterManager.expireRateLimitIfNeeded(queue);
+    }
+    tryAcquireRateLimit(queue) {
+        return this.limiterManager.tryAcquireRateLimit(queue);
+    }
+    getRateLimit(queue) {
+        return this.limiterManager.getRateLimit(queue);
+    }
+    getRateLimitTtl(queue, maxJobs) {
+        return this.limiterManager.getRateLimitTtl(queue, maxJobs);
+    }
+    setConcurrency(queue, limit) {
+        this.limiterManager.setConcurrency(queue, limit);
+    }
+    clearConcurrency(queue) {
+        this.limiterManager.clearConcurrency(queue);
+    }
+    tryAcquireConcurrency(queue) {
+        return this.limiterManager.tryAcquireConcurrency(queue);
+    }
+    releaseConcurrency(queue) {
+        this.limiterManager.releaseConcurrency(queue);
+    }
+    getConcurrency(queue) {
+        return this.limiterManager.getConcurrency(queue);
+    }
+    isConcurrencyMaxed(queue) {
+        return this.limiterManager.isConcurrencyMaxed(queue);
+    }
+    get queueState() {
+        return this.limiterManager.getStateMap();
+    }
+    clearQueueLimiters(queue) {
+        this.limiterManager.deleteQueue(queue);
+    }
+    releaseJobResources(queue, uniqueKey, groupId, ownerId) {
+        if (uniqueKey) {
+            if (ownerId)
+                this.releaseUniqueKeyIfOwned(queue, uniqueKey, ownerId);
+            else
+                this.releaseUniqueKey(queue, uniqueKey);
+        }
+        if (groupId)
+            this.releaseGroup(queue, groupId);
+        this.releaseConcurrency(queue);
+    }
+}

package/dist/domain/queue/shard/metrics.d.ts

@@ -0,0 +1,32 @@
+import type { JobId } from '../../types/job';
+import type { ShardStats } from '../shardCounters';
+import { ShardDlq } from './dlq';
+/** Queue counts, running counters, and temporal-index operations. */
+export declare class ShardMetrics extends ShardDlq {
+    getWaitingCount(queue: string): number;
+    getDlqCount(queue: string): number;
+    getCountsPerPriority(queue: string): Map<number, number>;
+    getStats(): ShardStats;
+    getInternalSizes(): {
+        delayedJobIds: number;
+        delayedHeap: number;
+        delayedRunAt: number;
+        temporalIndex: number;
+        waiters: number;
+    };
+    incrementQueued(jobId: JobId, isDelayed: boolean, createdAt?: number, queue?: string, runAt?: number): void;
+    decrementQueued(jobId: JobId): void;
+    promoteDelayed(jobId: JobId): void;
+    incrementDlq(): void;
+    decrementDlq(count?: number): void;
+    refreshDelayedCount(now: number): void;
+    resetQueuedCounters(): void;
+    resetDlqCounter(): void;
+    getOldJobs(queue: string, thresholdMs: number, limit: number): Array<{
+        jobId: JobId;
+        createdAt: number;
+    }>;
+    removeFromTemporalIndex(jobId: JobId): void;
+    clearTemporalIndexForQueue(queue: string): void;
+    cleanOrphanedTemporalEntries(): number;
+}

package/dist/domain/queue/shard/metrics.js

@@ -0,0 +1,72 @@
+import { ShardDlq } from './dlq';
+/** Queue counts, running counters, and temporal-index operations. */
+export class ShardMetrics extends ShardDlq {
+    getWaitingCount(queue) {
+        return this.queues.get(queue)?.size ?? 0;
+    }
+    getDlqCount(queue) {
+        return this.dlqManager.getCount(queue);
+    }
+    getCountsPerPriority(queue) {
+        const priorityQueue = this.queues.get(queue);
+        const counts = new Map();
+        if (!priorityQueue)
+            return counts;
+        for (const job of priorityQueue.values()) {
+            const count = counts.get(job.priority) ?? 0;
+            counts.set(job.priority, count + 1);
+        }
+        return counts;
+    }
+    getStats() {
+        return this.counters.getStats();
+    }
+    getInternalSizes() {
+        const sizes = this.temporalManager.getSizes();
+        return { ...sizes, waiters: this.waiterManager.length };
+    }
+    incrementQueued(jobId, isDelayed, createdAt, queue, runAt) {
+        this.counters.incrementQueued(jobId, isDelayed, createdAt, queue, runAt);
+    }
+    decrementQueued(jobId) {
+        this.counters.decrementQueued(jobId);
+    }
+    promoteDelayed(jobId) {
+        this.temporalManager.removeDelayed(jobId);
+        this.counters.syncDelayedCount();
+    }
+    incrementDlq() {
+        this.counters.incrementDlq();
+    }
+    decrementDlq(count = 1) {
+        this.counters.decrementDlq(count);
+    }
+    refreshDelayedCount(now) {
+        this.counters.refreshDelayedCount(now);
+    }
+    resetQueuedCounters() {
+        this.counters.resetQueuedCounters();
+    }
+    resetDlqCounter() {
+        this.counters.resetDlqCounter();
+    }
+    getOldJobs(queue, thresholdMs, limit) {
+        return this.temporalManager.getOldJobs(queue, thresholdMs, limit);
+    }
+    removeFromTemporalIndex(jobId) {
+        this.temporalManager.removeFromIndex(jobId);
+    }
+    clearTemporalIndexForQueue(queue) {
+        this.temporalManager.clearIndexForQueue(queue);
+    }
+    cleanOrphanedTemporalEntries() {
+        if (this.temporalManager.indexSize === 0)
+            return 0;
+        const validJobIds = new Set();
+        for (const priorityQueue of this.queues.values()) {
+            for (const job of priorityQueue.values())
+                validJobIds.add(job.id);
+        }
+        return this.temporalManager.cleanOrphaned(validJobIds);
+    }
+}

package/dist/domain/queue/shard/state.d.ts

@@ -0,0 +1,34 @@
+import type { QueueState } from '../../types/queue';
+import type { ShardOptions } from '../../types/shard';
+import { DependencyTracker } from '../dependencyTracker';
+import { DlqShard } from '../dlqShard';
+import { LimiterManager } from '../limiterManager';
+import { IndexedPriorityQueue } from '../priorityQueue';
+import { ShardCounters } from '../shardCounters';
+import { TemporalManager } from '../temporalManager';
+import { UniqueKeyManager } from '../uniqueKeyManager';
+import { WaiterManager } from '../waiterManager';
+/** Owns the collaborating shard managers and basic queue/waiter operations. */
+export declare class ShardState {
+    readonly queues: Map<string, IndexedPriorityQueue>;
+    readonly activeGroups: Map<string, Set<string>>;
+    protected readonly uniqueKeyManager: UniqueKeyManager;
+    protected readonly dlqManager: DlqShard;
+    protected readonly limiterManager: LimiterManager;
+    protected readonly dependencyTracker: DependencyTracker;
+    protected readonly temporalManager: TemporalManager;
+    protected readonly waiterManager: WaiterManager;
+    protected readonly counters: ShardCounters;
+    constructor(options?: ShardOptions);
+    notify(queue?: string): void;
+    notifyBatch(count: number): void;
+    notifyBatch(queue: string, count: number): void;
+    waitForJob(timeoutMs: number, signal?: AbortSignal): Promise<void>;
+    waitForJob(queue: string, timeoutMs: number, signal?: AbortSignal): Promise<void>;
+    getQueue(name: string): IndexedPriorityQueue;
+    getState(name: string): QueueState;
+    isPaused(name: string): boolean;
+    pause(name: string): void;
+    resume(name: string): void;
+    getQueueNames(): string[];
+}