bunqueue 2.8.53 → 2.8.56

package/dist/client/worker/runtime/polling.js

@@ -0,0 +1,123 @@
+import { WORKER_CONSTANTS } from '../constants';
+import { pullEmbedded, pullTcp } from '../workerPull';
+import { WorkerBuffer } from './buffer';
+export class WorkerPolling extends WorkerBuffer {
+    poll() {
+        if (!this.running || this._closing)
+            return;
+        if (this.activeJobs >= this.opts.concurrency) {
+            this.pollTimer = setTimeout(() => {
+                this.poll();
+            }, 10);
+            return;
+        }
+        if (!this.rateLimiter.canProcessWithinLimit()) {
+            this.scheduleRateLimitPoll();
+            return;
+        }
+        void this.tryProcess();
+    }
+    async tryProcess() {
+        if (!this.running || this._closing)
+            return;
+        try {
+            let item = this.getNextEligibleJob();
+            if (!item) {
+                if (!this.rateLimiter.canProcessWithinLimit()) {
+                    this.scheduleRateLimitPoll();
+                    return;
+                }
+                const pulledItems = await this.doPullBatch();
+                if (!this.running || this._closing)
+                    return;
+                if (pulledItems.length > 0) {
+                    const items = this.registerPulledJobs(pulledItems);
+                    if (this.pendingJobsHead >= this.pendingJobs.length) {
+                        this.pendingJobs = items;
+                        this.pendingJobsHead = 0;
+                    }
+                    else {
+                        this.pendingJobs = this.pendingJobs.slice(this.pendingJobsHead).concat(items);
+                        this.pendingJobsHead = 0;
+                    }
+                    item = this.getNextEligibleJob();
+                }
+            }
+            if (item) {
+                if (this.activeJobs >= this.opts.concurrency) {
+                    this.requeueItem(item);
+                    this.pollTimer = setTimeout(() => {
+                        this.poll();
+                    }, 10);
+                    return;
+                }
+                this.consecutiveErrors = 0;
+                if (!this.startJob(item)) {
+                    this.requeueItem(item);
+                    this.scheduleRateLimitPoll();
+                }
+            }
+            else {
+                const hasBuffered = this.pendingJobsHead < this.pendingJobs.length;
+                if (hasBuffered && this.groupLimiter) {
+                    this.pollTimer = setTimeout(() => {
+                        this.poll();
+                    }, 10);
+                    return;
+                }
+                const now = Date.now();
+                if (now - this.lastDrainedEmit > 1000) {
+                    this.lastDrainedEmit = now;
+                    this.emit('drained');
+                }
+                const waitTime = this.opts.pollTimeout > 0 ? 10 : this.opts.drainDelay;
+                this.pollTimer = setTimeout(() => {
+                    this.poll();
+                }, waitTime);
+            }
+        }
+        catch (error) {
+            if (!this.running)
+                return;
+            this.handlePullError(error);
+        }
+    }
+    async doPullBatch() {
+        const groupBlockedBuffer = this.groupLimiter !== null && this.pendingJobsHead < this.pendingJobs.length;
+        const leased = groupBlockedBuffer ? this.activeJobs : this.pulledJobIds.size;
+        const slots = this.opts.concurrency - leased - this.pendingPull;
+        const rateSlots = this.rateLimiter.getAvailableSlots() - this.pendingPull;
+        const batchSize = Math.min(this.opts.batchSize, slots, rateSlots, 1000);
+        if (batchSize <= 0)
+            return [];
+        const config = this.getPullConfig();
+        this.pendingPull += batchSize;
+        try {
+            return this.embedded
+                ? await pullEmbedded(config, batchSize)
+                : await pullTcp(config, this.tcp, batchSize, this._closing);
+        }
+        finally {
+            this.pendingPull -= batchSize;
+        }
+    }
+    scheduleRateLimitPoll() {
+        const waitTime = this.rateLimiter.getTimeUntilNextSlot();
+        this.pollTimer = setTimeout(() => {
+            this.poll();
+        }, Math.max(waitTime, 10));
+    }
+    handlePullError(errorValue) {
+        this.consecutiveErrors++;
+        const error = errorValue instanceof Error ? errorValue : new Error(String(errorValue));
+        this.emit('error', Object.assign(error, {
+            queue: this.name,
+            consecutiveErrors: this.consecutiveErrors,
+            context: 'pull',
+        }));
+        const backoffMs = Math.min(WORKER_CONSTANTS.BASE_BACKOFF_MS * Math.pow(2, this.consecutiveErrors - 1), WORKER_CONSTANTS.MAX_BACKOFF_MS);
+        this.pollTimer = setTimeout(() => {
+            this.poll();
+        }, backoffMs);
+    }
+}

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

@@ -0,0 +1,110 @@
+import { EventEmitter } from 'events';
+import type { Job as InternalJob } from '../../../domain/types/job';
+import type { Job, Processor, WorkerOptions } from '../../types';
+import type { TcpConnectionPool } from '../../tcpPool';
+import { AckBatcher } from '../ackBatcher';
+import { GroupConcurrencyLimiter } from '../groupConcurrency';
+import type { HeartbeatDeps } from '../workerHeartbeat';
+import { WorkerRateLimiter } from '../workerRateLimiter';
+import type { ExtendedWorkerOptions, TcpConnection } from '../types';
+import type { TcpEventSubscription } from '../../queue-events/tcpSubscription';
+export interface PulledJob {
+    job: InternalJob;
+    token: string | null;
+}
+export interface WorkerDelivery extends PulledJob {
+    generation: number;
+}
+export declare abstract class WorkerState<T = unknown, R = unknown> extends EventEmitter {
+    readonly name: string;
+    protected readonly queueKey: string;
+    readonly opts: ExtendedWorkerOptions;
+    protected readonly processor: Processor<T, R>;
+    protected readonly embedded: boolean;
+    protected readonly tcp: TcpConnection | null;
+    protected readonly tcpPool: TcpConnectionPool | null;
+    protected readonly ackBatcher: AckBatcher;
+    protected readonly rateLimiter: WorkerRateLimiter;
+    protected readonly groupLimiter: GroupConcurrencyLimiter | null;
+    protected running: boolean;
+    protected paused: boolean;
+    protected _closing: boolean;
+    protected _forceClose: boolean;
+    protected _closingPromise: Promise<void> | null;
+    protected closed: boolean;
+    protected activeJobs: number;
+    protected pollTimer: ReturnType<typeof setTimeout> | null;
+    protected consecutiveErrors: number;
+    protected readonly pulledJobIds: Set<string>;
+    protected readonly jobTokens: Map<string, string>;
+    protected readonly cancelledJobs: Set<string>;
+    private deliverySequence;
+    private readonly currentDeliveries;
+    private readonly activeDeliveries;
+    protected heartbeatTimer: ReturnType<typeof setInterval> | null;
+    protected workerHeartbeatTimer: ReturnType<typeof setInterval> | null;
+    protected processedCount: number;
+    protected failedCount: number;
+    protected readonly startedAt: number;
+    protected registered: boolean;
+    protected readonly workerId: string;
+    protected pendingJobs: WorkerDelivery[];
+    protected pendingJobsHead: number;
+    protected processingScheduled: boolean;
+    protected pendingPull: number;
+    protected lastDrainedEmit: number;
+    protected stalledUnsubscribe: (() => void) | null;
+    protected stalledSubscription: TcpEventSubscription | null;
+    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;
+    on(event: 'failed', listener: (job: Job<T>, error: Error) => void): this;
+    on(event: 'progress', listener: (job: Job<T> | null, progress: number) => void): this;
+    on(event: 'stalled', listener: (jobId: string, reason: string) => void): this;
+    on(event: 'error', listener: (error: Error) => void): this;
+    on(event: 'cancelled', listener: (data: {
+        jobId: string;
+        reason: string;
+    }) => void): this;
+    on(event: 'log', listener: (job: Job<T>, message: string) => void): this;
+    once(event: 'ready' | 'drained' | 'closed', listener: () => void): this;
+    once(event: 'active', listener: (job: Job<T>) => void): this;
+    once(event: 'completed', listener: (job: Job<T>, result: R) => void): this;
+    once(event: 'failed', listener: (job: Job<T>, error: Error) => void): this;
+    once(event: 'progress', listener: (job: Job<T> | null, progress: number) => void): this;
+    once(event: 'stalled', listener: (jobId: string, reason: string) => void): this;
+    once(event: 'error', listener: (error: Error) => void): this;
+    once(event: 'cancelled', listener: (data: {
+        jobId: string;
+        reason: string;
+    }) => void): this;
+    once(event: 'log', listener: (job: Job<T>, message: string) => void): this;
+    off(event: 'ready' | 'drained' | 'closed', listener: () => void): this;
+    off(event: 'active', listener: (job: Job<T>) => void): this;
+    off(event: 'completed', listener: (job: Job<T>, result: R) => void): this;
+    off(event: 'failed', listener: (job: Job<T>, error: Error) => void): this;
+    off(event: 'progress', listener: (job: Job<T> | null, progress: number) => void): this;
+    off(event: 'stalled', listener: (jobId: string, reason: string) => void): this;
+    off(event: 'error', listener: (error: Error) => void): this;
+    off(event: 'cancelled', listener: (data: {
+        jobId: string;
+        reason: string;
+    }) => void): this;
+    off(event: 'log', listener: (job: Job<T>, message: string) => void): this;
+    constructor(name: string, processor: Processor<T, R>, options?: WorkerOptions);
+    protected trackDelivery(item: PulledJob): WorkerDelivery;
+    protected currentDelivery(jobId: string): WorkerDelivery | undefined;
+    protected isCurrentDelivery(delivery: WorkerDelivery): boolean;
+    protected isActiveDelivery(delivery: WorkerDelivery): boolean;
+    protected beginDelivery(delivery: WorkerDelivery): void;
+    protected finishDelivery(delivery: WorkerDelivery): void;
+    protected forgetDelivery(delivery: WorkerDelivery): void;
+    protected hasActiveDelivery(jobId: string): boolean;
+    protected activeDeliveryIds(): IterableIterator<string>;
+    protected clearDeliveries(): void;
+    abstract run(): void;
+    protected abstract registerWithServer(): void;
+    protected abstract getHeartbeatDeps(): HeartbeatDeps;
+    protected abstract startWorkerHeartbeat(): void;
+    protected abstract poll(): void;
+}

package/dist/client/worker/runtime/state.js

@@ -0,0 +1,156 @@
+import { EventEmitter } from 'events';
+import { getSharedManager } from '../../manager';
+import { AckBatcher } from '../ackBatcher';
+import { FORCE_EMBEDDED, WORKER_CONSTANTS } from '../constants';
+import { GroupConcurrencyLimiter } from '../groupConcurrency';
+import { WorkerRateLimiter } from '../workerRateLimiter';
+import { createTcpPool, resolveWorkerOptions } from './options';
+export class WorkerState extends EventEmitter {
+    name;
+    queueKey;
+    opts;
+    processor;
+    embedded;
+    tcp;
+    tcpPool;
+    ackBatcher;
+    rateLimiter;
+    groupLimiter;
+    running = false;
+    paused = false;
+    _closing = false;
+    _forceClose = false;
+    _closingPromise = null;
+    closed = false;
+    activeJobs = 0;
+    pollTimer = null;
+    consecutiveErrors = 0;
+    pulledJobIds = new Set();
+    jobTokens = new Map();
+    cancelledJobs = new Set();
+    deliverySequence = 0;
+    currentDeliveries = new Map();
+    activeDeliveries = new Map();
+    heartbeatTimer = null;
+    workerHeartbeatTimer = null;
+    processedCount = 0;
+    failedCount = 0;
+    startedAt;
+    registered = false;
+    workerId;
+    pendingJobs = [];
+    pendingJobsHead = 0;
+    processingScheduled = false;
+    pendingPull = 0;
+    lastDrainedEmit = 0;
+    stalledUnsubscribe = null;
+    stalledSubscription = null;
+    // biome-ignore lint/suspicious/noExplicitAny: EventEmitter's fallback listener is intentionally untyped
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: EventEmitter's fallback listener is intentionally untyped
+    once(event, listener) {
+        return super.once(event, listener);
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: EventEmitter's fallback listener is intentionally untyped
+    off(event, listener) {
+        return super.off(event, listener);
+    }
+    constructor(name, processor, options = {}) {
+        super();
+        this.name = name;
+        this.queueKey = (options.prefixKey ?? '') + name;
+        this.processor = processor;
+        this.embedded = options.embedded ?? FORCE_EMBEDDED;
+        this.startedAt = Date.now();
+        this.workerId = `worker-${this.queueKey}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+        this.opts = resolveWorkerOptions(options, this.embedded);
+        this.rateLimiter = new WorkerRateLimiter(options.limiter?.groupKey ? null : (options.limiter ?? null));
+        this.groupLimiter = GroupConcurrencyLimiter.fromOptions(options.limiter);
+        this.ackBatcher = new AckBatcher({
+            batchSize: options.batchSize ?? 10,
+            interval: WORKER_CONSTANTS.DEFAULT_ACK_INTERVAL,
+            embedded: this.embedded,
+        });
+        if (this.embedded) {
+            getSharedManager(options.dataPath);
+            this.tcp = null;
+            this.tcpPool = null;
+        }
+        else {
+            this.tcpPool = createTcpPool(options, this.opts.concurrency);
+            this.tcp = this.tcpPool;
+            this.ackBatcher.setTcp(this.tcp);
+            this.tcpPool.onReconnect(() => {
+                if (this.closed || this._closing || !this.registered)
+                    return;
+                this.registered = false;
+                this.registerWithServer();
+            });
+        }
+        if (this.opts.autorun)
+            this.run();
+    }
+    trackDelivery(item) {
+        const delivery = { ...item, generation: ++this.deliverySequence };
+        const jobId = String(item.job.id);
+        this.currentDeliveries.set(jobId, delivery);
+        this.pulledJobIds.add(jobId);
+        if (this.opts.useLocks && item.token)
+            this.jobTokens.set(jobId, item.token);
+        else
+            this.jobTokens.delete(jobId);
+        return delivery;
+    }
+    currentDelivery(jobId) {
+        return this.currentDeliveries.get(jobId);
+    }
+    isCurrentDelivery(delivery) {
+        return this.currentDeliveries.get(String(delivery.job.id))?.generation === delivery.generation;
+    }
+    isActiveDelivery(delivery) {
+        return this.activeDeliveries.get(String(delivery.job.id))?.has(delivery.generation) ?? false;
+    }
+    beginDelivery(delivery) {
+        const jobId = String(delivery.job.id);
+        let generations = this.activeDeliveries.get(jobId);
+        if (!generations) {
+            generations = new Set();
+            this.activeDeliveries.set(jobId, generations);
+        }
+        generations.add(delivery.generation);
+    }
+    finishDelivery(delivery) {
+        const jobId = String(delivery.job.id);
+        const generations = this.activeDeliveries.get(jobId);
+        generations?.delete(delivery.generation);
+        if (generations?.size === 0)
+            this.activeDeliveries.delete(jobId);
+        if (this.isCurrentDelivery(delivery)) {
+            this.currentDeliveries.delete(jobId);
+            this.pulledJobIds.delete(jobId);
+            this.jobTokens.delete(jobId);
+        }
+        if (!this.activeDeliveries.has(jobId))
+            this.cancelledJobs.delete(jobId);
+    }
+    forgetDelivery(delivery) {
+        if (!this.isCurrentDelivery(delivery))
+            return;
+        const jobId = String(delivery.job.id);
+        this.currentDeliveries.delete(jobId);
+        this.pulledJobIds.delete(jobId);
+        this.jobTokens.delete(jobId);
+    }
+    hasActiveDelivery(jobId) {
+        return this.activeDeliveries.has(jobId);
+    }
+    activeDeliveryIds() {
+        return this.activeDeliveries.keys();
+    }
+    clearDeliveries() {
+        this.currentDeliveries.clear();
+        this.activeDeliveries.clear();
+    }
+}

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

@@ -0,0 +1,5 @@
+export type { ExtendedWorkerOptions } from './options';
+export type { ManualJob } from './manual';
+export type { ManualMove, PendingTransitionSettlement } from './outcome';
+export type { FailureContext, ProcessorConfig } from './processor';
+export type { PendingAck, TcpConnection } from './transport';

package/dist/client/worker/types/index.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,7 @@
+import type { Job as InternalJob } from '../../../domain/types/job';
+/** Job returned by Worker.getNextJob() for explicit manual processing. */
+export type ManualJob<T = unknown> = Omit<InternalJob, 'data'> & {
+    readonly data: T;
+    /** Broker lease token when WorkerOptions.useLocks is enabled. */
+    readonly token?: string;
+};

package/dist/client/worker/types/manual.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,24 @@
+import type { ConnectionOptions } from '../../types';
+export interface ExtendedWorkerOptions {
+    concurrency: number;
+    autorun: boolean;
+    heartbeatInterval: number;
+    batchSize: number;
+    pollTimeout: number;
+    embedded: boolean;
+    useLocks: boolean;
+    skipLockRenewal: boolean;
+    skipStalledCheck: boolean;
+    drainDelay: number;
+    lockDuration: number;
+    maxStalledCount: number;
+    removeOnComplete?: boolean | number | {
+        age?: number;
+        count?: number;
+    };
+    removeOnFail?: boolean | number | {
+        age?: number;
+        count?: number;
+    };
+    connection?: ConnectionOptions;
+}

package/dist/client/worker/types/options.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,23 @@
+export type PendingTransitionSettlement = {
+    status: 'applied';
+} | {
+    status: 'ignored';
+} | {
+    status: 'failed';
+    error: Error;
+};
+export interface ManualMove {
+    result: {
+        type: 'completed';
+        value?: unknown;
+    } | {
+        type: 'failed';
+        error?: Error;
+    } | {
+        type: 'ignored' | 'transitioned';
+    } | {
+        type: 'pending-transition';
+        context: 'discard';
+        pending: Promise<PendingTransitionSettlement>;
+    } | null;
+}

package/dist/client/worker/types/outcome.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,22 @@
+import type { EventEmitter } from 'events';
+import type { FlowJobData, Job, Processor } from '../../types';
+import type { AckBatcher } from '../ackBatcher';
+import type { TcpConnection } from './transport';
+export interface ProcessorConfig<T, R> {
+    name: string;
+    processor: Processor<T, R>;
+    embedded: boolean;
+    tcp: TcpConnection | null;
+    ackBatcher: AckBatcher;
+    emitter: EventEmitter;
+    token?: string | null;
+    removeOnComplete?: boolean;
+    removeOnFail?: boolean;
+    onOutcome?: (succeeded: boolean) => void;
+    shouldAbandonOutcome?: () => boolean;
+}
+export interface FailureContext<T extends FlowJobData> {
+    job: Job<T>;
+    jobIdStr: string;
+    token?: string | null;
+}

package/dist/client/worker/types/processor.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,11 @@
+export interface PendingAck {
+    id: string;
+    result: unknown;
+    token?: string;
+    removeOnComplete?: boolean;
+    resolve: (applied: boolean) => void;
+    reject: (error: Error) => void;
+}
+export interface TcpConnection {
+    send: (command: Record<string, unknown>) => Promise<Record<string, unknown>>;
+}

package/dist/client/worker/types/transport.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,161 +1,4 @@
-/**
- * Worker
- * BullMQ-style worker for job processing
- */
-import { EventEmitter } from 'events';
-import type { WorkerOptions, Processor, Job } from '../types';
-import { type Job as InternalJob } from '../../domain/types/job';
-import type { ExtendedWorkerOptions } from './types';
-/**
- * Worker class for processing jobs
- */
-export declare class Worker<T = unknown, R = unknown> extends EventEmitter {
-    readonly name: string;
-    /**
-     * Server-side queue key. Equals `name` unless `prefixKey` is set, in which
-     * case it is `prefixKey + name`. All broker pulls/registrations route
-     * through this key so a Worker only sees jobs from its own namespace.
-     */
-    private readonly queueKey;
-    readonly opts: ExtendedWorkerOptions;
-    private readonly processor;
-    private readonly embedded;
-    private readonly tcp;
-    private readonly tcpPool;
-    private readonly ackBatcher;
-    private readonly rateLimiter;
-    private readonly groupLimiter;
-    private running;
-    private paused;
-    private _closing;
-    private _forceClose;
-    private _closingPromise;
-    private closed;
-    private activeJobs;
-    private pollTimer;
-    private consecutiveErrors;
-    private readonly activeJobIds;
-    private readonly pulledJobIds;
-    private readonly jobTokens;
-    private readonly cancelledJobs;
-    private heartbeatTimer;
-    private workerHeartbeatTimer;
-    private processedCount;
-    private failedCount;
-    private readonly startedAt;
-    private registered;
-    private readonly workerId;
-    private pendingJobs;
-    private pendingJobsHead;
-    private processingScheduled;
-    private pendingPull;
-    private lastDrainedEmit;
-    private stalledUnsubscribe;
-    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;
-    on(event: 'failed', listener: (job: Job<T>, error: Error) => void): this;
-    on(event: 'progress', listener: (job: Job<T> | null, progress: number) => void): this;
-    on(event: 'stalled', listener: (jobId: string, reason: string) => void): this;
-    on(event: 'error', listener: (error: Error) => void): this;
-    on(event: 'cancelled', listener: (data: {
-        jobId: string;
-        reason: string;
-    }) => void): this;
-    on(event: 'log', listener: (job: Job<T>, message: string) => void): this;
-    once(event: 'ready' | 'drained' | 'closed', listener: () => void): this;
-    once(event: 'active', listener: (job: Job<T>) => void): this;
-    once(event: 'completed', listener: (job: Job<T>, result: R) => void): this;
-    once(event: 'failed', listener: (job: Job<T>, error: Error) => void): this;
-    once(event: 'progress', listener: (job: Job<T> | null, progress: number) => void): this;
-    once(event: 'stalled', listener: (jobId: string, reason: string) => void): this;
-    once(event: 'error', listener: (error: Error) => void): this;
-    once(event: 'cancelled', listener: (data: {
-        jobId: string;
-        reason: string;
-    }) => void): this;
-    once(event: 'log', listener: (job: Job<T>, message: string) => void): this;
-    off(event: 'ready' | 'drained' | 'closed', listener: () => void): this;
-    off(event: 'active', listener: (job: Job<T>) => void): this;
-    off(event: 'completed', listener: (job: Job<T>, result: R) => void): this;
-    off(event: 'failed', listener: (job: Job<T>, error: Error) => void): this;
-    off(event: 'progress', listener: (job: Job<T> | null, progress: number) => void): this;
-    off(event: 'stalled', listener: (jobId: string, reason: string) => void): this;
-    off(event: 'error', listener: (error: Error) => void): this;
-    off(event: 'cancelled', listener: (data: {
-        jobId: string;
-        reason: string;
-    }) => void): this;
-    off(event: 'log', listener: (job: Job<T>, message: string) => void): this;
-    constructor(name: string, processor: Processor<T, R>, opts?: WorkerOptions);
-    /** Start processing */
-    run(): void;
-    /** Subscribe to stalled events from QueueManager (BullMQ v5 compatible) */
-    private subscribeToStalledEvents;
-    /** Pause processing */
-    pause(): void;
-    /** Resume processing */
-    resume(): void;
-    isRunning(): boolean;
-    isPaused(): boolean;
-    isClosed(): boolean;
-    /** Get current concurrency */
-    get concurrency(): number;
-    /** Set concurrency at runtime (BullMQ v5 compatible) */
-    set concurrency(val: number);
-    /** Promise that resolves when close() finishes (BullMQ v5 compatible) */
-    get closing(): Promise<void> | null;
-    waitUntilReady(): Promise<void>;
-    cancelJob(jobId: string, reason?: string): boolean;
-    cancelAllJobs(reason?: string): void;
-    isJobCancelled(jobId: string): boolean;
-    getRateLimiterInfo(): {
-        current: number;
-        max: number;
-        duration: number;
-    } | null;
-    rateLimit(expireTimeMs: number): void;
-    isRateLimited(): boolean;
-    startStalledCheckTimer(): Promise<void>;
-    delay(milliseconds?: number, abortController?: AbortController): Promise<void>;
-    getNextJob(token?: string, _opts?: {
-        block?: boolean;
-    }): Promise<InternalJob | undefined>;
-    processJobManually(job: InternalJob, token?: string, fetchNextCallback?: () => Promise<InternalJob | undefined>): Promise<InternalJob | undefined>;
-    extendJobLocks(jobIds: string[], tokens: string[], duration: number): Promise<number>;
-    close(force?: boolean): Promise<void>;
-    private _doClose;
-    /**
-     * Release all buffered (pulled-but-unstarted) jobs back to the queue on close.
-     * These jobs are `active` server-side holding a lock; moving them back to
-     * `waiting` makes them re-pullable so nothing is lost, and removes them from
-     * the close drain (which would otherwise hang on a buffer that can never be
-     * advanced while `_closing` is set). Best-effort: a job that can't be
-     * released (e.g. already completed/stall-retried) is simply dropped from the
-     * local buffer — its server-side lock will expire and requeue it.
-     */
-    private releaseBufferedJobs;
-    private poll;
-    private tryProcess;
-    private registerPulledJobs;
-    private getBufferedJob;
-    /** Put an item back at the front of the pending buffer (Issue #96). */
-    private requeueItem;
-    /**
-     * Get the next buffered job eligible for processing.
-     * When group concurrency is enabled, skips jobs whose group is at capacity
-     * and leaves them in the buffer for later processing.
-     */
-    private getNextEligibleJob;
-    private doPullBatch;
-    private startJob;
-    private handlePullError;
-    /** Register this worker with the server (TCP only, fire-and-forget) */
-    private registerWithServer;
-    /** Start periodic worker-level heartbeat (separate from job heartbeat) */
-    private startWorkerHeartbeat;
-    private getHeartbeatDeps;
-    private getPullConfig;
-    /** Apply worker-level removeOnComplete/removeOnFail defaults to a job */
-    private applyRemoveDefaults;
+/** Public Worker façade. Runtime implementation lives in worker/runtime/. */
+import { WorkerExecution } from './runtime/execution';
+export declare class Worker<T = unknown, R = unknown> extends WorkerExecution<T, R> {
 }