bunqueue 2.8.34 → 2.8.36

package/dist/client/queue/dlq.js

@@ -4,6 +4,7 @@
  */
 import { getSharedManager } from '../manager';
 import { jobId } from '../../domain/types/job';
+import { createSimpleJob } from './jobProxy';
 import * as dlqOps from './dlqOps';
 /** Client-side cache for TCP mode */
 const tcpDlqConfigCache = new Map();
@@ -18,6 +19,18 @@ export function setDlqConfig(ctx, config) {
         void ctx.tcp.send({ cmd: 'SetDlqConfig', queue: ctx.name, config });
     }
 }
+/** Set DLQ configuration and resolve once the server has applied it. */
+export async function setDlqConfigAsync(ctx, config) {
+    if (ctx.embedded) {
+        dlqOps.setDlqConfig(ctx.name, config);
+        return;
+    }
+    if (!ctx.tcp)
+        return;
+    const current = tcpDlqConfigCache.get(ctx.name) ?? {};
+    tcpDlqConfigCache.set(ctx.name, { ...current, ...config });
+    await ctx.tcp.send({ cmd: 'SetDlqConfig', queue: ctx.name, config });
+}
 /** Get DLQ configuration */
 export function getDlqConfig(ctx) {
     if (ctx.embedded)
@@ -45,6 +58,38 @@ export function getDlq(ctx, filter) {
         return [];
     return dlqOps.getDlqEntries(ctx.name, filter);
 }
+/**
+ * Get the dead jobs in the DLQ, working over TCP too (wire command `Dlq`).
+ * Returns public Job objects; the wire does not carry DlqEntry metadata
+ * (reason, enteredAt, attempts) — that stays embedded-only via getDlq().
+ */
+export async function getDlqJobsAsync(ctx, count) {
+    let raw;
+    if (ctx.embedded) {
+        raw = getSharedManager().getDlq(ctx.name, count);
+    }
+    else if (ctx.tcp) {
+        const response = await ctx.tcp.send({ cmd: 'Dlq', queue: ctx.name, count });
+        if (!response.ok)
+            return [];
+        raw = (response.jobs ?? []);
+    }
+    else {
+        return [];
+    }
+    return raw.map((job) => {
+        const name = job.data?.name ?? 'unknown';
+        return createSimpleJob(String(job.id), name, job.data, job.createdAt ?? Date.now(), {
+            queueName: ctx.name,
+            embedded: ctx.embedded,
+            tcp: ctx.tcp,
+            getJobState: ctx.getJobState,
+            removeAsync: ctx.removeAsync,
+            retryJob: ctx.retryJob,
+            getChildrenValues: ctx.getChildrenValues,
+        });
+    });
+}
 /** Get DLQ stats */
 export function getDlqStats(ctx) {
     if (!ctx.embedded) {
@@ -67,6 +112,21 @@ export function retryDlq(ctx, id) {
         void ctx.tcp.send({ cmd: 'RetryDlq', queue: ctx.name, jobId: id });
     return 0;
 }
+/**
+ * Retry DLQ entries and resolve with the retried count once the server has
+ * processed it. The fire-and-forget retryDlq() always returns 0 over TCP and
+ * discards the server's count.
+ */
+export async function retryDlqAsync(ctx, id) {
+    if (ctx.embedded)
+        return dlqOps.retryDlqEmbedded(ctx.name, id);
+    if (!ctx.tcp)
+        return 0;
+    const response = await ctx.tcp.send({ cmd: 'RetryDlq', queue: ctx.name, jobId: id });
+    if (!response.ok)
+        return 0;
+    return (response.count ?? 0);
+}
 /** Retry DLQ entries by filter */
 export function retryDlqByFilter(ctx, filter) {
     if (!ctx.embedded)
@@ -81,6 +141,21 @@ export function purgeDlq(ctx) {
         void ctx.tcp.send({ cmd: 'PurgeDlq', queue: ctx.name });
     return 0;
 }
+/**
+ * Purge the DLQ and resolve with the purged count once the server has
+ * processed it. The fire-and-forget purgeDlq() always returns 0 over TCP;
+ * purge-then-assert-empty patterns need this variant.
+ */
+export async function purgeDlqAsync(ctx) {
+    if (ctx.embedded)
+        return dlqOps.purgeDlqEmbedded(ctx.name);
+    if (!ctx.tcp)
+        return 0;
+    const response = await ctx.tcp.send({ cmd: 'PurgeDlq', queue: ctx.name });
+    if (!response.ok)
+        return 0;
+    return (response.count ?? 0);
+}
 /** Retry completed job */
 export function retryCompleted(ctx, id) {
     if (ctx.embedded) {

package/dist/client/queue/helpers.js

@@ -19,6 +19,8 @@ export function getDlqContext(manager) {
     return {
         shards: getShards(manager),
         jobIndex: manager.getJobIndex(),
+        jobResults: manager.jobResults,
+        jobLogs: manager.jobLogs,
         // #110-class: without storage, retryDlqByFilter's deleteDlqEntry/insertJob
         // silently no-op — filtered retries were never persisted in embedded mode
         // (dlq rows resurrected the jobs into the DLQ on restart).

package/dist/client/queue/jobProxy.d.ts

@@ -29,7 +29,7 @@ export interface JobReflectionMeta {
 }
 /** Create a full Job proxy with TCP methods */
 export declare function createJobProxy<T>(id: string, name: string, data: T, ctx: JobProxyContext, meta?: JobReflectionMeta): Job<T>;
-interface SimpleJobContext {
+export interface SimpleJobContext {
     queueName: string;
     /** Execution mode — determines whether to use embedded manager or TCP */
     embedded?: boolean;

package/dist/client/queue/operations/control.d.ts

@@ -10,12 +10,29 @@ interface ControlContext {
 }
 /** Pause the queue */
 export declare function pause(ctx: ControlContext): void;
+/** Pause the queue and resolve once the server has processed it. */
+export declare function pauseAsync(ctx: ControlContext): Promise<void>;
 /** Resume the queue */
 export declare function resume(ctx: ControlContext): void;
+/** Resume the queue and resolve once the server has processed it. */
+export declare function resumeAsync(ctx: ControlContext): Promise<void>;
 /** Drain the queue (remove all waiting jobs) */
 export declare function drain(ctx: ControlContext): void;
+/**
+ * Drain the queue and resolve with the number of removed jobs once the
+ * server has processed it. Same ordering guarantee as obliterateAsync():
+ * jobs added after resolution cannot be caught by a late-arriving drain.
+ */
+export declare function drainAsync(ctx: ControlContext): Promise<number>;
 /** Obliterate the queue (remove all jobs and data) */
 export declare function obliterate(ctx: ControlContext): void;
+/**
+ * Obliterate the queue and resolve once the server has processed it.
+ * The fire-and-forget obliterate() gives no ordering guarantee over a
+ * multi-connection pool: a PUSH sent right after it can be processed first
+ * and then wiped. Await this variant before enqueuing follow-up jobs.
+ */
+export declare function obliterateAsync(ctx: ControlContext): Promise<void>;
 /** Check if queue is paused (sync, embedded only) */
 export declare function isPaused(ctx: ControlContext): boolean;
 /** Check if queue is paused (async, works with TCP) */

package/dist/client/queue/operations/control.js

@@ -10,6 +10,13 @@ export function pause(ctx) {
     else if (ctx.tcp)
         void ctx.tcp.send({ cmd: 'Pause', queue: ctx.name });
 }
+/** Pause the queue and resolve once the server has processed it. */
+export async function pauseAsync(ctx) {
+    if (ctx.embedded)
+        getSharedManager().pause(ctx.name);
+    else if (ctx.tcp)
+        await ctx.tcp.send({ cmd: 'Pause', queue: ctx.name });
+}
 /** Resume the queue */
 export function resume(ctx) {
     if (ctx.embedded)
@@ -17,6 +24,13 @@ export function resume(ctx) {
     else if (ctx.tcp)
         void ctx.tcp.send({ cmd: 'Resume', queue: ctx.name });
 }
+/** Resume the queue and resolve once the server has processed it. */
+export async function resumeAsync(ctx) {
+    if (ctx.embedded)
+        getSharedManager().resume(ctx.name);
+    else if (ctx.tcp)
+        await ctx.tcp.send({ cmd: 'Resume', queue: ctx.name });
+}
 /** Drain the queue (remove all waiting jobs) */
 export function drain(ctx) {
     if (ctx.embedded)
@@ -24,6 +38,21 @@ export function drain(ctx) {
     else if (ctx.tcp)
         void ctx.tcp.send({ cmd: 'Drain', queue: ctx.name });
 }
+/**
+ * Drain the queue and resolve with the number of removed jobs once the
+ * server has processed it. Same ordering guarantee as obliterateAsync():
+ * jobs added after resolution cannot be caught by a late-arriving drain.
+ */
+export async function drainAsync(ctx) {
+    if (ctx.embedded)
+        return getSharedManager().drain(ctx.name);
+    if (!ctx.tcp)
+        return 0;
+    const response = await ctx.tcp.send({ cmd: 'Drain', queue: ctx.name });
+    if (!response.ok)
+        return 0;
+    return (response.count ?? 0);
+}
 /** Obliterate the queue (remove all jobs and data) */
 export function obliterate(ctx) {
     if (ctx.embedded)
@@ -31,6 +60,18 @@ export function obliterate(ctx) {
     else if (ctx.tcp)
         void ctx.tcp.send({ cmd: 'Obliterate', queue: ctx.name });
 }
+/**
+ * Obliterate the queue and resolve once the server has processed it.
+ * The fire-and-forget obliterate() gives no ordering guarantee over a
+ * multi-connection pool: a PUSH sent right after it can be processed first
+ * and then wiped. Await this variant before enqueuing follow-up jobs.
+ */
+export async function obliterateAsync(ctx) {
+    if (ctx.embedded)
+        getSharedManager().obliterate(ctx.name);
+    else if (ctx.tcp)
+        await ctx.tcp.send({ cmd: 'Obliterate', queue: ctx.name });
+}
 /** Check if queue is paused (sync, embedded only) */
 export function isPaused(ctx) {
     if (!ctx.embedded)

package/dist/client/queue/operations/counts.d.ts

@@ -16,6 +16,7 @@ export interface JobCounts {
     failed: number;
     delayed: number;
     paused: number;
+    'waiting-children': number;
 }
 /**
  * Get job counts.

package/dist/client/queue/operations/counts.js

@@ -30,6 +30,7 @@ export function getJobCounts(ctx) {
         failed: counts.failed,
         delayed: counts.delayed,
         paused: pv.paused,
+        'waiting-children': counts['waiting-children'],
     };
 }
 /** Get job counts (async, works with TCP) */
@@ -47,6 +48,7 @@ export async function getJobCountsAsync(ctx) {
             failed: 0,
             delayed: 0,
             paused: 0,
+            'waiting-children': 0,
         };
     }
     const counts = response.counts;
@@ -58,6 +60,7 @@ export async function getJobCountsAsync(ctx) {
         failed: counts?.failed ?? 0,
         delayed: counts?.delayed ?? 0,
         paused: counts?.paused ?? 0,
+        'waiting-children': counts?.['waiting-children'] ?? 0,
     };
 }
 /** Get waiting job count */

package/dist/client/queue/queue.d.ts

@@ -74,9 +74,13 @@ export declare class Queue<T = unknown> {
     getCountsPerPriority(): Record<number, number>;
     getCountsPerPriorityAsync(): Promise<Record<number, number>>;
     pause(): void;
+    pauseAsync(): Promise<void>;
     resume(): void;
+    resumeAsync(): Promise<void>;
     drain(): void;
+    drainAsync(): Promise<number>;
     obliterate(): void;
+    obliterateAsync(): Promise<void>;
     isPaused(): boolean;
     isPausedAsync(): Promise<boolean>;
     waitUntilReady(): Promise<void>;
@@ -106,23 +110,32 @@ export declare class Queue<T = unknown> {
     changeJobPriority(id: string, opts: ChangePriorityOpts): Promise<void>;
     extendJobLock(id: string, token: string, duration: number): Promise<number>;
     setStallConfig(config: Partial<StallConfig>): void;
+    setStallConfigAsync(config: Partial<StallConfig>): Promise<void>;
     getStallConfig(): StallConfig;
     getStallConfigAsync(): Promise<StallConfig>;
     setDlqConfig(config: Partial<DlqConfig>): void;
+    setDlqConfigAsync(config: Partial<DlqConfig>): Promise<void>;
     getDlqConfig(): DlqConfig;
     getDlqConfigAsync(): Promise<DlqConfig>;
     getDlq(filter?: DlqFilter): DlqEntry<T>[];
+    getDlqJobsAsync(count?: number): Promise<Job<T>[]>;
     getDlqStats(): DlqStats;
     retryDlq(id?: string): number;
+    retryDlqAsync(id?: string): Promise<number>;
     retryDlqByFilter(filter: DlqFilter): number;
     purgeDlq(): number;
+    purgeDlqAsync(): Promise<number>;
     retryCompleted(id?: string): number;
     retryCompletedAsync(id?: string): Promise<number>;
     setGlobalConcurrency(concurrency: number): void;
+    setGlobalConcurrencyAsync(concurrency: number): Promise<void>;
     removeGlobalConcurrency(): void;
+    removeGlobalConcurrencyAsync(): Promise<void>;
     getGlobalConcurrency(): Promise<number | null>;
     setGlobalRateLimit(max: number, duration?: number): void;
+    setGlobalRateLimitAsync(max: number, duration?: number): Promise<void>;
     removeGlobalRateLimit(): void;
+    removeGlobalRateLimitAsync(): Promise<void>;
     getGlobalRateLimit(): Promise<{
         max: number;
         duration: number;

package/dist/client/queue/queue.js

@@ -262,15 +262,27 @@ export class Queue {
     pause() {
         controlOps.pause(this.ctx);
     }
+    pauseAsync() {
+        return controlOps.pauseAsync(this.ctx);
+    }
     resume() {
         controlOps.resume(this.ctx);
     }
+    resumeAsync() {
+        return controlOps.resumeAsync(this.ctx);
+    }
     drain() {
         controlOps.drain(this.ctx);
     }
+    drainAsync() {
+        return controlOps.drainAsync(this.ctx);
+    }
     obliterate() {
         controlOps.obliterate(this.ctx);
     }
+    obliterateAsync() {
+        return controlOps.obliterateAsync(this.ctx);
+    }
     isPaused() {
         return controlOps.isPaused(this.ctx);
     }
@@ -333,6 +345,9 @@ export class Queue {
     setStallConfig(config) {
         stallOps.setStallConfig(this.ctx, config);
     }
+    setStallConfigAsync(config) {
+        return stallOps.setStallConfigAsync(this.ctx, config);
+    }
     getStallConfig() {
         return stallOps.getStallConfig(this.ctx);
     }
@@ -343,6 +358,9 @@ export class Queue {
     setDlqConfig(config) {
         dlqOps.setDlqConfig(this.ctx, config);
     }
+    setDlqConfigAsync(config) {
+        return dlqOps.setDlqConfigAsync(this.ctx, config);
+    }
     getDlqConfig() {
         return dlqOps.getDlqConfig(this.ctx);
     }
@@ -352,18 +370,27 @@ export class Queue {
     getDlq(filter) {
         return dlqOps.getDlq(this.ctx, filter);
     }
+    getDlqJobsAsync(count) {
+        return dlqOps.getDlqJobsAsync(this.queryCtx, count);
+    }
     getDlqStats() {
         return dlqOps.getDlqStats(this.ctx);
     }
     retryDlq(id) {
         return dlqOps.retryDlq(this.ctx, id);
     }
+    retryDlqAsync(id) {
+        return dlqOps.retryDlqAsync(this.ctx, id);
+    }
     retryDlqByFilter(filter) {
         return dlqOps.retryDlqByFilter(this.ctx, filter);
     }
     purgeDlq() {
         return dlqOps.purgeDlq(this.ctx);
     }
+    purgeDlqAsync() {
+        return dlqOps.purgeDlqAsync(this.ctx);
+    }
     retryCompleted(id) {
         return dlqOps.retryCompleted(this.ctx, id);
     }
@@ -374,18 +401,30 @@ export class Queue {
     setGlobalConcurrency(concurrency) {
         rateLimitOps.setGlobalConcurrency(this.ctx, concurrency);
     }
+    setGlobalConcurrencyAsync(concurrency) {
+        return rateLimitOps.setGlobalConcurrencyAsync(this.ctx, concurrency);
+    }
     removeGlobalConcurrency() {
         rateLimitOps.removeGlobalConcurrency(this.ctx);
     }
+    removeGlobalConcurrencyAsync() {
+        return rateLimitOps.removeGlobalConcurrencyAsync(this.ctx);
+    }
     getGlobalConcurrency() {
         return rateLimitOps.getGlobalConcurrency(this.ctx);
     }
     setGlobalRateLimit(max, duration) {
         rateLimitOps.setGlobalRateLimit(this.ctx, max, duration);
     }
+    setGlobalRateLimitAsync(max, duration) {
+        return rateLimitOps.setGlobalRateLimitAsync(this.ctx, max, duration);
+    }
     removeGlobalRateLimit() {
         rateLimitOps.removeGlobalRateLimit(this.ctx);
     }
+    removeGlobalRateLimitAsync() {
+        return rateLimitOps.removeGlobalRateLimitAsync(this.ctx);
+    }
     getGlobalRateLimit() {
         return rateLimitOps.getGlobalRateLimit(this.ctx);
     }

package/dist/client/queue/rateLimit.d.ts

@@ -9,20 +9,35 @@ interface RateLimitContext {
 }
 /** Set global concurrency limit */
 export declare function setGlobalConcurrency(ctx: RateLimitContext, concurrency: number): void;
+/** Set global concurrency limit and resolve once the server has applied it. */
+export declare function setGlobalConcurrencyAsync(ctx: RateLimitContext, concurrency: number): Promise<void>;
 /** Remove global concurrency limit */
 export declare function removeGlobalConcurrency(ctx: RateLimitContext): void;
+/** Remove global concurrency limit and resolve once the server has applied it. */
+export declare function removeGlobalConcurrencyAsync(ctx: RateLimitContext): Promise<void>;
 /** Get global concurrency limit */
 export declare function getGlobalConcurrency(_ctx: RateLimitContext): Promise<number | null>;
-/** Set global rate limit */
-export declare function setGlobalRateLimit(ctx: RateLimitContext, max: number, _duration?: number): void;
+/**
+ * Set global rate limit: `max` jobs per `duration` ms (default 1000ms).
+ * The window is honored in both embedded and TCP modes.
+ */
+export declare function setGlobalRateLimit(ctx: RateLimitContext, max: number, duration?: number): void;
+/** Set global rate limit and resolve once the server has applied it. */
+export declare function setGlobalRateLimitAsync(ctx: RateLimitContext, max: number, duration?: number): Promise<void>;
 /** Remove global rate limit */
 export declare function removeGlobalRateLimit(ctx: RateLimitContext): void;
+/** Remove global rate limit and resolve once the server has applied it. */
+export declare function removeGlobalRateLimitAsync(ctx: RateLimitContext): Promise<void>;
 /** Get global rate limit */
 export declare function getGlobalRateLimit(_ctx: RateLimitContext): Promise<{
     max: number;
     duration: number;
 } | null>;
-/** Set temporary rate limit with expiration */
+/**
+ * Set temporary rate limit with expiration. The expiry lives broker-side
+ * (RateLimit `ttl`), so it survives client exit and works identically in
+ * embedded and TCP modes — no client timer involved.
+ */
 export declare function rateLimit(ctx: RateLimitContext, expireTimeMs: number): Promise<void>;
 /** Get rate limit TTL */
 export declare function getRateLimitTtl(_ctx: RateLimitContext, _maxJobs?: number): Promise<number>;

package/dist/client/queue/rateLimit.js

@@ -11,6 +11,13 @@ export function setGlobalConcurrency(ctx, concurrency) {
         void ctx.tcp.send({ cmd: 'SetConcurrency', queue: ctx.name, limit: concurrency });
     }
 }
+/** Set global concurrency limit and resolve once the server has applied it. */
+export async function setGlobalConcurrencyAsync(ctx, concurrency) {
+    if (ctx.embedded)
+        getSharedManager().setConcurrency(ctx.name, concurrency);
+    else if (ctx.tcp)
+        await ctx.tcp.send({ cmd: 'SetConcurrency', queue: ctx.name, limit: concurrency });
+}
 /** Remove global concurrency limit */
 export function removeGlobalConcurrency(ctx) {
     if (ctx.embedded) {
@@ -20,19 +27,36 @@ export function removeGlobalConcurrency(ctx) {
         void ctx.tcp.send({ cmd: 'ClearConcurrency', queue: ctx.name });
     }
 }
+/** Remove global concurrency limit and resolve once the server has applied it. */
+export async function removeGlobalConcurrencyAsync(ctx) {
+    if (ctx.embedded)
+        getSharedManager().clearConcurrency(ctx.name);
+    else if (ctx.tcp)
+        await ctx.tcp.send({ cmd: 'ClearConcurrency', queue: ctx.name });
+}
 /** Get global concurrency limit */
 export function getGlobalConcurrency(_ctx) {
     return Promise.resolve(null);
 }
-/** Set global rate limit */
-export function setGlobalRateLimit(ctx, max, _duration) {
+/**
+ * Set global rate limit: `max` jobs per `duration` ms (default 1000ms).
+ * The window is honored in both embedded and TCP modes.
+ */
+export function setGlobalRateLimit(ctx, max, duration) {
     if (ctx.embedded) {
-        getSharedManager().setRateLimit(ctx.name, max);
+        getSharedManager().setRateLimit(ctx.name, max, duration);
     }
     else if (ctx.tcp) {
-        void ctx.tcp.send({ cmd: 'RateLimit', queue: ctx.name, limit: max });
+        void ctx.tcp.send({ cmd: 'RateLimit', queue: ctx.name, limit: max, duration });
     }
 }
+/** Set global rate limit and resolve once the server has applied it. */
+export async function setGlobalRateLimitAsync(ctx, max, duration) {
+    if (ctx.embedded)
+        getSharedManager().setRateLimit(ctx.name, max, duration);
+    else if (ctx.tcp)
+        await ctx.tcp.send({ cmd: 'RateLimit', queue: ctx.name, limit: max, duration });
+}
 /** Remove global rate limit */
 export function removeGlobalRateLimit(ctx) {
     if (ctx.embedded) {
@@ -42,20 +66,31 @@ export function removeGlobalRateLimit(ctx) {
         void ctx.tcp.send({ cmd: 'RateLimitClear', queue: ctx.name });
     }
 }
+/** Remove global rate limit and resolve once the server has applied it. */
+export async function removeGlobalRateLimitAsync(ctx) {
+    if (ctx.embedded)
+        getSharedManager().clearRateLimit(ctx.name);
+    else if (ctx.tcp)
+        await ctx.tcp.send({ cmd: 'RateLimitClear', queue: ctx.name });
+}
 /** Get global rate limit */
 export function getGlobalRateLimit(_ctx) {
     return Promise.resolve(null);
 }
-/** Set temporary rate limit with expiration */
+/**
+ * Set temporary rate limit with expiration. The expiry lives broker-side
+ * (RateLimit `ttl`), so it survives client exit and works identically in
+ * embedded and TCP modes — no client timer involved.
+ */
 export async function rateLimit(ctx, expireTimeMs) {
+    if (!Number.isFinite(expireTimeMs) || expireTimeMs <= 0) {
+        throw new Error(`rateLimit: expireTimeMs must be a positive finite number, got ${expireTimeMs}`);
+    }
     if (ctx.embedded) {
-        getSharedManager().setRateLimit(ctx.name, 1);
-        setTimeout(() => {
-            getSharedManager().clearRateLimit(ctx.name);
-        }, expireTimeMs);
+        getSharedManager().setRateLimit(ctx.name, 1, undefined, expireTimeMs);
     }
     else if (ctx.tcp) {
-        await ctx.tcp.send({ cmd: 'RateLimit', queue: ctx.name, limit: 1 });
+        await ctx.tcp.send({ cmd: 'RateLimit', queue: ctx.name, limit: 1, ttl: expireTimeMs });
     }
 }
 /** Get rate limit TTL */

package/dist/client/queue/stall.d.ts

@@ -11,6 +11,8 @@ interface StallContext {
 }
 /** Set stall detection configuration */
 export declare function setStallConfig(ctx: StallContext, config: Partial<StallConfig>): void;
+/** Set stall detection configuration and resolve once the server has applied it. */
+export declare function setStallConfigAsync(ctx: StallContext, config: Partial<StallConfig>): Promise<void>;
 /** Get stall detection configuration */
 export declare function getStallConfig(ctx: StallContext): StallConfig;
 /** Get stall detection configuration (async, works in TCP mode) */

package/dist/client/queue/stall.js

@@ -23,6 +23,18 @@ export function setStallConfig(ctx, config) {
         void ctx.tcp.send({ cmd: 'SetStallConfig', queue: ctx.name, config });
     }
 }
+/** Set stall detection configuration and resolve once the server has applied it. */
+export async function setStallConfigAsync(ctx, config) {
+    if (ctx.embedded) {
+        dlqOps.setStallConfigEmbedded(ctx.name, config);
+        return;
+    }
+    if (!ctx.tcp)
+        return;
+    const current = tcpConfigCache.get(ctx.name) ?? { ...DEFAULT_STALL_CONFIG };
+    tcpConfigCache.set(ctx.name, { ...current, ...config });
+    await ctx.tcp.send({ cmd: 'SetStallConfig', queue: ctx.name, config });
+}
 /** Get stall detection configuration */
 export function getStallConfig(ctx) {
     if (ctx.embedded) {

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

@@ -54,6 +54,11 @@ export declare class DependencyTracker {
      * Remove a parent job from waiting
      */
     removeWaitingParent(jobId: JobId): Job | undefined;
+    /**
+     * Remove every dependency-gated job owned by a queue.
+     * Returns the removed ids so the caller can purge global indexes and storage.
+     */
+    removeQueue(queue: string): JobId[];
     /**
      * Get a parent job waiting for children
      */

package/dist/domain/queue/dependencyTracker.js

@@ -100,6 +100,26 @@ export class DependencyTracker {
         }
         return job;
     }
+    /**
+     * Remove every dependency-gated job owned by a queue.
+     * Returns the removed ids so the caller can purge global indexes and storage.
+     */
+    removeQueue(queue) {
+        const removed = [];
+        for (const [jobId, job] of this.waitingDeps) {
+            if (job.queue !== queue)
+                continue;
+            this.removeWaitingJob(jobId);
+            removed.push(jobId);
+        }
+        for (const [jobId, job] of this.waitingChildren) {
+            if (job.queue !== queue)
+                continue;
+            this.waitingChildren.delete(jobId);
+            removed.push(jobId);
+        }
+        return removed;
+    }
     /**
      * Get a parent job waiting for children
      */

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

@@ -20,10 +20,22 @@ export declare class LimiterManager {
     pause(name: string): void;
     /** Resume queue */
     resume(name: string): void;
-    /** Set rate limit for queue */
-    setRateLimit(queue: string, limit: number): void;
+    /**
+     * Set rate limit for queue.
+     * @param durationMs window the limit applies to (default 1000ms): `limit`
+     *   tokens refill over `durationMs`. Non-finite or non-positive → default.
+     * @param ttlMs auto-expiry: the limit clears itself after this many ms
+     *   (lazy, checked on acquire/read). Non-finite or non-positive → permanent.
+     */
+    setRateLimit(queue: string, limit: number, durationMs?: number, ttlMs?: number): void;
     /** Clear rate limit */
     clearRateLimit(queue: string): void;
+    /**
+     * Drop the rate limit if its TTL has elapsed. Lazy expiry: called from the
+     * acquire path and from limit reads, so no timer is needed and an expired
+     * limit can never throttle a pull.
+     */
+    expireRateLimitIfNeeded(queue: string): void;
     /** Try to acquire rate limit token */
     tryAcquireRateLimit(queue: string): boolean;
     /** Set concurrency limit for queue */