bunqueue 2.8.53 → 2.8.56

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[];
+}

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

@@ -0,0 +1,80 @@
+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 class ShardState {
+    queues = new Map();
+    activeGroups = new Map();
+    uniqueKeyManager = new UniqueKeyManager();
+    dlqManager;
+    limiterManager = new LimiterManager();
+    dependencyTracker = new DependencyTracker();
+    temporalManager = new TemporalManager();
+    waiterManager = new WaiterManager();
+    counters;
+    constructor(options = {}) {
+        this.counters = new ShardCounters(this.temporalManager);
+        this.dlqManager = new DlqShard({
+            incrementDlq: () => {
+                this.counters.incrementDlq();
+            },
+            decrementDlq: (count) => {
+                this.counters.decrementDlq(count);
+            },
+            onEvict: options.onDlqEvicted,
+        });
+    }
+    notify(queue) {
+        this.waiterManager.notify(queue);
+    }
+    notifyBatch(queueOrCount, maybeCount) {
+        if (typeof queueOrCount === 'number') {
+            this.waiterManager.notifyBatch(queueOrCount);
+        }
+        else {
+            this.waiterManager.notifyBatch(queueOrCount, maybeCount ?? 0);
+        }
+    }
+    waitForJob(queueOrTimeout, maybeTimeoutOrSignal, maybeSignal) {
+        if (typeof queueOrTimeout === 'number') {
+            return this.waiterManager.waitForJob(queueOrTimeout, maybeTimeoutOrSignal);
+        }
+        return this.waiterManager.waitForJob(queueOrTimeout, typeof maybeTimeoutOrSignal === 'number' ? maybeTimeoutOrSignal : 0, maybeSignal);
+    }
+    getQueue(name) {
+        let queue = this.queues.get(name);
+        if (!queue) {
+            queue = new IndexedPriorityQueue();
+            this.queues.set(name, queue);
+        }
+        return queue;
+    }
+    getState(name) {
+        return this.limiterManager.getState(name);
+    }
+    isPaused(name) {
+        return this.limiterManager.isPaused(name);
+    }
+    pause(name) {
+        this.limiterManager.pause(name);
+    }
+    resume(name) {
+        this.limiterManager.resume(name);
+        this.waiterManager.notify(name);
+    }
+    getQueueNames() {
+        const names = new Set();
+        for (const name of this.queues.keys())
+            names.add(name);
+        for (const name of this.dlqManager.getQueueNames())
+            names.add(name);
+        for (const name of this.limiterManager.getQueueNames())
+            names.add(name);
+        return Array.from(names);
+    }
+}

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

@@ -1,139 +1,7 @@
-/**
- * Shard - Container for queues within a shard
- * Each shard manages multiple queues and their state
- *
- * Refactored to compose smaller modules:
- * - UniqueKeyManager: deduplication with TTL
- * - DlqShard: Dead Letter Queue operations
- * - LimiterManager: rate limiting + concurrency
- * - DependencyTracker: job dependency tracking
- * - TemporalManager: temporal index + delayed job tracking
- * - WaiterManager: job availability notifications
- * - ShardCounters: running counters for O(1) stats
- */
-import type { Job, JobId } from '../types/job';
-import type { QueueState } from '../types/queue';
-import type { DlqEntry, DlqConfig, DlqFilter } from '../types/dlq';
-import { FailureReason } from '../types/dlq';
-import type { StallConfig } from '../types/stall';
-import type { UniqueKeyEntry } from '../types/deduplication';
-import { IndexedPriorityQueue } from './priorityQueue';
-import { type ShardStats } from './shardCounters';
+/** Public Shard façade. */
+import { ShardLifecycle } from './shard/lifecycle';
 export type { ShardStats } from './shardCounters';
-/**
- * Shard contains:
- * - Queues (waiting + delayed jobs)
- * - DLQ (dead letter queue)
- * - Unique keys tracking
- * - Active FIFO groups
- * - Queue state (paused, rate limit, concurrency)
- */
-export declare class Shard {
-    /** Priority queues by queue name */
-    readonly queues: Map<string, IndexedPriorityQueue>;
-    /** Unique key manager for deduplication */
-    private readonly uniqueKeyManager;
-    /** DLQ manager */
-    private readonly dlqManager;
-    /** Limiter manager for rate/concurrency control */
-    private readonly limiterManager;
-    /** Dependency tracker */
-    private readonly dependencyTracker;
-    /** Temporal manager for index and delayed jobs */
-    private readonly temporalManager;
-    /** Waiter manager for job availability notifications */
-    private readonly waiterManager;
-    /** Running counters for O(1) stats */
-    private readonly counters;
-    /** Active FIFO groups per queue */
-    readonly activeGroups: Map<string, Set<string>>;
-    constructor();
-    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;
-    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): void;
-    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;
-    setRateLimit(queue: string, limit: number, durationMs?: number, ttlMs?: number): void;
-    clearRateLimit(queue: string): void;
-    expireRateLimitIfNeeded(queue: string): void;
-    tryAcquireRateLimit(queue: string): boolean;
-    setConcurrency(queue: string, limit: number): void;
-    clearConcurrency(queue: string): void;
-    tryAcquireConcurrency(queue: string): boolean;
-    releaseConcurrency(queue: string): void;
-    get queueState(): Map<string, QueueState>;
-    clearQueueLimiters(queue: string): void;
-    releaseJobResources(queue: string, uniqueKey: string | null, groupId: string | null): void;
-    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;
-    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;
-    getWaitingCount(queue: string): number;
-    getDlqCount(queue: string): number;
-    getQueueNames(): string[];
-    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;
-    /** Remove a promoted job from delayed tracking without changing queue depth. */
-    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;
-    drain(queue: string): {
-        count: number;
-        jobIds: JobId[];
-    };
-    obliterate(queue: string): JobId[];
+export type { ShardOptions } from '../types/shard';
+/** Shard behavior is composed from focused manager-delegation layers. */
+export declare class Shard extends ShardLifecycle {
 }

package/dist/domain/queue/shard.js

@@ -1,391 +1,5 @@
-/**
- * Shard - Container for queues within a shard
- * Each shard manages multiple queues and their state
- *
- * Refactored to compose smaller modules:
- * - UniqueKeyManager: deduplication with TTL
- * - DlqShard: Dead Letter Queue operations
- * - LimiterManager: rate limiting + concurrency
- * - DependencyTracker: job dependency tracking
- * - TemporalManager: temporal index + delayed job tracking
- * - WaiterManager: job availability notifications
- * - ShardCounters: running counters for O(1) stats
- */
-import { IndexedPriorityQueue } from './priorityQueue';
-import { UniqueKeyManager } from './uniqueKeyManager';
-import { DlqShard } from './dlqShard';
-import { LimiterManager } from './limiterManager';
-import { DependencyTracker } from './dependencyTracker';
-import { TemporalManager } from './temporalManager';
-import { WaiterManager } from './waiterManager';
-import { ShardCounters } from './shardCounters';
-/**
- * Shard contains:
- * - Queues (waiting + delayed jobs)
- * - DLQ (dead letter queue)
- * - Unique keys tracking
- * - Active FIFO groups
- * - Queue state (paused, rate limit, concurrency)
- */
-export class Shard {
-    /** Priority queues by queue name */
-    queues = new Map();
-    /** Unique key manager for deduplication */
-    uniqueKeyManager = new UniqueKeyManager();
-    /** DLQ manager */
-    dlqManager;
-    /** Limiter manager for rate/concurrency control */
-    limiterManager = new LimiterManager();
-    /** Dependency tracker */
-    dependencyTracker = new DependencyTracker();
-    /** Temporal manager for index and delayed jobs */
-    temporalManager = new TemporalManager();
-    /** Waiter manager for job availability notifications */
-    waiterManager = new WaiterManager();
-    /** Running counters for O(1) stats */
-    counters;
-    /** Active FIFO groups per queue */
-    activeGroups = new Map();
-    constructor() {
-        this.counters = new ShardCounters(this.temporalManager);
-        this.dlqManager = new DlqShard({
-            incrementDlq: () => {
-                this.counters.incrementDlq();
-            },
-            decrementDlq: (count) => {
-                this.counters.decrementDlq(count);
-            },
-        });
-    }
-    // ============ Waiter Management (delegated) ============
-    notify(queue) {
-        this.waiterManager.notify(queue);
-    }
-    notifyBatch(queueOrCount, maybeCount) {
-        if (typeof queueOrCount === 'number') {
-            this.waiterManager.notifyBatch(queueOrCount);
-        }
-        else {
-            this.waiterManager.notifyBatch(queueOrCount, maybeCount ?? 0);
-        }
-    }
-    waitForJob(queueOrTimeout, maybeTimeoutOrSignal, maybeSignal) {
-        if (typeof queueOrTimeout === 'number') {
-            return this.waiterManager.waitForJob(queueOrTimeout, maybeTimeoutOrSignal);
-        }
-        return this.waiterManager.waitForJob(queueOrTimeout, typeof maybeTimeoutOrSignal === 'number' ? maybeTimeoutOrSignal : 0, maybeSignal);
-    }
-    // ============ Queue Operations ============
-    getQueue(name) {
-        let queue = this.queues.get(name);
-        if (!queue) {
-            queue = new IndexedPriorityQueue();
-            this.queues.set(name, queue);
-        }
-        return queue;
-    }
-    getState(name) {
-        return this.limiterManager.getState(name);
-    }
-    isPaused(name) {
-        return this.limiterManager.isPaused(name);
-    }
-    pause(name) {
-        this.limiterManager.pause(name);
-    }
-    resume(name) {
-        this.limiterManager.resume(name);
-        this.waiterManager.notify(name);
-    }
-    // ============ Unique Key Management (delegated) ============
-    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) {
-        this.uniqueKeyManager.release(queue, key);
-    }
-    cleanExpiredUniqueKeys() {
-        return this.uniqueKeyManager.cleanExpired();
-    }
-    get uniqueKeys() {
-        return this.uniqueKeyManager.getMap();
-    }
-    // ============ FIFO Group Management ============
-    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);
-    }
-    // ============ Rate & Concurrency Limiting (delegated) ============
-    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);
-    }
-    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);
-    }
-    get queueState() {
-        return this.limiterManager.getStateMap();
-    }
-    clearQueueLimiters(queue) {
-        this.limiterManager.deleteQueue(queue);
-    }
-    // ============ Resource Release ============
-    releaseJobResources(queue, uniqueKey, groupId) {
-        if (uniqueKey)
-            this.releaseUniqueKey(queue, uniqueKey);
-        if (groupId)
-            this.releaseGroup(queue, groupId);
-        this.releaseConcurrency(queue);
-    }
-    // ============ Dependency Tracking (delegated) ============
-    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);
-    }
-    // ============ DLQ Operations (delegated) ============
-    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);
-    }
-    // ============ Queue Stats ============
-    getWaitingCount(queue) {
-        return this.queues.get(queue)?.size ?? 0;
-    }
-    getDlqCount(queue) {
-        return this.dlqManager.getCount(queue);
-    }
-    getQueueNames() {
-        const names = new Set();
-        for (const name of this.queues.keys())
-            names.add(name);
-        for (const name of this.dlqManager.getQueueNames())
-            names.add(name);
-        for (const name of this.limiterManager.getQueueNames())
-            names.add(name);
-        return Array.from(names);
-    }
-    getCountsPerPriority(queue) {
-        const q = this.queues.get(queue);
-        const counts = new Map();
-        if (!q)
-            return counts;
-        for (const job of q.values()) {
-            const count = counts.get(job.priority) ?? 0;
-            counts.set(job.priority, count + 1);
-        }
-        return counts;
-    }
-    // ============ Running Counters (delegated) ============
-    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);
-    }
-    /** Remove a promoted job from delayed tracking without changing queue depth. */
-    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();
-    }
-    // ============ Temporal Index (delegated) ============
-    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 pq of this.queues.values()) {
-            for (const job of pq.values()) {
-                validJobIds.add(job.id);
-            }
-        }
-        return this.temporalManager.cleanOrphaned(validJobIds);
-    }
-    // ============ Queue Lifecycle ============
-    drain(queue) {
-        const q = this.queues.get(queue);
-        if (!q)
-            return { count: 0, jobIds: [] };
-        const count = q.size;
-        const jobIds = [];
-        for (const job of q.values()) {
-            jobIds.push(job.id);
-            this.temporalManager.removeDelayed(job.id);
-        }
-        q.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 q = this.queues.get(queue);
-        if (q) {
-            for (const job of q.values()) {
-                removed.add(job.id);
-                this.temporalManager.removeDelayed(job.id);
-            }
-            this.counters.adjustQueued(-q.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);
-    }
+/** Public Shard façade. */
+import { ShardLifecycle } from './shard/lifecycle';
+/** Shard behavior is composed from focused manager-delegation layers. */
+export class Shard extends ShardLifecycle {
 }

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

@@ -21,7 +21,9 @@ export declare class UniqueKeyManager {
     /** Extend TTL for an existing unique key */
     extendTtl(queue: string, key: string, ttl: number): boolean;
     /** Release unique key */
-    release(queue: string, key: string): void;
+    release(queue: string, key: string): boolean;
+    /** Release a key only when it is still owned by the given job. */
+    releaseIfOwned(queue: string, key: string, ownerId: JobId): boolean;
     /** Clean expired unique keys (call periodically) */
     cleanExpired(): number;
     /** Clear all keys for a queue */

package/dist/domain/queue/uniqueKeyManager.js

@@ -59,7 +59,15 @@ export class UniqueKeyManager {
     }
     /** Release unique key */
     release(queue, key) {
-        this.keys.get(queue)?.delete(key);
+        return this.keys.get(queue)?.delete(key) ?? false;
+    }
+    /** Release a key only when it is still owned by the given job. */
+    releaseIfOwned(queue, key, ownerId) {
+        const queueKeys = this.keys.get(queue);
+        const entry = queueKeys?.get(key);
+        if (!entry || entry.jobId !== ownerId)
+            return false;
+        return queueKeys?.delete(key) ?? false;
     }
     /** Clean expired unique keys (call periodically) */
     cleanExpired() {