bunqueue 2.8.53 → 2.8.56

package/dist/client/bunqueue.d.ts

@@ -1,36 +1,11 @@
-/**
- * Bunqueue - Simplified all-in-one Queue + Worker
- * Routes, middleware, cron, batch, retry, circuit breaker, TTL, aging, cancellation.
- */
-import { Queue } from './queue/queue';
-import { Worker } from './worker/worker';
-import type { Job, JobOptions, DlqConfig, DlqEntry, DlqStats, DlqFilter } from './types';
 import type { SchedulerInfo } from './queue/scheduler';
-import type { BunqueueOptions, BunqueueMiddleware, TriggerRule, CircuitState } from './bunqueue/types';
-export type { BunqueueMiddleware, BunqueueOptions, RetryStrategy, RetryConfig, CircuitBreakerConfig, TriggerRule, PriorityAgingConfig, BatchProcessor, BatchConfig, JobTtlConfig, BunqueueDeduplicationConfig, BunqueueDebounceConfig, BunqueueDlqConfig, } from './bunqueue/types';
-export declare class Bunqueue<T = unknown, R = unknown> {
-    readonly name: string;
-    readonly queue: Queue<T>;
-    readonly worker: Worker<T, R>;
-    private readonly middlewares;
-    private readonly baseProcessor;
-    private readonly cb;
-    private readonly retryConfig;
-    private readonly triggerMgr;
-    private readonly ager;
-    private readonly cancellation;
-    private readonly ttlChecker;
-    private readonly batchAcc;
-    private readonly merger;
-    private readonly dlqrl;
-    constructor(name: string, opts: BunqueueOptions<T, R>);
-    private buildRouteProcessor;
-    private buildQueueOpts;
-    private buildWorkerOpts;
-    private processJob;
-    private runMiddlewareChain;
-    use(middleware: BunqueueMiddleware<T, R>): this;
-    add(name: string, data: T, opts?: JobOptions): Promise<Job<T>>;
+import type { DlqConfig, DlqEntry, DlqFilter, DlqStats, Job, JobOptions } from './types';
+import { BunqueueRuntime } from './bunqueue/runtime';
+import type { CircuitState, TriggerRule } from './bunqueue/types';
+export type { BatchConfig, BatchProcessor, BunqueueDebounceConfig, BunqueueDeduplicationConfig, BunqueueDlqConfig, BunqueueMiddleware, BunqueueOptions, CircuitBreakerConfig, JobTtlConfig, PriorityAgingConfig, RetryConfig, RetryStrategy, TriggerRule, } from './bunqueue/types';
+/** Simplified all-in-one Queue and Worker façade. */
+export declare class Bunqueue<T = unknown, R = unknown> extends BunqueueRuntime<T, R> {
+    add(name: string, data: T, options?: JobOptions): Promise<Job<T>>;
     addBulk(jobs: Array<{
         name: string;
         data: T;
@@ -41,12 +16,12 @@ export declare class Bunqueue<T = unknown, R = unknown> {
     getJobCountsAsync(): Promise<import("./queue/operations").JobCounts>;
     count(): number;
     countAsync(): Promise<number>;
-    cron(id: string, pattern: string, data?: T, opts?: {
+    cron(id: string, pattern: string, data?: T, options?: {
         timezone?: string;
         limit?: number;
         jobOpts?: JobOptions;
     }): Promise<SchedulerInfo | null>;
-    every(id: string, intervalMs: number, data?: T, opts?: {
+    every(id: string, intervalMs: number, data?: T, options?: {
         limit?: number;
         jobOpts?: JobOptions;
     }): Promise<SchedulerInfo | null>;
@@ -61,13 +36,21 @@ export declare class Bunqueue<T = unknown, R = unknown> {
     setDefaultTtl(ttlMs: number): void;
     setNameTtl(name: string, ttlMs: number): void;
     setDlqConfig(config: Partial<DlqConfig>): void;
+    setDlqConfigAsync(config: Partial<DlqConfig>): Promise<void>;
     getDlqConfig(): DlqConfig;
+    getDlqConfigAsync(): Promise<DlqConfig>;
     getDlq(filter?: DlqFilter): DlqEntry<T>[];
+    getDlqAsync(filter?: DlqFilter): Promise<DlqEntry<T>[]>;
     getDlqStats(): DlqStats;
+    getDlqStatsAsync(): Promise<DlqStats>;
     retryDlq(id?: string): number;
+    retryDlqAsync(id?: string): Promise<number>;
     purgeDlq(): number;
+    purgeDlqAsync(): Promise<number>;
     setGlobalRateLimit(max: number, duration?: number): void;
+    setGlobalRateLimitAsync(max: number, duration?: number): Promise<void>;
     removeGlobalRateLimit(): void;
+    removeGlobalRateLimitAsync(): Promise<void>;
     on(event: 'ready' | 'drained' | 'closed', listener: () => void): this;
     on(event: 'active', listener: (job: Job<T>) => void): this;
     on(event: 'completed', listener: (job: Job<T>, result: R) => void): this;
@@ -81,6 +64,8 @@ export declare class Bunqueue<T = unknown, R = unknown> {
     off(event: any, listener: (...args: any[]) => void): this;
     pause(): void;
     resume(): void;
+    pauseAsync(): Promise<void>;
+    resumeAsync(): Promise<void>;
     close(force?: boolean): Promise<void>;
     isRunning(): boolean;
     isPaused(): boolean;

package/dist/client/bunqueue.js

@@ -1,158 +1,14 @@
-/**
- * Bunqueue - Simplified all-in-one Queue + Worker
- * Routes, middleware, cron, batch, retry, circuit breaker, TTL, aging, cancellation.
- */
-import { Queue } from './queue/queue';
-import { Worker } from './worker/worker';
-import { DlqRateLimitManager } from './bunqueue/dlqRateLimit';
-import { executeWithRetry } from './bunqueue/retry';
-import { WorkerCircuitBreaker } from './bunqueue/circuitBreaker';
-import { BatchAccumulator } from './bunqueue/batch';
-import { TriggerManager } from './bunqueue/triggers';
-import { PriorityAger } from './bunqueue/aging';
-import { CancellationManager } from './bunqueue/cancellation';
-import { TtlChecker } from './bunqueue/ttl';
-import { DedupDebounceMerger } from './bunqueue/dedupDebounce';
-export class Bunqueue {
-    name;
-    queue;
-    worker;
-    middlewares = [];
-    baseProcessor;
-    cb;
-    retryConfig;
-    triggerMgr;
-    ager;
-    cancellation = new CancellationManager();
-    ttlChecker;
-    batchAcc;
-    merger;
-    dlqrl;
-    constructor(name, opts) {
-        const modes = [opts.processor, opts.routes, opts.batch].filter(Boolean).length;
-        if (modes === 0)
-            throw new Error('Bunqueue requires "processor", "routes", or "batch"');
-        if (modes > 1)
-            throw new Error('Bunqueue: use only one of "processor", "routes", or "batch"');
-        this.name = name;
-        this.retryConfig = opts.retry ?? null;
-        this.ttlChecker = opts.ttl ? new TtlChecker(opts.ttl) : null;
-        this.merger = new DedupDebounceMerger(opts.deduplication ?? null, opts.debounce ?? null);
-        // Build base processor
-        if (opts.batch) {
-            this.batchAcc = new BatchAccumulator(opts.batch);
-            this.baseProcessor = this.batchAcc.buildProcessor();
-        }
-        else {
-            this.batchAcc = null;
-            this.baseProcessor = opts.routes ? this.buildRouteProcessor(opts.routes) : opts.processor; // eslint-disable-line @typescript-eslint/no-non-null-assertion
-        }
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const self = this;
-        const wrappedProcessor = (job) => self.processJob(job);
-        this.queue = new Queue(name, this.buildQueueOpts(opts));
-        this.worker = new Worker(name, wrappedProcessor, this.buildWorkerOpts(opts));
-        // DLQ & Rate Limit manager
-        this.dlqrl = new DlqRateLimitManager(this.queue);
-        if (opts.dlq)
-            this.dlqrl.setDlqConfig(opts.dlq);
-        // Initialize subsystems
-        this.cb = opts.circuitBreaker
-            ? new WorkerCircuitBreaker(opts.circuitBreaker, this.worker)
-            : null;
-        this.triggerMgr = new TriggerManager(this.queue, this.worker);
-        this.ager = opts.priorityAging ? new PriorityAger(opts.priorityAging, this.queue) : null;
-        this.ager?.start();
-    }
-    buildRouteProcessor(routes) {
-        const routeMap = routes;
-        return (job) => {
-            const handler = routeMap[job.name];
-            if (!handler)
-                throw new Error(`No route for job "${job.name}" in queue "${this.name}"`);
-            return handler(job);
-        };
-    }
-    buildQueueOpts(opts) {
-        return {
-            connection: opts.connection,
-            embedded: opts.embedded,
-            dataPath: opts.dataPath,
-            defaultJobOptions: opts.defaultJobOptions,
-            autoBatch: opts.autoBatch,
-            prefixKey: opts.prefixKey,
-        };
-    }
-    buildWorkerOpts(opts) {
-        return {
-            connection: opts.connection,
-            embedded: opts.embedded,
-            dataPath: opts.dataPath,
-            concurrency: opts.concurrency,
-            autorun: opts.autorun,
-            heartbeatInterval: opts.heartbeatInterval,
-            batchSize: opts.batchSize,
-            pollTimeout: opts.pollTimeout,
-            limiter: opts.rateLimit ?? opts.limiter,
-            removeOnComplete: opts.removeOnComplete,
-            removeOnFail: opts.removeOnFail,
-            prefixKey: opts.prefixKey,
-        };
-    }
-    // ============ Core Processing Pipeline ============
-    processJob(job) {
-        // Circuit breaker check
-        if (this.cb?.isOpen()) {
-            return Promise.reject(new Error('Circuit breaker is open'));
-        }
-        // TTL check
-        if (this.ttlChecker?.isExpired(job.name, job.timestamp)) {
-            return Promise.reject(new Error(`Job expired (age: ${Date.now() - job.timestamp}ms)`));
-        }
-        // Register cancellation
-        const ac = this.cancellation.register(job.id);
-        const runChain = () => this.runMiddlewareChain(job, ac);
-        const execute = this.retryConfig ? executeWithRetry(runChain, this.retryConfig) : runChain();
-        return execute.then((result) => {
-            this.cb?.onSuccess();
-            this.cancellation.unregister(job.id);
-            return result;
-        }, (err) => {
-            this.cb?.onFailure();
-            this.cancellation.unregister(job.id);
-            throw err;
-        });
-    }
-    runMiddlewareChain(job, ac) {
-        const asJob = job;
-        if (this.middlewares.length === 0) {
-            const result = this.baseProcessor(job);
-            return result instanceof Promise ? result : Promise.resolve(result);
-        }
-        let index = 0;
-        const mws = this.middlewares;
-        const base = this.baseProcessor;
-        const next = () => {
-            if (ac.signal.aborted)
-                return Promise.reject(new Error('Job cancelled'));
-            if (index < mws.length)
-                return mws[index++](asJob, next);
-            const result = base(job);
-            return result instanceof Promise ? result : Promise.resolve(result);
-        };
-        return next();
-    }
-    // ============ Middleware ============
-    use(middleware) {
-        this.middlewares.push(middleware);
-        return this;
-    }
-    // ============ Queue Operations ============
-    add(name, data, opts) {
-        return this.queue.add(name, data, this.merger.merge(name, opts, data));
+import { BunqueueRuntime } from './bunqueue/runtime';
+/** Simplified all-in-one Queue and Worker façade. */
+export class Bunqueue extends BunqueueRuntime {
+    add(name, data, options) {
+        return this.queue.add(name, data, this.merger.merge(name, options, data));
     }
     addBulk(jobs) {
-        return this.queue.addBulk(jobs.map((j) => ({ ...j, opts: this.merger.merge(j.name, j.opts, j.data) })));
+        return this.queue.addBulk(jobs.map((job) => ({
+            ...job,
+            opts: this.merger.merge(job.name, job.opts, job.data),
+        })));
     }
     getJob(id) {
         return this.queue.getJob(id);
@@ -169,12 +25,11 @@ export class Bunqueue {
     countAsync() {
         return this.queue.countAsync();
     }
-    // ============ Cron ============
-    cron(id, pattern, data, opts) {
-        return this.queue.upsertJobScheduler(id, { pattern, timezone: opts?.timezone, limit: opts?.limit }, { name: id, data, opts: opts?.jobOpts });
+    cron(id, pattern, data, options) {
+        return this.queue.upsertJobScheduler(id, { pattern, timezone: options?.timezone, limit: options?.limit }, { name: id, data, opts: options?.jobOpts });
     }
-    every(id, intervalMs, data, opts) {
-        return this.queue.upsertJobScheduler(id, { every: intervalMs, limit: opts?.limit }, { name: id, data, opts: opts?.jobOpts });
+    every(id, intervalMs, data, options) {
+        return this.queue.upsertJobScheduler(id, { every: intervalMs, limit: options?.limit }, { name: id, data, opts: options?.jobOpts });
     }
     removeCron(id) {
         return this.queue.removeJobScheduler(id);
@@ -182,7 +37,6 @@ export class Bunqueue {
     listCrons() {
         return this.queue.getJobSchedulers();
     }
-    // ============ Cancellation (feature 3) ============
     cancel(jobId, gracePeriodMs = 0) {
         this.cancellation.cancel(jobId, gracePeriodMs);
     }
@@ -192,51 +46,70 @@ export class Bunqueue {
     getSignal(jobId) {
         return this.cancellation.getSignal(jobId);
     }
-    // ============ Circuit Breaker (feature 5) ============
     getCircuitState() {
         return this.cb?.currentState ?? 'closed';
     }
     resetCircuit() {
         this.cb?.reset();
     }
-    // ============ Triggers (feature 6) ============
     trigger(rule) {
         this.triggerMgr.add(rule);
         return this;
     }
-    // ============ TTL (feature 7) ============
     setDefaultTtl(ttlMs) {
         this.ttlChecker?.setDefaultTtl(ttlMs);
     }
     setNameTtl(name, ttlMs) {
         this.ttlChecker?.setNameTtl(name, ttlMs);
     }
-    // ============ DLQ (feature 12) ============
     setDlqConfig(config) {
         this.dlqrl.setDlqConfig(config);
     }
+    setDlqConfigAsync(config) {
+        return this.dlqrl.setDlqConfigAsync(config);
+    }
     getDlqConfig() {
         return this.dlqrl.getDlqConfig();
     }
+    getDlqConfigAsync() {
+        return this.dlqrl.getDlqConfigAsync();
+    }
     getDlq(filter) {
         return this.dlqrl.getDlq(filter);
     }
+    getDlqAsync(filter) {
+        return this.dlqrl.getDlqAsync(filter);
+    }
     getDlqStats() {
         return this.dlqrl.getDlqStats();
     }
+    getDlqStatsAsync() {
+        return this.dlqrl.getDlqStatsAsync();
+    }
     retryDlq(id) {
         return this.dlqrl.retryDlq(id);
     }
+    retryDlqAsync(id) {
+        return this.dlqrl.retryDlqAsync(id);
+    }
     purgeDlq() {
         return this.dlqrl.purgeDlq();
     }
-    // ============ Rate Limiting ============
+    purgeDlqAsync() {
+        return this.dlqrl.purgeDlqAsync();
+    }
     setGlobalRateLimit(max, duration) {
         this.dlqrl.setGlobalRateLimit(max, duration);
     }
+    setGlobalRateLimitAsync(max, duration) {
+        return this.dlqrl.setGlobalRateLimitAsync(max, duration);
+    }
     removeGlobalRateLimit() {
         this.dlqrl.removeGlobalRateLimit();
     }
+    removeGlobalRateLimitAsync() {
+        return this.dlqrl.removeGlobalRateLimitAsync();
+    }
     on(event, listener) {
         this.worker.on(event, listener);
         return this;
@@ -249,8 +122,6 @@ export class Bunqueue {
         this.worker.off(event, listener);
         return this;
     }
-    /* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument */
-    // ============ Control ============
     pause() {
         this.queue.pause();
         this.worker.pause();
@@ -259,6 +130,14 @@ export class Bunqueue {
         this.queue.resume();
         this.worker.resume();
     }
+    async pauseAsync() {
+        await this.queue.pauseAsync();
+        this.worker.pause();
+    }
+    async resumeAsync() {
+        await this.queue.resumeAsync();
+        this.worker.resume();
+    }
     async close(force = false) {
         this.ager?.destroy();
         this.cb?.destroy();

package/dist/client/dlqConversion.d.ts

@@ -0,0 +1,5 @@
+import type { DlqEntry as InternalDlqEntry } from '../domain/types/dlq';
+import type { DlqEntry, Job } from './types';
+import type { CreatePublicJobOptions, PublicJobMethodContext } from './jobConversionTypes';
+/** Convert authoritative DLQ metadata while retaining live public Job methods. */
+export declare function convertDlqEntry<T>(entry: InternalDlqEntry, methods: PublicJobMethodContext, buildJob: (options: CreatePublicJobOptions) => Job<T>): DlqEntry<T>;

package/dist/client/dlqConversion.js

@@ -0,0 +1,28 @@
+import { resolvePublicJobPayload } from './jobHelpers';
+/** Convert authoritative DLQ metadata while retaining live public Job methods. */
+export function convertDlqEntry(entry, methods, buildJob) {
+    const { name } = resolvePublicJobPayload(entry.job);
+    return {
+        job: buildJob({
+            job: entry.job,
+            name,
+            failedReason: entry.error ?? undefined,
+            ...methods,
+        }),
+        enteredAt: entry.enteredAt,
+        reason: entry.reason,
+        error: entry.error,
+        attempts: entry.attempts.map((attempt) => ({
+            attempt: attempt.attempt,
+            startedAt: attempt.startedAt,
+            failedAt: attempt.failedAt,
+            reason: attempt.reason,
+            error: attempt.error,
+            duration: attempt.duration,
+        })),
+        retryCount: entry.retryCount,
+        lastRetryAt: entry.lastRetryAt,
+        nextRetryAt: entry.nextRetryAt,
+        expiresAt: entry.expiresAt,
+    };
+}

package/dist/client/events.d.ts

@@ -3,61 +3,8 @@
  */
 import { EventEmitter } from 'events';
 import { type JobEvent } from '../domain/types/queue';
-/** Event payload for 'waiting' event */
-export interface WaitingEvent {
-    jobId: string;
-}
-/** Event payload for 'active' event */
-export interface ActiveEvent {
-    jobId: string;
-}
-/** Event payload for 'completed' event */
-export interface CompletedEvent<R = unknown> {
-    jobId: string;
-    returnvalue: R;
-}
-/** Event payload for 'failed' event */
-export interface FailedEvent {
-    jobId: string;
-    failedReason: string;
-    data?: unknown;
-}
-/** Event payload for 'progress' event */
-export interface ProgressEvent<P = unknown> {
-    jobId: string;
-    data: P;
-}
-/** Event payload for 'stalled' event */
-export interface StalledEvent {
-    jobId: string;
-}
-/** Event payload for 'removed' event */
-export interface RemovedEvent {
-    jobId: string;
-    prev: string;
-}
-/** Event payload for 'delayed' event */
-export interface DelayedEvent {
-    jobId: string;
-    delay: number;
-}
-/** Event payload for 'duplicated' event */
-export interface DuplicatedEvent {
-    jobId: string;
-}
-/** Event payload for 'retried' event */
-export interface RetriedEvent {
-    jobId: string;
-    prev: string;
-}
-/** Event payload for 'waiting-children' event */
-export interface WaitingChildrenEvent {
-    jobId: string;
-}
-/** Event payload for 'drained' event */
-export interface DrainedEvent {
-    id: string;
-}
+import type { ActiveEvent, CompletedEvent, DelayedEvent, DrainedEvent, DuplicatedEvent, FailedEvent, ProgressEvent, QueueEventsOptions, RemovedEvent, RetriedEvent, StalledEvent, WaitingChildrenEvent, WaitingEvent } from './types/events';
+export type { ActiveEvent, CompletedEvent, DelayedEvent, DrainedEvent, DuplicatedEvent, FailedEvent, ProgressEvent, QueueEventsOptions, RemovedEvent, RetriedEvent, StalledEvent, WaitingChildrenEvent, WaitingEvent, } from './types/events';
 /**
  * QueueEvents class for listening to queue events
  * Provides a way to listen to events without processing jobs
@@ -84,8 +31,11 @@ export declare class QueueEvents<R = unknown, P = unknown> extends EventEmitter
     readonly name: string;
     private running;
     private unsubscribe;
+    private subscription;
     private ready;
-    constructor(name: string);
+    private readonly queueKey;
+    private readonly options;
+    constructor(name: string, options?: QueueEventsOptions);
     on(event: 'waiting', listener: (data: WaitingEvent) => void): this;
     on(event: 'active', listener: (data: ActiveEvent) => void): this;
     on(event: 'completed', listener: (data: CompletedEvent<R>) => void): this;
@@ -116,6 +66,7 @@ export declare class QueueEvents<R = unknown, P = unknown> extends EventEmitter
     once(event: 'error', listener: (error: Error, event?: JobEvent) => void): this;
     private dispatchEvent;
     private start;
+    private emitTransportError;
     /** Emit an error event (can be called externally) */
     emitError(error: Error): void;
     /**

package/dist/client/events.js

@@ -3,6 +3,7 @@
  */
 import { EventEmitter } from 'events';
 import { getSharedManager } from './manager';
+import { TcpEventSubscription } from './queue-events/tcpSubscription';
 /**
  * QueueEvents class for listening to queue events
  * Provides a way to listen to events without processing jobs
@@ -29,17 +30,22 @@ export class QueueEvents extends EventEmitter {
     name;
     running = false;
     unsubscribe = null;
+    subscription = null;
     ready = false;
-    constructor(name) {
+    queueKey;
+    options;
+    constructor(name, options = {}) {
         super();
         this.name = name;
+        this.options = options;
+        this.queueKey = (options.prefixKey ?? '') + name;
         this.start();
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // biome-ignore lint/suspicious/noExplicitAny: EventEmitter's fallback overload requires any[].
     on(event, listener) {
         return super.on(event, listener);
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // biome-ignore lint/suspicious/noExplicitAny: EventEmitter's fallback overload requires any[].
     once(event, listener) {
         return super.once(event, listener);
     }
@@ -60,12 +66,12 @@ export class QueueEvents extends EventEmitter {
                     failedReason: event.error ?? 'Job failed',
                     data: event.data,
                 });
-                if (event.error) {
+                if (event.error && this.listenerCount('error') > 0) {
                     this.emit('error', new Error(event.error), event);
                 }
                 break;
             case "progress" /* EventType.Progress */:
-                this.emit('progress', { jobId: event.jobId, data: event.data });
+                this.emit('progress', { jobId: event.jobId, data: event.progress ?? event.data });
                 break;
             case "stalled" /* EventType.Stalled */:
                 this.emit('stalled', { jobId: event.jobId });
@@ -97,22 +103,35 @@ export class QueueEvents extends EventEmitter {
         }
     }
     start() {
-        if (this.running || this.unsubscribe)
+        if (this.running || this.unsubscribe || this.subscription)
             return;
         this.running = true;
-        const manager = getSharedManager();
         const handler = (event) => {
             try {
-                if (event.queue !== this.name)
+                if (event.queue !== this.queueKey)
                     return;
                 this.dispatchEvent(event);
             }
             catch (err) {
-                this.emit('error', err instanceof Error ? err : new Error(String(err)));
+                this.emitTransportError(err instanceof Error ? err : new Error(String(err)));
             }
         };
-        this.unsubscribe = manager.subscribe(handler);
-        this.ready = true;
+        const embedded = this.options.embedded ?? this.options.connection === undefined;
+        if (embedded) {
+            this.unsubscribe = getSharedManager(this.options.dataPath).subscribe(handler);
+            this.ready = true;
+            return;
+        }
+        this.subscription = new TcpEventSubscription({
+            connection: this.options.connection,
+            queue: this.queueKey,
+            onEvent: handler,
+            onError: (error) => this.emitTransportError(error),
+        });
+    }
+    emitTransportError(error) {
+        if (this.listenerCount('error') > 0)
+            this.emit('error', error);
     }
     /** Emit an error event (can be called externally) */
     emitError(error) {
@@ -124,11 +143,13 @@ export class QueueEvents extends EventEmitter {
      * BullMQ v5 compatible.
      */
     async waitUntilReady() {
-        // In embedded mode, we're always ready after construction
-        if (this.ready)
+        if (this.subscription) {
+            await this.subscription.waitUntilReady();
+            this.ready = true;
             return;
-        // Wait a tick for the subscription to complete
-        await new Promise((resolve) => setImmediate(resolve));
+        }
+        if (!this.ready)
+            throw new Error('QueueEvents is closed');
     }
     /**
      * Disconnect from the event stream.
@@ -146,6 +167,8 @@ export class QueueEvents extends EventEmitter {
             this.unsubscribe();
             this.unsubscribe = null;
         }
+        this.subscription?.close();
+        this.subscription = null;
         this.removeAllListeners();
     }
 }

package/dist/client/flow.d.ts

@@ -4,6 +4,7 @@
  */
 import { EventEmitter } from 'events';
 import type { FlowProducerOptions, FlowStep, FlowResult, FlowJob, JobNode, GetFlowOpts, FlowOpts } from './flowTypes';
+import { type RuntimeResult } from './flowResults';
 export type { FlowProducerOptions, FlowStep, FlowResult, FlowJob, JobNode, GetFlowOpts, FlowOpts, } from './flowTypes';
 /**
  * FlowProducer creates job flows with automatic dependencies.
@@ -30,11 +31,10 @@ export type { FlowProducerOptions, FlowStep, FlowResult, FlowJob, JobNode, GetFl
  * ```
  */
 export declare class FlowProducer extends EventEmitter {
-    closing: Promise<void>;
+    closing: Promise<void> | null;
     private readonly embedded;
     private readonly tcp;
     private readonly useSharedPool;
-    private closed;
     constructor(opts?: FlowProducerOptions);
     /** Get push context for helper functions */
     private get pushCtx();
@@ -59,16 +59,10 @@ export declare class FlowProducer extends EventEmitter {
     }>;
     /** Add a tree of jobs where children depend on parent. */
     addTree<T = unknown>(root: FlowStep<T>): Promise<FlowResult>;
-    /**
-     * Get the result of a completed parent job (embedded only).
-     * @template R - Type of the job result
-     */
-    getParentResult<R = unknown>(parentId: string): R | undefined;
-    /**
-     * Get results from multiple parent jobs (embedded only).
-     * @template R - Type of the job results
-     */
-    getParentResults<R = unknown>(parentIds: string[]): Map<string, R>;
+    /** Get the result of a completed parent job in embedded or TCP mode. */
+    getParentResult<R = unknown>(parentId: string): RuntimeResult<R | undefined>;
+    /** Get results from multiple parent jobs in input order in either runtime. */
+    getParentResults<R = unknown>(parentIds: string[]): RuntimeResult<Map<string, R>>;
     /** Build callbacks that wire flow job methods to actual management operations */
     private buildCallbacks;
     private buildPlannedNode;