bunqueue-client 0.1.9 → 0.2.1

package/dist/queue-control.js

@@ -1,107 +0,0 @@
-/**
- * Queue control surface: pause/drain/clean, promotion, retry and per-job
- * mutations. Methods are merged onto Queue.prototype by queue.ts.
- */
-import { UnrecoverableError } from './errors.js';
-import { compact } from './frame.js';
-import { MAX_STACK_LINES } from './worker-types.js';
-export const controlMethods = {
-    async pause() {
-        await this.call({ cmd: 'Pause', queue: this.name });
-    },
-    async resume() {
-        await this.call({ cmd: 'Resume', queue: this.name });
-    },
-    async isPaused() {
-        return (await this.call({ cmd: 'IsPaused', queue: this.name })).paused === true;
-    },
-    /** Remove all waiting/delayed jobs; returns how many were dropped. */
-    async drain() {
-        const response = await this.call({ cmd: 'Drain', queue: this.name });
-        return response.count ?? 0;
-    },
-    async obliterate() {
-        await this.call({ cmd: 'Obliterate', queue: this.name });
-    },
-    /** Remove old jobs; returns how many were removed. */
-    async clean(graceMs, limit, state) {
-        const response = await this.call(compact({ cmd: 'Clean', queue: this.name, grace: graceMs, limit, state }));
-        return response.count ?? 0;
-    },
-    async remove(id) {
-        await this.call({ cmd: 'Cancel', id });
-    },
-    async discard(id) {
-        await this.call({ cmd: 'Discard', id });
-    },
-    async promoteJob(id) {
-        await this.call({ cmd: 'Promote', id });
-    },
-    /** Promote delayed jobs to waiting; returns how many were promoted. */
-    async promoteJobs(opts = {}) {
-        const response = await this.call(compact({ cmd: 'PromoteJobs', queue: this.name, count: opts.count }));
-        return response.count ?? 0;
-    },
-    /** BullMQ contract: failed → waiting. */
-    async retryJob(id) {
-        await this.call({ cmd: 'MoveToWait', id });
-    },
-    async retryJobs(opts = {}) {
-        if (opts.state === 'completed') {
-            await this.call({ cmd: 'RetryCompleted', queue: this.name });
-            return;
-        }
-        // `count` caps how many DLQ entries are retried (server >= 2.8.29). Older
-        // servers ignore the field and retry the whole DLQ — forward-compatible.
-        await this.call(compact({ cmd: 'RetryDlq', queue: this.name, count: opts.count }));
-    },
-    async retryCompleted(id) {
-        await this.call(compact({ cmd: 'RetryCompleted', queue: this.name, id }));
-    },
-    // ----------------------------------------------------------- job mutations
-    async updateJobProgress(id, progress, message) {
-        await this.call(compact({ cmd: 'Progress', id, progress, message }));
-    },
-    async updateJobData(id, data) {
-        await this.call({ cmd: 'Update', id, data });
-    },
-    async changeJobPriority(id, opts) {
-        await this.call({ cmd: 'ChangePriority', id, priority: opts.priority, lifo: opts.lifo });
-    },
-    async changeJobDelay(id, delayMs) {
-        await this.call({ cmd: 'ChangeDelay', id, delay: delayMs });
-    },
-    async moveJobToWait(id) {
-        await this.call({ cmd: 'MoveToWait', id });
-    },
-    async moveJobToDelayed(id, delayMs) {
-        await this.call({ cmd: 'MoveToDelayed', id, delay: delayMs });
-    },
-    async extendJobLock(id, token, durationMs) {
-        await this.call({ cmd: 'ExtendLock', id, token, duration: durationMs });
-    },
-    async moveJobToCompleted(id, returnValue, token) {
-        await this.call(compact({ cmd: 'ACK', id, result: returnValue, token }));
-    },
-    /**
-     * Explicit failure path: mirrors the worker's FAIL wire so the stacktrace
-     * and the UnrecoverableError "do not retry" intent are persisted (#111
-     * silent-loss class), not just the message.
-     */
-    async moveJobToFailed(id, error, token) {
-        const err = typeof error === 'string' ? undefined : error;
-        const message = err ? err.message || err.name : error;
-        // Keep the FIRST lines (message + throw site), like the worker path.
-        const stack = err
-            ? (err.stack ?? err.message).split('\n').slice(0, MAX_STACK_LINES)
-            : undefined;
-        await this.call(compact({
-            cmd: 'FAIL',
-            id,
-            error: message,
-            stack,
-            unrecoverable: err instanceof UnrecoverableError ? true : undefined,
-            token,
-        }));
-    },
-};

package/dist/queue-query.js

@@ -1,187 +0,0 @@
-/**
- * Queue query surface: job lookup, state, results, counts, logs, children.
- * Methods are merged onto Queue.prototype by queue.ts.
- */
-import { CommandError, CommandTimeoutError } from './errors.js';
-import { compact } from './frame.js';
-import { Job } from './job.js';
-function unwrapValues(response) {
-    const data = (response.data ?? {});
-    return (data.values ?? response.values ?? data ?? {});
-}
-export const queryMethods = {
-    async getJob(id) {
-        try {
-            const response = await this.call({ cmd: 'GetJob', id });
-            return response.job ? new Job(response.job, this.connection) : null;
-        }
-        catch (err) {
-            // Only the server's 'Job not found' maps to null; connection loss,
-            // timeouts and other server errors must surface.
-            if (err instanceof CommandError && /not found/i.test(err.message))
-                return null;
-            throw err;
-        }
-    },
-    async getJobByCustomId(customId) {
-        try {
-            const response = await this.call({ cmd: 'GetJobByCustomId', customId });
-            return response.job ? new Job(response.job, this.connection) : null;
-        }
-        catch (err) {
-            if (err instanceof CommandError && /not found/i.test(err.message))
-                return null;
-            throw err;
-        }
-    },
-    /** BullMQ v5: resolve the job id registered under a deduplication id. */
-    async getDeduplicationJobId(deduplicationId) {
-        const job = await this.getJobByCustomId(deduplicationId);
-        return job ? job.id : null;
-    },
-    async getJobs(opts = {}) {
-        const start = opts.start ?? 0;
-        const end = opts.end !== undefined && opts.end >= 0 ? opts.end : 1000;
-        const response = await this.call(compact({
-            cmd: 'GetJobs',
-            queue: this.name,
-            state: opts.state,
-            offset: start,
-            limit: end - start,
-        }));
-        return (response.jobs ?? []).map((raw) => new Job(raw, this.connection));
-    },
-    getWaiting(start, end) {
-        // Only the 'waiting' bucket — prioritized jobs live in a separate bucket
-        // (getPrioritized), matching BullMQ and the Python SDK / reference client.
-        return this.getJobs({ state: 'waiting', start, end });
-    },
-    getDelayed(start, end) {
-        return this.getJobs({ state: 'delayed', start, end });
-    },
-    getActive(start, end) {
-        return this.getJobs({ state: 'active', start, end });
-    },
-    getCompleted(start, end) {
-        return this.getJobs({ state: 'completed', start, end });
-    },
-    getFailed(start, end) {
-        return this.getJobs({ state: 'failed', start, end });
-    },
-    getPrioritized(start, end) {
-        return this.getJobs({ state: 'prioritized', start, end });
-    },
-    getWaitingChildren(start, end) {
-        return this.getJobs({ state: 'waiting-children', start, end });
-    },
-    async getJobState(id) {
-        return (await this.call({ cmd: 'GetState', id })).state;
-    },
-    async getResult(id) {
-        return (await this.call({ cmd: 'GetResult', id })).result;
-    },
-    async getChildrenValues(id) {
-        return unwrapValues(await this.call({ cmd: 'GetChildrenValues', id }));
-    },
-    async getFailedChildrenValues(id) {
-        return unwrapValues(await this.call({ cmd: 'GetFailedChildrenValues', id }));
-    },
-    async getIgnoredChildrenFailures(id) {
-        return unwrapValues(await this.call({ cmd: 'GetIgnoredChildrenFailures', id }));
-    },
-    /** Detach a child job from its parent's dependency list. */
-    async removeChildDependency(id) {
-        await this.call({ cmd: 'RemoveChildDependency', id });
-    },
-    /** Remove all still-unprocessed children of a parent job. */
-    async removeUnprocessedChildren(id) {
-        await this.call({ cmd: 'RemoveUnprocessedChildren', id });
-    },
-    /**
-     * Block until the job completes; returns its result.
-     * The server's WaitJob waiter resolves only on completion, replying
-     * `{ok:true, completed:false}` (no result) otherwise — so returning undefined
-     * would be indistinguishable from a genuine undefined result. On
-     * non-completion we probe the state: a `failed` job throws CommandError (it
-     * will not complete), everything else throws CommandTimeoutError.
-     */
-    async waitForJob(id, ttlMs = 30_000) {
-        // The server validates 0 <= timeout <= 600000: clamp instead of erroring.
-        ttlMs = Math.min(Math.max(ttlMs, 0), 600_000);
-        const response = await this.call({ cmd: 'WaitJob', id, timeout: ttlMs }, ttlMs + 5000);
-        if (response.completed !== true) {
-            let state;
-            try {
-                state = await this.getJobState(id);
-            }
-            catch {
-                /* ignore probe failure; fall through to timeout */
-            }
-            if (state === 'failed')
-                throw new CommandError(`job ${id} failed before completion`);
-            throw new CommandTimeoutError(`waitUntilFinished timed out after ${ttlMs}ms`);
-        }
-        return response.result;
-    },
-    /** BullMQ v5 alias for waitForJob (queueEvents param unused over TCP). */
-    waitJobUntilFinished(id, _queueEvents, ttlMs) {
-        return this.waitForJob(id, ttlMs);
-    },
-    async getProgress(id) {
-        const response = await this.call({ cmd: 'GetProgress', id });
-        return { progress: response.progress ?? 0, message: response.message ?? null };
-    },
-    // ------------------------------------------------------------------- counts
-    async getJobCounts() {
-        return (await this.call({ cmd: 'GetJobCounts', queue: this.name })).counts;
-    },
-    async getWaitingCount() {
-        // 'waiting' only — prioritized jobs are counted by getPrioritizedCount,
-        // matching BullMQ and the Python SDK / reference client.
-        return (await this.getJobCounts()).waiting;
-    },
-    async getActiveCount() {
-        return (await this.getJobCounts()).active;
-    },
-    async getCompletedCount() {
-        return (await this.getJobCounts()).completed;
-    },
-    async getFailedCount() {
-        return (await this.getJobCounts()).failed;
-    },
-    async getDelayedCount() {
-        return (await this.getJobCounts()).delayed;
-    },
-    async getPrioritizedCount() {
-        return (await this.getJobCounts()).prioritized;
-    },
-    async getWaitingChildrenCount() {
-        return (await this.getJobCounts())['waiting-children'];
-    },
-    async count() {
-        return (await this.call({ cmd: 'Count', queue: this.name })).count ?? 0;
-    },
-    async getCountsPerPriority() {
-        const response = await this.call({ cmd: 'GetCountsPerPriority', queue: this.name });
-        return (response.counts ?? response.data ?? {});
-    },
-    // --------------------------------------------------------------------- logs
-    async addJobLog(id, message, level) {
-        await this.call(compact({ cmd: 'AddLog', id, message, level }));
-    },
-    async getJobLogs(id, start, end) {
-        const response = await this.call(compact({ cmd: 'GetLogs', id, start, end }));
-        const data = (response.data ?? {});
-        const logs = (data.logs ?? response.logs ?? []);
-        // Format as `[level] message` (reference client parity); never drop level.
-        return logs.map((row) => {
-            if (typeof row === 'string')
-                return row;
-            const r = row;
-            return r.level ? `[${r.level}] ${r.message}` : String(r.message ?? row);
-        });
-    },
-    async clearJobLogs(id, keepLogs) {
-        await this.call(compact({ cmd: 'ClearLogs', id, keepLogs }));
-    },
-};

package/dist/queue.js

@@ -1,92 +0,0 @@
-/**
- * Queue: producer + management API over the bunqueue TCP protocol.
- * Method surface mirrors the official TS client (TCP mode).
- *
- * The class is composed from area modules kept under 250 lines each:
- * queue-query.ts (query/counts/logs), queue-control.ts (state control,
- * job mutations) and queue-admin.ts (DLQ, configs, schedulers, webhooks,
- * monitoring). Methods are merged onto the prototype; declaration merging
- * exposes them on the type.
- */
-import { Connection } from './connection.js';
-import { ConnectionPool } from './connection-pool.js';
-import { Job } from './job.js';
-import { adminMethods } from './queue-admin.js';
-import { controlMethods } from './queue-control.js';
-import { queryMethods } from './queue-query.js';
-import { jobPayload, wireJobOptions } from './types.js';
-// biome-ignore lint/suspicious/noUnsafeDeclarationMerging: prototype-mixin composition — Object.assign at the bottom installs exactly the methods the merged interface declares
-export class Queue {
-    name;
-    connection;
-    ownsConnection;
-    constructor(name, opts = {}) {
-        this.name = name;
-        const connOptions = {
-            host: opts.host,
-            port: opts.port,
-            token: opts.token,
-            tls: opts.tls,
-            commandTimeoutMs: opts.commandTimeoutMs,
-            maxInFlight: opts.maxInFlight,
-            logger: opts.logger,
-            onTelemetry: opts.onTelemetry,
-        };
-        this.connection =
-            opts.connection ??
-                (opts.poolSize && opts.poolSize > 1
-                    ? new ConnectionPool(opts.poolSize, connOptions)
-                    : new Connection(connOptions));
-        this.ownsConnection = opts.connection === undefined;
-    }
-    /** Send a raw command on this queue's connection (used by area modules). */
-    call(command, timeoutMs) {
-        return this.connection.call(command, timeoutMs);
-    }
-    // ------------------------------------------------------------------ produce
-    /** Add a job; returns a Job stub carrying the assigned id. */
-    async add(name, data, opts) {
-        const payload = jobPayload(name, data);
-        const response = await this.call({
-            cmd: 'PUSH',
-            queue: this.name,
-            data: payload,
-            ...wireJobOptions(opts),
-        });
-        return new Job({ id: response.id, queue: this.name, data: payload }, this.connection);
-    }
-    /** Add many jobs in one round-trip; returns Job stubs. */
-    async addBulk(jobs) {
-        const inputs = jobs.map((entry) => {
-            const opts = wireJobOptions(entry.opts);
-            // PUSHB entries are JobInput, whose custom-id field is `customId` —
-            // unlike single PUSH which renames `jobId`->`customId` server-side.
-            // Without this the batch custom id is silently dropped (idempotency /
-            // getJobByCustomId broken).
-            if (opts.jobId !== undefined) {
-                opts.customId = opts.jobId;
-                delete opts.jobId;
-            }
-            return { data: jobPayload(entry.name, entry.data), ...opts };
-        });
-        const response = await this.call({ cmd: 'PUSHB', queue: this.name, jobs: inputs });
-        const ids = (response.ids ?? []);
-        return ids.map((id, i) => new Job({ id, queue: this.name, data: inputs[i].data }, this.connection));
-    }
-    // ---------------------------------------------------------------- lifecycle
-    ping() {
-        return this.connection.ping();
-    }
-    async waitUntilReady() {
-        await this.connection.connect();
-    }
-    close() {
-        if (this.ownsConnection)
-            this.connection.close();
-    }
-    /** BullMQ v5 alias for close(). */
-    async disconnect() {
-        this.close();
-    }
-}
-Object.assign(Queue.prototype, queryMethods, controlMethods, adminMethods);

package/dist/responses.js

@@ -1,10 +0,0 @@
-/**
- * Typed server-response shapes, mirroring the server's response builders
- * (src/domain/types/response.ts). `Connection.call<R>()` and `Queue.call<R>()`
- * are generic over these, so call sites read `response.job` / `response.counts`
- * with real types instead of casting `as Record<string, unknown>`.
- *
- * These narrow the loose transport `Response`; the runtime value is whatever
- * the server sent, so only assert the shape a given command actually returns.
- */
-export {};

package/dist/socket-factory.js

@@ -1,47 +0,0 @@
-/** Socket factory: opens a plain or TLS socket with a connect timeout. */
-import { readFileSync } from 'node:fs';
-import { connect as netConnect } from 'node:net';
-import { connect as tlsConnect } from 'node:tls';
-import { ConnectionClosedError } from './errors.js';
-export function openSocket(host, port, tls, connectTimeoutMs) {
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        const timer = setTimeout(() => {
-            if (settled)
-                return;
-            settled = true;
-            socket.destroy();
-            reject(new ConnectionClosedError(`connect timeout to ${host}:${port}`));
-        }, connectTimeoutMs);
-        const onError = (err) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            reject(new ConnectionClosedError(`connect failed: ${err.message}`));
-        };
-        const onReady = () => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            socket.off('error', onError);
-            resolve(socket);
-        };
-        let socket;
-        if (tls) {
-            const tlsOpts = { host: host, port: port };
-            if (typeof tls === 'object') {
-                if (tls.caFile)
-                    tlsOpts.ca = readFileSync(tls.caFile);
-                if (tls.rejectUnauthorized === false)
-                    tlsOpts.rejectUnauthorized = false;
-            }
-            socket = tlsConnect(tlsOpts, onReady);
-        }
-        else {
-            socket = netConnect({ host: host, port: port }, onReady);
-        }
-        socket.on('error', onError);
-    });
-}

package/dist/types.js

@@ -1,50 +0,0 @@
-/** Shared option types + wire mapping, mirroring the official client. */
-import { compact } from './frame.js';
-/** Map SDK JobOptions to the PUSH/PUSHB wire fields (undefined keys dropped). */
-export function wireJobOptions(opts = {}) {
-    return compact({
-        priority: opts.priority,
-        delay: opts.delay,
-        maxAttempts: opts.attempts,
-        backoff: opts.backoff,
-        ttl: opts.ttl,
-        timeout: opts.timeout,
-        jobId: opts.jobId,
-        uniqueKey: opts.deduplication?.id,
-        dedup: opts.deduplication
-            ? compact({
-                ttl: opts.deduplication.ttl,
-                extend: opts.deduplication.extend,
-                replace: opts.deduplication.replace,
-            })
-            : undefined,
-        dependsOn: opts.dependsOn,
-        parentId: opts.parentId,
-        childrenIds: opts.childrenIds,
-        tags: opts.tags,
-        groupId: opts.groupId,
-        lifo: opts.lifo,
-        removeOnComplete: typeof opts.removeOnComplete === 'boolean' ? opts.removeOnComplete : undefined,
-        removeOnFail: typeof opts.removeOnFail === 'boolean' ? opts.removeOnFail : undefined,
-        stallTimeout: opts.stallTimeout,
-        durable: opts.durable,
-        repeat: opts.repeat,
-        debounceId: opts.debounce?.id,
-        debounceTtl: opts.debounce?.ttl,
-        stackTraceLimit: opts.stackTraceLimit,
-        keepLogs: opts.keepLogs,
-        sizeLimit: opts.sizeLimit,
-        timestamp: opts.timestamp,
-        failParentOnFailure: opts.failParentOnFailure,
-        removeDependencyOnFailure: opts.removeDependencyOnFailure,
-        ignoreDependencyOnFailure: opts.ignoreDependencyOnFailure,
-        continueParentOnFailure: opts.continueParentOnFailure,
-    });
-}
-/** The job name travels inside `data`, mirroring the official client. */
-export function jobPayload(name, data) {
-    if (data && typeof data === 'object' && !Array.isArray(data)) {
-        return { name, ...data };
-    }
-    return data === undefined || data === null ? { name } : { name, payload: data };
-}

package/dist/worker-base.js

@@ -1,159 +0,0 @@
-/**
- * WorkerBase: lifecycle state, cooperative cancellation and safe command
- * dispatch shared by the Worker pull loop (worker.ts).
- */
-import { randomBytes } from 'node:crypto';
-import { EventEmitter } from 'node:events';
-import { hostname } from 'node:os';
-import { Connection } from './connection.js';
-import { MAX_POLL_TIMEOUT_MS, sleep, } from './worker-types.js';
-export class WorkerBase extends EventEmitter {
-    queue;
-    concurrency;
-    batchSize;
-    pollTimeoutMs;
-    lockTtlMs;
-    heartbeatIntervalS;
-    workerId;
-    name;
-    connection;
-    active = new Map(); // job id -> lock token
-    cancelledJobs = new Set();
-    stopped = false;
-    paused = false;
-    closedFlag = false;
-    running = false;
-    wasBusy = false;
-    processed = 0;
-    failedCount = 0;
-    readyPromise;
-    readyResolve = null;
-    readyFired = false;
-    loopPromise = null;
-    heartbeatTimer = null;
-    registeredGeneration = -1;
-    constructor(queue, opts = {}) {
-        super();
-        if ((opts.concurrency ?? 4) < 1)
-            throw new Error('concurrency must be >= 1');
-        this.queue = queue;
-        this.concurrency = opts.concurrency ?? 4;
-        // The server rejects PULLB count > 1000 (handlers/core.ts) — an unclamped
-        // batchSize would wedge the pull loop in a permanent error cycle. The
-        // finite-guard also catches NaN, which would otherwise pass both bounds.
-        const rawBatch = opts.batchSize ?? 10;
-        this.batchSize = Number.isFinite(rawBatch) ? Math.min(Math.max(1, rawBatch), 1000) : 10;
-        this.pollTimeoutMs = Math.min(opts.pollTimeoutMs ?? 5000, MAX_POLL_TIMEOUT_MS);
-        this.lockTtlMs = opts.lockTtlMs ?? 30_000;
-        this.heartbeatIntervalS = opts.heartbeatIntervalS ?? 10;
-        this.workerId = `ts-${hostname()}-${process.pid}-${randomBytes(4).toString('hex')}`;
-        this.name = opts.name ?? this.workerId;
-        this.connection = new Connection({
-            host: opts.host,
-            port: opts.port,
-            token: opts.token,
-            tls: opts.tls,
-            logger: opts.logger,
-            onTelemetry: opts.onTelemetry,
-        });
-        this.readyPromise = new Promise((resolve) => {
-            this.readyResolve = resolve;
-        });
-    }
-    pause() {
-        this.paused = true;
-    }
-    resume() {
-        this.paused = false;
-    }
-    isRunning() {
-        return this.running && !this.closedFlag;
-    }
-    isPaused() {
-        return this.paused;
-    }
-    isClosed() {
-        return this.closedFlag;
-    }
-    async waitUntilReady() {
-        await this.readyPromise;
-    }
-    on(event, listener) {
-        if (event === 'ready' && this.readyFired)
-            listener();
-        return super.on(event, listener);
-    }
-    once(event, listener) {
-        if (event === 'ready' && this.readyFired) {
-            listener();
-            return this;
-        }
-        return super.once(event, listener);
-    }
-    off(event, listener) {
-        return super.off(event, listener);
-    }
-    /**
-     * Cooperative cancel of a locally active job (mirrors the official client):
-     * marks the job and emits 'cancelled'; the processor is expected to check
-     * isJobCancelled() and abort. Returns false if the job is not active here.
-     */
-    cancelJob(jobId, reason) {
-        if (this.active.has(jobId)) {
-            this.cancelledJobs.add(jobId);
-            this.emit('cancelled', { jobId, reason: reason ?? 'Job cancelled by worker' });
-            return true;
-        }
-        return false;
-    }
-    cancelAllJobs(reason) {
-        for (const jobId of this.active.keys()) {
-            this.cancelledJobs.add(jobId);
-            this.emit('cancelled', { jobId, reason: reason ?? 'All jobs cancelled' });
-        }
-    }
-    isJobCancelled(jobId) {
-        return this.cancelledJobs.has(jobId);
-    }
-    /** Graceful shutdown: stop pulling, wait for in-flight jobs.
-     * With `force` the wait for in-flight jobs is skipped (parity with the
-     * official client's `close(force)`). */
-    async close(force = false) {
-        if (this.closedFlag)
-            return;
-        this.stopped = true;
-        if (this.loopPromise)
-            await this.loopPromise;
-        await this.beforeClose(); // flush any batched ACKs before draining
-        while (!force && this.active.size > 0)
-            await sleep(20);
-        if (this.heartbeatTimer) {
-            clearInterval(this.heartbeatTimer);
-            this.heartbeatTimer = null;
-        }
-        // Only unregister when the loop actually registered (autorun: false and
-        // never run() means the server does not know this worker).
-        if (this.registeredGeneration >= 0) {
-            await this.safeCall({ cmd: 'UnregisterWorker', workerId: this.workerId });
-        }
-        this.connection.close();
-        this.closedFlag = true;
-        this.running = false;
-        this.emit('closed');
-    }
-    /** Dispatch a command, routing failures to 'error'. Returns whether the
-     * command reached the server — callers gate success-only side effects
-     * ('completed'/'failed' emits, counters) on it. */
-    async safeCall(command) {
-        try {
-            await this.connection.call(command);
-            return true;
-        }
-        catch (err) {
-            this.emit('error', err instanceof Error ? err : new Error(String(err)));
-            return false;
-        }
-    }
-    /** Hook run during close() before draining in-flight jobs (see Worker). */
-    async beforeClose() { }
-}

package/dist/worker-types.js

@@ -1,5 +0,0 @@
-/** Worker option types and shared constants. */
-export const MAX_POLL_TIMEOUT_MS = 30_000;
-export const MAX_STACK_LINES = 20;
-export const RECONNECT_BACKOFF_MS = [500, 1000, 2000, 5000];
-export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));