bunqueue 2.8.53 → 2.8.54

package/dist/client/queueGroup.js

@@ -22,12 +22,15 @@ import { getSharedManager } from './manager';
  */
 export class QueueGroup {
     prefix;
+    queues = new Map();
     constructor(namespace) {
         this.prefix = namespace.endsWith(':') ? namespace : `${namespace}:`;
     }
     /** Get a queue within this group */
     getQueue(name, opts) {
-        return new Queue(this.prefix + name, opts);
+        const queue = new Queue(this.prefix + name, opts);
+        this.queues.set(name, queue);
+        return queue;
     }
     /** Create a worker for a queue in this group */
     getWorker(name, processor, opts) {
@@ -77,4 +80,28 @@ export class QueueGroup {
             }
         }
     }
+    /** List queues created through this group, including remote queues. */
+    async listQueuesAsync() {
+        const names = new Set(this.queues.keys());
+        for (const name of this.listQueues())
+            names.add(name);
+        return [...names].sort();
+    }
+    /** Pause every queue created through this group. */
+    async pauseAllAsync() {
+        await Promise.all([...this.queues.values()].map((queue) => queue.pauseAsync()));
+    }
+    /** Resume every queue created through this group. */
+    async resumeAllAsync() {
+        await Promise.all([...this.queues.values()].map((queue) => queue.resumeAsync()));
+    }
+    /** Drain waiting jobs from every queue and return the aggregate count. */
+    async drainAllAsync() {
+        const counts = await Promise.all([...this.queues.values()].map((queue) => queue.drainAsync()));
+        return counts.reduce((total, count) => total + count, 0);
+    }
+    /** Remove all data from every queue created through this group. */
+    async obliterateAllAsync() {
+        await Promise.all([...this.queues.values()].map((queue) => queue.obliterateAsync()));
+    }
 }

package/dist/client/sandboxed/worker.js

@@ -550,7 +550,7 @@ export class SandboxedWorker extends EventEmitter {
             discard: createDiscardHandler(embedded, tcp),
             getDependencies: createGetDependenciesHandler(embedded, tcp, domainJob),
             getDependenciesCount: createGetDependenciesCountHandler(embedded, tcp, domainJob),
-            removeDeduplicationKey: createRemoveDeduplicationKeyHandler(),
+            removeDeduplicationKey: createRemoveDeduplicationKeyHandler(embedded, tcp),
             moveToCompleted,
             moveToFailed,
         });

package/dist/client/worker/processor.js

@@ -55,7 +55,7 @@ export async function processJob(internalJob, config) {
         discard: createDiscardHandler(embedded, tcp),
         getDependencies: createGetDependenciesHandler(embedded, tcp, internalJob),
         getDependenciesCount: createGetDependenciesCountHandler(embedded, tcp, internalJob),
-        removeDeduplicationKey: createRemoveDeduplicationKeyHandler(),
+        removeDeduplicationKey: createRemoveDeduplicationKeyHandler(embedded, tcp),
         token: token ?? undefined,
     });
     jobHolder.current = job;

package/dist/client/worker/processorHandlers.d.ts

@@ -58,8 +58,4 @@ export declare function createDiscardHandler(embedded: boolean, tcp: TcpConnecti
  */
 export declare function createGetDependenciesHandler(embedded: boolean, tcp: TcpConnection | null, internalJob: InternalJob): (_id: string) => Promise<JobDependencies>;
 export declare function createGetDependenciesCountHandler(embedded: boolean, tcp: TcpConnection | null, internalJob: InternalJob): (_id: string) => Promise<JobDependenciesCount>;
-/**
- * removeDeduplicationKey — no server primitive; throw explicit error so callers
- * learn this isn't supported rather than silently getting `false`.
- */
-export declare function createRemoveDeduplicationKeyHandler(): (_id: string) => Promise<boolean>;
+export declare function createRemoveDeduplicationKeyHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<boolean>;

package/dist/client/worker/processorHandlers.js

@@ -5,6 +5,7 @@
 import { jobId } from '../../domain/types/job';
 import { getSharedManager } from '../manager';
 import { UnrecoverableError } from '../errors';
+import { removeJobDeduplicationKey } from '../jobDeduplication';
 export function createProgressHandler(embedded, tcp, emitter, jobHolder) {
     return async (id, progress, message) => {
         if (embedded) {
@@ -306,7 +307,8 @@ export function createMoveToWaitingChildrenHandler(embedded, tcp) {
         }
         if (!tcp)
             return false;
-        throw new Error('moveToWaitingChildren is not supported in TCP mode — no server command available');
+        const response = await tcp.send({ cmd: 'MoveToWaitingChildren', id });
+        return response.ok === true;
     };
 }
 export function createWaitUntilFinishedHandler(embedded, tcp) {
@@ -391,10 +393,6 @@ export function createGetDependenciesCountHandler(embedded, tcp, internalJob) {
         };
     };
 }
-/**
- * removeDeduplicationKey — no server primitive; throw explicit error so callers
- * learn this isn't supported rather than silently getting `false`.
- */
-export function createRemoveDeduplicationKeyHandler() {
-    return () => Promise.reject(new Error('removeDeduplicationKey is not implemented — no server primitive available'));
+export function createRemoveDeduplicationKeyHandler(embedded, tcp) {
+    return (id) => removeJobDeduplicationKey(id, embedded, tcp);
 }

package/dist/client/worker/worker.d.ts

@@ -152,7 +152,7 @@ export declare class Worker<T = unknown, R = unknown> extends EventEmitter {
     private handlePullError;
     /** Register this worker with the server (TCP only, fire-and-forget) */
     private registerWithServer;
-    /** Start periodic worker-level heartbeat (separate from job heartbeat) */
+    /** Start periodic worker-level heartbeat (separate from job heartbeat). */
     private startWorkerHeartbeat;
     private getHeartbeatDeps;
     private getPullConfig;

package/dist/client/worker/worker.js

@@ -183,8 +183,17 @@ export class Worker extends EventEmitter {
         if (this.embedded && !this.stalledUnsubscribe && !this.opts.skipStalledCheck) {
             this.subscribeToStalledEvents();
         }
-        // Register worker with server (TCP only)
-        if (!this.embedded && this.tcp && !this.registered) {
+        // Register the worker in the selected broker runtime.
+        if (this.embedded && !this.registered) {
+            getSharedManager().registerWorker(this.queueKey, [this.queueKey], this.opts.concurrency, {
+                workerId: this.workerId,
+                hostname: hostname(),
+                pid: process.pid,
+                startedAt: this.startedAt,
+            });
+            this.registered = true;
+        }
+        else if (this.tcp && !this.registered) {
             this.registerWithServer();
         }
         if (this.opts.heartbeatInterval > 0 && !this.opts.skipLockRenewal) {
@@ -199,10 +208,10 @@ export class Worker extends EventEmitter {
             else {
                 const deps = this.getHeartbeatDeps();
                 this.heartbeatTimer = startHeartbeat(deps, this.opts.heartbeatInterval);
-                // Worker-level heartbeat (separate from job heartbeat)
-                this.startWorkerHeartbeat();
             }
         }
+        if (this.opts.heartbeatInterval > 0)
+            this.startWorkerHeartbeat();
         this.poll();
     }
     /** Subscribe to stalled events from QueueManager (BullMQ v5 compatible) */
@@ -485,13 +494,18 @@ export class Worker extends EventEmitter {
         await this.ackBatcher.flush();
         await this.ackBatcher.waitForInFlight();
         this.ackBatcher.stop();
-        // Unregister from server before closing connection
-        if (!this.embedded && this.tcp && this.registered) {
-            try {
-                await this.tcp.send({ cmd: 'UnregisterWorker', workerId: this.workerId });
+        // Unregister before closing the transport/runtime.
+        if (this.registered) {
+            if (this.embedded) {
+                getSharedManager().unregisterWorker(this.workerId);
             }
-            catch {
-                // Best-effort unregister — server will cleanup via stale timeout
+            else if (this.tcp) {
+                try {
+                    await this.tcp.send({ cmd: 'UnregisterWorker', workerId: this.workerId });
+                }
+                catch {
+                    // Best-effort unregister — server will cleanup via stale timeout
+                }
             }
             this.registered = false;
         }
@@ -852,12 +866,22 @@ export class Worker extends EventEmitter {
             this.emit('error', Object.assign(error, { context: 'worker-register' }));
         });
     }
-    /** Start periodic worker-level heartbeat (separate from job heartbeat) */
+    /** Start periodic worker-level heartbeat (separate from job heartbeat). */
     startWorkerHeartbeat() {
-        if (this.workerHeartbeatTimer || !this.tcp)
+        if (this.workerHeartbeatTimer)
             return;
         this.workerHeartbeatTimer = setInterval(() => {
-            if (!this.tcp || !this.registered)
+            if (!this.registered)
+                return;
+            if (this.embedded) {
+                getSharedManager().workerManager.heartbeat(this.workerId, {
+                    activeJobs: this.activeJobs,
+                    processed: this.processedCount,
+                    failed: this.failedCount,
+                });
+                return;
+            }
+            if (!this.tcp)
                 return;
             void this.tcp
                 .send({

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

@@ -38,6 +38,13 @@ export declare class LimiterManager {
     expireRateLimitIfNeeded(queue: string): void;
     /** Try to acquire rate limit token */
     tryAcquireRateLimit(queue: string): boolean;
+    /** Read the active rate-limit configuration after applying lazy expiry. */
+    getRateLimit(queue: string): {
+        max: number;
+        duration: number;
+    } | null;
+    /** Read the remaining temporary-limit TTL or token-bucket cooldown. */
+    getRateLimitTtl(queue: string, maxJobs?: number): number;
     /** Set concurrency limit for queue */
     setConcurrency(queue: string, limit: number): void;
     /** Clear concurrency limit */
@@ -46,6 +53,10 @@ export declare class LimiterManager {
     tryAcquireConcurrency(queue: string): boolean;
     /** Release concurrency slot */
     releaseConcurrency(queue: string): void;
+    /** Read the configured global concurrency limit. */
+    getConcurrency(queue: string): number | null;
+    /** Whether all configured global concurrency slots are currently occupied. */
+    isConcurrencyMaxed(queue: string): boolean;
     /** Get all queue names with state */
     getQueueNames(): string[];
     /** Delete queue data */

package/dist/domain/queue/limiterManager.js

@@ -78,6 +78,25 @@ export class LimiterManager {
         const limiter = this.rateLimiters.get(queue);
         return !limiter || limiter.tryAcquire();
     }
+    /** Read the active rate-limit configuration after applying lazy expiry. */
+    getRateLimit(queue) {
+        this.expireRateLimitIfNeeded(queue);
+        const state = this.queueState.get(queue);
+        if (state?.rateLimit === null || state?.rateLimit === undefined)
+            return null;
+        return { max: state.rateLimit, duration: state.rateLimitDuration ?? 1000 };
+    }
+    /** Read the remaining temporary-limit TTL or token-bucket cooldown. */
+    getRateLimitTtl(queue, maxJobs) {
+        this.expireRateLimitIfNeeded(queue);
+        const state = this.queueState.get(queue);
+        if (state?.rateLimit === null || state?.rateLimit === undefined)
+            return -2;
+        if (state.rateLimitExpiresAt !== null) {
+            return Math.max(0, state.rateLimitExpiresAt - Date.now());
+        }
+        return this.rateLimiters.get(queue)?.getTtl(maxJobs) ?? -2;
+    }
     // ============ Concurrency Limiting ============
     /** Set concurrency limit for queue */
     setConcurrency(queue, limit) {
@@ -107,6 +126,15 @@ export class LimiterManager {
     releaseConcurrency(queue) {
         this.concurrencyLimiters.get(queue)?.release();
     }
+    /** Read the configured global concurrency limit. */
+    getConcurrency(queue) {
+        return this.queueState.get(queue)?.concurrencyLimit ?? null;
+    }
+    /** Whether all configured global concurrency slots are currently occupied. */
+    isConcurrencyMaxed(queue) {
+        const limiter = this.concurrencyLimiters.get(queue);
+        return limiter ? limiter.getActive() >= limiter.getLimit() : false;
+    }
     // ============ Queue Management ============
     /** Get all queue names with state */
     getQueueNames() {

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

@@ -63,7 +63,8 @@ export declare class Shard {
     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;
+    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;
@@ -73,13 +74,20 @@ export declare class Shard {
     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): void;
+    releaseJobResources(queue: string, uniqueKey: string | null, groupId: string | null, ownerId?: JobId): void;
     get waitingDeps(): Map<JobId, Job>;
     get dependencyIndex(): Map<JobId, Set<JobId>>;
     get waitingChildren(): Map<JobId, Job>;

package/dist/domain/queue/shard.js

@@ -114,7 +114,10 @@ export class Shard {
         return this.uniqueKeyManager.extendTtl(queue, key, ttl);
     }
     releaseUniqueKey(queue, key) {
-        this.uniqueKeyManager.release(queue, key);
+        return this.uniqueKeyManager.release(queue, key);
+    }
+    releaseUniqueKeyIfOwned(queue, key, ownerId) {
+        return this.uniqueKeyManager.releaseIfOwned(queue, key, ownerId);
     }
     cleanExpiredUniqueKeys() {
         return this.uniqueKeyManager.cleanExpired();
@@ -150,6 +153,12 @@ export class Shard {
     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);
     }
@@ -162,6 +171,12 @@ export class Shard {
     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();
     }
@@ -169,9 +184,13 @@ export class Shard {
         this.limiterManager.deleteQueue(queue);
     }
     // ============ Resource Release ============
-    releaseJobResources(queue, uniqueKey, groupId) {
-        if (uniqueKey)
-            this.releaseUniqueKey(queue, uniqueKey);
+    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/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() {

package/dist/domain/types/command.d.ts

@@ -5,6 +5,7 @@
 import type { JobInput, JobState } from './job';
 import type { AtomicFlowJobInput } from './flow';
 import type { CronJobOptions } from './cron';
+import type { DlqFilter } from './dlq';
 /** Base command interface */
 interface BaseCommand {
     readonly cmd: string;
@@ -143,6 +144,7 @@ export interface GetJobsCommand extends BaseCommand {
     readonly state?: JobState | JobState[];
     readonly limit?: number;
     readonly offset?: number;
+    readonly asc?: boolean;
 }
 export interface GetJobCountsCommand extends BaseCommand {
     readonly cmd: 'GetJobCounts';
@@ -238,6 +240,11 @@ export interface DlqCommand extends BaseCommand {
     readonly cmd: 'Dlq';
     readonly queue: string;
     readonly count?: number;
+    readonly filter?: DlqFilter;
+}
+export interface GetDlqStatsCommand extends BaseCommand {
+    readonly cmd: 'GetDlqStats';
+    readonly queue: string;
 }
 export interface RetryDlqCommand extends BaseCommand {
     readonly cmd: 'RetryDlq';
@@ -245,6 +252,7 @@ export interface RetryDlqCommand extends BaseCommand {
     readonly jobId?: string;
     /** Cap the number of DLQ entries retried (omit = retry all). #111-class. */
     readonly count?: number;
+    readonly filter?: DlqFilter;
 }
 export interface PurgeDlqCommand extends BaseCommand {
     readonly cmd: 'PurgeDlq';
@@ -254,6 +262,31 @@ export interface RetryCompletedCommand extends BaseCommand {
     readonly cmd: 'RetryCompleted';
     readonly queue: string;
     readonly id?: string;
+    readonly count?: number;
+    readonly timestamp?: number;
+}
+export interface GetQueueLimitsCommand extends BaseCommand {
+    readonly cmd: 'GetQueueLimits';
+    readonly queue: string;
+    readonly maxJobs?: number;
+}
+export interface GetDeduplicationJobIdCommand extends BaseCommand {
+    readonly cmd: 'GetDeduplicationJobId';
+    readonly queue: string;
+    readonly deduplicationId: string;
+}
+export interface RemoveDeduplicationKeyCommand extends BaseCommand {
+    readonly cmd: 'RemoveDeduplicationKey';
+    readonly queue: string;
+    readonly deduplicationId: string;
+}
+export interface RemoveJobDeduplicationKeyCommand extends BaseCommand {
+    readonly cmd: 'RemoveJobDeduplicationKey';
+    readonly id: string;
+}
+export interface MoveToWaitingChildrenCommand extends BaseCommand {
+    readonly cmd: 'MoveToWaitingChildren';
+    readonly id: string;
 }
 export interface RateLimitCommand extends BaseCommand {
     readonly cmd: 'RateLimit';
@@ -516,7 +549,7 @@ export interface HelloCommand extends BaseCommand {
     readonly capabilities?: 'pipelining'[];
 }
 /** Union of all commands */
-export type Command = PushCommand | PushBatchCommand | PushFlowCommand | PullCommand | PullBatchCommand | AckCommand | AckBatchCommand | FailCommand | GetJobCommand | GetStateCommand | GetResultCommand | GetJobsCommand | GetJobCountsCommand | GetCountsPerPriorityCommand | GetJobByCustomIdCommand | CountCommand | GetProgressCommand | CancelCommand | ProgressCommand | UpdateCommand | ChangePriorityCommand | PromoteCommand | WaitJobCommand | MoveToDelayedCommand | DiscardCommand | PauseCommand | ResumeCommand | IsPausedCommand | DrainCommand | ObliterateCommand | ListQueuesCommand | CleanCommand | DlqCommand | RetryDlqCommand | PurgeDlqCommand | RetryCompletedCommand | RateLimitCommand | SetConcurrencyCommand | RateLimitClearCommand | ClearConcurrencyCommand | SetStallConfigCommand | GetStallConfigCommand | SetDlqConfigCommand | GetDlqConfigCommand | CronCommand | CronDeleteCommand | CronListCommand | AddLogCommand | GetLogsCommand | HeartbeatCommand | JobHeartbeatCommand | JobHeartbeatBatchCommand | PingCommand | RegisterWorkerCommand | UnregisterWorkerCommand | ListWorkersCommand | AddWebhookCommand | RemoveWebhookCommand | ListWebhooksCommand | StatsCommand | MetricsCommand | PrometheusCommand | CronGetCommand | GetChildrenValuesCommand | StorageStatusCommand | ClearLogsCommand | ExtendLockCommand | ExtendLocksCommand | ChangeDelayCommand | SetWebhookEnabledCommand | CompactMemoryCommand | UpdateParentCommand | MoveToWaitCommand | PromoteJobsCommand | DashboardOverviewCommand | DashboardQueuesCommand | DashboardQueueCommand | AuthCommand | GetFailedChildrenValuesCommand | GetIgnoredChildrenFailuresCommand | RemoveChildDependencyCommand | RemoveUnprocessedChildrenCommand | HelloCommand;
+export type Command = PushCommand | PushBatchCommand | PushFlowCommand | PullCommand | PullBatchCommand | AckCommand | AckBatchCommand | FailCommand | GetJobCommand | GetStateCommand | GetResultCommand | GetJobsCommand | GetJobCountsCommand | GetCountsPerPriorityCommand | GetJobByCustomIdCommand | CountCommand | GetProgressCommand | CancelCommand | ProgressCommand | UpdateCommand | ChangePriorityCommand | PromoteCommand | WaitJobCommand | MoveToDelayedCommand | DiscardCommand | PauseCommand | ResumeCommand | IsPausedCommand | DrainCommand | ObliterateCommand | ListQueuesCommand | CleanCommand | DlqCommand | GetDlqStatsCommand | RetryDlqCommand | PurgeDlqCommand | RetryCompletedCommand | GetQueueLimitsCommand | GetDeduplicationJobIdCommand | RemoveDeduplicationKeyCommand | RemoveJobDeduplicationKeyCommand | MoveToWaitingChildrenCommand | RateLimitCommand | SetConcurrencyCommand | RateLimitClearCommand | ClearConcurrencyCommand | SetStallConfigCommand | GetStallConfigCommand | SetDlqConfigCommand | GetDlqConfigCommand | CronCommand | CronDeleteCommand | CronListCommand | AddLogCommand | GetLogsCommand | HeartbeatCommand | JobHeartbeatCommand | JobHeartbeatBatchCommand | PingCommand | RegisterWorkerCommand | UnregisterWorkerCommand | ListWorkersCommand | AddWebhookCommand | RemoveWebhookCommand | ListWebhooksCommand | StatsCommand | MetricsCommand | PrometheusCommand | CronGetCommand | GetChildrenValuesCommand | StorageStatusCommand | ClearLogsCommand | ExtendLockCommand | ExtendLocksCommand | ChangeDelayCommand | SetWebhookEnabledCommand | CompactMemoryCommand | UpdateParentCommand | MoveToWaitCommand | PromoteJobsCommand | DashboardOverviewCommand | DashboardQueuesCommand | DashboardQueueCommand | AuthCommand | GetFailedChildrenValuesCommand | GetIgnoredChildrenFailuresCommand | RemoveChildDependencyCommand | RemoveUnprocessedChildrenCommand | HelloCommand;
 /** Extract command type */
 export type CommandType = Command['cmd'];
 export {};

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

@@ -29,6 +29,11 @@ export declare class RateLimiter {
     private refill;
     /** Get current token count */
     getTokens(): number;
+    /**
+     * Milliseconds until the bucket can admit another job. When `maxJobs` is
+     * provided, report 0 until at least that many tokens have been consumed.
+     */
+    getTtl(maxJobs?: number): number;
 }
 /** Concurrency limiter */
 export declare class ConcurrencyLimiter {

package/dist/domain/types/queue.js

@@ -48,6 +48,19 @@ export class RateLimiter {
         this.refill();
         return this.tokens;
     }
+    /**
+     * Milliseconds until the bucket can admit another job. When `maxJobs` is
+     * provided, report 0 until at least that many tokens have been consumed.
+     */
+    getTtl(maxJobs) {
+        const tokens = this.getTokens();
+        const consumed = this.capacity - tokens;
+        if (maxJobs !== undefined && consumed < maxJobs)
+            return 0;
+        if (tokens >= 1 || this.refillRate <= 0)
+            return 0;
+        return Math.ceil(((1 - tokens) / this.refillRate) * 1000);
+    }
 }
 /** Concurrency limiter */
 export class ConcurrencyLimiter {

package/dist/infrastructure/persistence/sqlite.d.ts

@@ -97,6 +97,8 @@ export declare class SqliteStorage {
      */
     private flushIfBuffered;
     markActive(jobId: JobId, startedAt: number, timeline?: JobTimelineEntry[]): void;
+    /** Persist a manually parked parent so recovery does not requeue it. */
+    markWaitingChildren(jobId: JobId, timeline?: JobTimelineEntry[]): void;
     markCompleted(jobId: JobId, completedAt: number, timeline?: JobTimelineEntry[]): void;
     markFailed(job: Job, error: string | null): void;
     /** Save DLQ entry with full metadata */
@@ -122,6 +124,8 @@ export declare class SqliteStorage {
     deleteJob(jobId: JobId): void;
     /** Update a job's data blob (e.g. after adding __parentId) */
     updateJobData(jobId: JobId, data: unknown): void;
+    /** Clear a released deduplication key so recovery cannot resurrect it. */
+    clearJobUniqueKey(jobId: JobId): void;
     /** Persist priority ordering, including its LIFO tie-break, across recovery. */
     updateJobPriority(jobId: JobId, priority: number, lifo: boolean): void;
     /** Persist progress and its heartbeat as one active-job mutation. */

package/dist/infrastructure/persistence/sqlite.js

@@ -289,6 +289,15 @@ export class SqliteStorage {
                 .run('active', startedAt, timeline && timeline.length > 0 ? pack(timeline) : null, jobId);
         });
     }
+    /** Persist a manually parked parent so recovery does not requeue it. */
+    markWaitingChildren(jobId, timeline) {
+        this.flushIfBuffered(jobId);
+        this.safeWrite(() => {
+            this.db
+                .prepare('UPDATE jobs SET state = ?, started_at = NULL, timeline = ? WHERE id = ?')
+                .run('waiting-children', timeline && timeline.length > 0 ? pack(timeline) : null, jobId);
+        });
+    }
     markCompleted(jobId, completedAt, timeline) {
         this.flushIfBuffered(jobId);
         this.safeWrite(() => {
@@ -432,6 +441,13 @@ export class SqliteStorage {
             this.db.prepare('UPDATE jobs SET data = ? WHERE id = ?').run(pack(data), jobId);
         });
     }
+    /** Clear a released deduplication key so recovery cannot resurrect it. */
+    clearJobUniqueKey(jobId) {
+        this.flushIfBuffered(jobId);
+        this.safeWrite(() => {
+            this.db.prepare('UPDATE jobs SET unique_key = NULL WHERE id = ?').run(jobId);
+        });
+    }
     /** Persist priority ordering, including its LIFO tie-break, across recovery. */
     updateJobPriority(jobId, priority, lifo) {
         this.flushIfBuffered(jobId);

package/dist/infrastructure/server/handlerRoutes.js

@@ -6,7 +6,8 @@ import { handlePush, handlePushBatch, handlePull, handlePullBatch, handleAck, ha
 import { handlePushFlow } from './handlers/flow';
 import { handleGetJob, handleGetState, handleGetResult, handleGetJobCounts, handleGetCountsPerPriority, handleGetJobByCustomId, handleGetJobs, handleGetChildrenValues, } from './handlers/query';
 import { handleCancel, handleProgress, handleGetProgress, handlePause, handleResume, handleDrain, handleStats, handleMetrics, handleStorageStatus, } from './handlers/management';
-import { handleDlq, handleRetryDlq, handlePurgeDlq, handleRetryCompleted } from './handlers/dlq';
+import { handleDlq, handleGetDlqStats, handleRetryDlq, handlePurgeDlq, handleRetryCompleted, } from './handlers/dlq';
+import { handleGetQueueLimits, handleGetDeduplicationJobId, handleRemoveDeduplicationKey, handleRemoveJobDeduplicationKey, handleMoveToWaitingChildren, } from './handlers/introspection';
 import { handleCron, handleCronGet, handleCronDelete, handleCronList } from './handlers/cron';
 import { handleUpdate, handleUpdateParent, handleChangePriority, handlePromote, handleMoveToDelayed, handleDiscard, handleWaitJob, handleIsPaused, handleObliterate, handleListQueues, handleClean, handleCount, handleRateLimit, handleRateLimitClear, handleSetConcurrency, handleClearConcurrency, handleChangeDelay, handleMoveToWait, handlePromoteJobs, handleSetStallConfig, handleGetStallConfig, handleSetDlqConfig, handleGetDlqConfig, handleGetFailedChildrenValues, handleGetIgnoredChildrenFailures, handleRemoveChildDependency, handleRemoveUnprocessedChildren, } from './handlers/advanced';
 import { handleDashboardOverview, handleDashboardQueues, handleDashboardQueue, } from './handlers/dashboard';
@@ -59,6 +60,10 @@ export async function routeQueryCommand(cmd, ctx, reqId) {
             return handleGetProgress(cmd, ctx, reqId);
         case 'GetChildrenValues':
             return handleGetChildrenValues(cmd, ctx, reqId);
+        case 'GetQueueLimits':
+            return handleGetQueueLimits(cmd, ctx, reqId);
+        case 'GetDeduplicationJobId':
+            return handleGetDeduplicationJobId(cmd, ctx, reqId);
         default:
             return null;
     }
@@ -103,6 +108,12 @@ export async function routeManagementCommand(cmd, ctx, reqId) {
             return handleRemoveChildDependency(cmd, ctx, reqId);
         case 'RemoveUnprocessedChildren':
             return handleRemoveUnprocessedChildren(cmd, ctx, reqId);
+        case 'RemoveDeduplicationKey':
+            return handleRemoveDeduplicationKey(cmd, ctx, reqId);
+        case 'RemoveJobDeduplicationKey':
+            return handleRemoveJobDeduplicationKey(cmd, ctx, reqId);
+        case 'MoveToWaitingChildren':
+            return handleMoveToWaitingChildren(cmd, ctx, reqId);
         default:
             return null;
     }
@@ -135,6 +146,8 @@ export function routeDlqCommand(cmd, ctx, reqId) {
     switch (cmd.cmd) {
         case 'Dlq':
             return handleDlq(cmd, ctx, reqId);
+        case 'GetDlqStats':
+            return handleGetDlqStats(cmd, ctx, reqId);
         case 'RetryDlq':
             return handleRetryDlq(cmd, ctx, reqId);
         case 'PurgeDlq':

package/dist/infrastructure/server/handlers/dlq.d.ts

@@ -9,6 +9,9 @@ import type { HandlerContext } from '../types';
 export declare function handleDlq(cmd: Extract<Command, {
     cmd: 'Dlq';
 }>, ctx: HandlerContext, reqId?: string): Response;
+export declare function handleGetDlqStats(cmd: Extract<Command, {
+    cmd: 'GetDlqStats';
+}>, ctx: HandlerContext, reqId?: string): Response;
 /** Handle RetryDlq command - retry DLQ jobs */
 export declare function handleRetryDlq(cmd: Extract<Command, {
     cmd: 'RetryDlq';

package/dist/infrastructure/server/handlers/dlq.js

@@ -6,14 +6,25 @@ import * as resp from '../../../domain/types/response';
 import { jobId } from '../../../domain/types/job';
 /** Handle Dlq command - get DLQ jobs */
 export function handleDlq(cmd, ctx, reqId) {
-    const jobs = ctx.queueManager.getDlq(cmd.queue, cmd.count);
-    return resp.jobs(jobs, reqId);
+    const entries = ctx.queueManager.getDlqEntries(cmd.queue, cmd.filter);
+    const selected = cmd.count === undefined ? entries : entries.slice(0, Math.max(0, cmd.count));
+    return {
+        ok: true,
+        jobs: selected.map((entry) => entry.job),
+        entries: selected,
+        reqId,
+    };
+}
+export function handleGetDlqStats(cmd, ctx, reqId) {
+    return resp.data({ stats: ctx.queueManager.getDlqStats(cmd.queue) }, reqId);
 }
 /** Handle RetryDlq command - retry DLQ jobs */
 export function handleRetryDlq(cmd, ctx, reqId) {
     const jid = cmd.jobId ? jobId(cmd.jobId) : undefined;
     // #111-class: honour the caller's `count` cap instead of retrying the whole DLQ.
-    const count = ctx.queueManager.retryDlq(cmd.queue, jid, cmd.count);
+    const count = cmd.filter
+        ? ctx.queueManager.retryDlqByFilter(cmd.queue, cmd.filter)
+        : ctx.queueManager.retryDlq(cmd.queue, jid, cmd.count);
     if (count > 0) {
         const event = jid ? 'dlq:retried' : 'dlq:retry-all';
         const data = { queue: cmd.queue, count };
@@ -33,6 +44,9 @@ export function handlePurgeDlq(cmd, ctx, reqId) {
 /** Handle RetryCompleted command - retry completed jobs */
 export function handleRetryCompleted(cmd, ctx, reqId) {
     const jid = cmd.id ? jobId(cmd.id) : undefined;
-    const count = ctx.queueManager.retryCompleted(cmd.queue, jid);
+    const count = ctx.queueManager.retryCompleted(cmd.queue, jid, {
+        limit: cmd.count,
+        timestamp: cmd.timestamp,
+    });
     return { ok: true, count, reqId };
 }