bunqueue-client 0.1.0

package/dist/queue-admin.js

@@ -0,0 +1,143 @@
+/**
+ * Queue admin surface: DLQ, stall/DLQ configs, rate limits, schedulers,
+ * monitoring and webhooks. Merged onto Queue.prototype by queue.ts.
+ */
+import { compact } from './frame.js';
+import { jobPayload, wireJobOptions } from './types.js';
+export const adminMethods = {
+    // ---------------------------------------------------------------------- dlq
+    async getDlq(count) {
+        const response = await this.call(compact({ cmd: 'Dlq', queue: this.name, count }));
+        return (response.jobs ?? response.data ?? []);
+    },
+    async retryDlq(jobId) {
+        const response = await this.call(compact({ cmd: 'RetryDlq', queue: this.name, jobId }));
+        return Number(response.count ?? 0);
+    },
+    async purgeDlq() {
+        const response = await this.call({ cmd: 'PurgeDlq', queue: this.name });
+        return Number(response.count ?? 0);
+    },
+    async setDlqConfig(config) {
+        await this.call({ cmd: 'SetDlqConfig', queue: this.name, config });
+    },
+    async getDlqConfig() {
+        const response = await this.call({ cmd: 'GetDlqConfig', queue: this.name });
+        return (response.config ?? response.data ?? {});
+    },
+    // -------------------------------------------------------------------- stall
+    async setStallConfig(config) {
+        await this.call({ cmd: 'SetStallConfig', queue: this.name, config });
+    },
+    async getStallConfig() {
+        const response = await this.call({ cmd: 'GetStallConfig', queue: this.name });
+        return (response.config ?? response.data ?? {});
+    },
+    // -------------------------------------------------- rate limit / concurrency
+    /** `duration` accepted for signature parity; the TCP wire carries only `limit`. */
+    async setGlobalRateLimit(max, _duration) {
+        await this.call({ cmd: 'RateLimit', queue: this.name, limit: max });
+    },
+    async removeGlobalRateLimit() {
+        await this.call({ cmd: 'RateLimitClear', queue: this.name });
+    },
+    async setGlobalConcurrency(concurrency) {
+        await this.call({ cmd: 'SetConcurrency', queue: this.name, limit: concurrency });
+    },
+    async removeGlobalConcurrency() {
+        await this.call({ cmd: 'ClearConcurrency', queue: this.name });
+    },
+    // ---------------------------------------------------------------- scheduler
+    /** Create/update a recurring job scheduler (cron pattern or fixed interval). */
+    async upsertJobScheduler(schedulerId, repeat, template = {}) {
+        await this.call(compact({
+            cmd: 'Cron',
+            name: schedulerId,
+            queue: this.name,
+            data: jobPayload(template.name ?? schedulerId, template.data ?? {}),
+            schedule: repeat.pattern,
+            repeatEvery: repeat.every,
+            timezone: repeat.tz,
+            immediately: repeat.immediately,
+            maxLimit: repeat.limit,
+            skipMissedOnRestart: repeat.skipMissedOnRestart,
+            skipIfNoWorker: repeat.skipIfNoWorker,
+            preventOverlap: repeat.preventOverlap,
+            jobOptions: template.opts ? wireJobOptions(template.opts) : undefined,
+        }));
+    },
+    async removeJobScheduler(schedulerId) {
+        await this.call({ cmd: 'CronDelete', name: schedulerId });
+    },
+    async getJobScheduler(schedulerId) {
+        try {
+            const response = await this.call({ cmd: 'CronGet', name: schedulerId });
+            return (response.cron ?? response.data ?? null);
+        }
+        catch {
+            return null; // not-found surfaces as a CommandError
+        }
+    },
+    async getJobSchedulers() {
+        const response = await this.call({ cmd: 'CronList' });
+        const crons = (response.crons ?? []);
+        return crons.filter((cron) => cron.queue === this.name);
+    },
+    async getJobSchedulersCount() {
+        return (await this.getJobSchedulers()).length;
+    },
+    /** Helper: run `name` on a cron `schedule`. */
+    addCron(name, schedule, data, opts) {
+        return this.upsertJobScheduler(name, { pattern: schedule }, { name, data, opts });
+    },
+    /** Helper: run `name` every `intervalMs` milliseconds. */
+    every(name, intervalMs, data, opts) {
+        return this.upsertJobScheduler(name, { every: intervalMs }, { name, data, opts });
+    },
+    // --------------------------------------------------------------- monitoring
+    async getWorkers() {
+        const response = await this.call({ cmd: 'ListWorkers' });
+        const data = (response.data ?? {});
+        return (data.workers ?? response.workers ?? []);
+    },
+    async getWorkersCount() {
+        return (await this.getWorkers()).length;
+    },
+    async getStats() {
+        const response = await this.call({ cmd: 'Stats' });
+        return (response.stats ?? {});
+    },
+    async getMetrics() {
+        const response = await this.call({ cmd: 'Metrics' });
+        return (response.metrics ?? {});
+    },
+    /** Server returns queue NAMES (strings). */
+    async listQueues() {
+        const response = await this.call({ cmd: 'ListQueues' });
+        const queues = (response.queues ?? []);
+        return queues.map((q) => (typeof q === 'string' ? q : String(q.name)));
+    },
+    // ----------------------------------------------------------------- webhooks
+    async addWebhook(opts) {
+        const response = await this.call(compact({
+            cmd: 'AddWebhook',
+            url: opts.url,
+            events: opts.events,
+            queue: opts.queue ?? this.name,
+            secret: opts.secret,
+        }));
+        const data = (response.data ?? {});
+        return (data.webhook ?? data);
+    },
+    async removeWebhook(webhookId) {
+        await this.call({ cmd: 'RemoveWebhook', webhookId });
+    },
+    async listWebhooks() {
+        const response = await this.call({ cmd: 'ListWebhooks' });
+        const data = (response.data ?? {});
+        return (data.webhooks ?? response.webhooks ?? []);
+    },
+    async setWebhookEnabled(webhookId, enabled) {
+        await this.call({ cmd: 'SetWebhookEnabled', webhookId, enabled });
+    },
+};

package/dist/queue-control.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Queue control surface: pause/drain/clean, promotion, retry and per-job
+ * mutations. Methods are merged onto Queue.prototype by queue.ts.
+ */
+import type { Queue } from './queue.js';
+import type { JobStateName } from './types.js';
+type Ctx = Queue<unknown>;
+export declare const controlMethods: {
+    pause(this: Ctx): Promise<void>;
+    resume(this: Ctx): Promise<void>;
+    isPaused(this: Ctx): Promise<boolean>;
+    drain(this: Ctx): Promise<void>;
+    obliterate(this: Ctx): Promise<void>;
+    /** Remove old jobs; returns how many were removed. */
+    clean(this: Ctx, graceMs: number, limit?: number, state?: JobStateName): Promise<number>;
+    remove(this: Ctx, id: string): Promise<void>;
+    discard(this: Ctx, id: string): Promise<void>;
+    promoteJob(this: Ctx, id: string): Promise<void>;
+    /** Promote delayed jobs to waiting; returns how many were promoted. */
+    promoteJobs(this: Ctx, opts?: {
+        count?: number;
+    }): Promise<number>;
+    /** BullMQ contract: failed → waiting. */
+    retryJob(this: Ctx, id: string): Promise<void>;
+    retryJobs(this: Ctx, opts?: {
+        state?: "failed" | "completed";
+        count?: number;
+    }): Promise<void>;
+    retryCompleted(this: Ctx, id?: string): Promise<void>;
+    updateJobProgress(this: Ctx, id: string, progress: number, message?: string): Promise<void>;
+    updateJobData(this: Ctx, id: string, data: unknown): Promise<void>;
+    changeJobPriority(this: Ctx, id: string, opts: {
+        priority: number;
+        lifo?: boolean;
+    }): Promise<void>;
+    changeJobDelay(this: Ctx, id: string, delayMs: number): Promise<void>;
+    moveJobToWait(this: Ctx, id: string): Promise<void>;
+    moveJobToDelayed(this: Ctx, id: string, delayMs: number): Promise<void>;
+    extendJobLock(this: Ctx, id: string, token: string, durationMs: number): Promise<void>;
+    moveJobToCompleted(this: Ctx, id: string, returnValue: unknown, token?: string): Promise<void>;
+    moveJobToFailed(this: Ctx, id: string, error: Error | string, token?: string): Promise<void>;
+};
+export type QueueControlApi = typeof controlMethods;
+export {};

package/dist/queue-control.js

@@ -0,0 +1,85 @@
+/**
+ * Queue control surface: pause/drain/clean, promotion, retry and per-job
+ * mutations. Methods are merged onto Queue.prototype by queue.ts.
+ */
+import { compact } from './frame.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() {
+        const response = await this.call({ cmd: 'IsPaused', queue: this.name });
+        return response.paused === true;
+    },
+    async drain() {
+        await this.call({ cmd: 'Drain', queue: this.name });
+    },
+    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 Number(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 Number(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;
+        }
+        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 }));
+    },
+    async moveJobToFailed(id, error, token) {
+        const message = typeof error === 'string' ? error : error.message;
+        await this.call(compact({ cmd: 'FAIL', id, error: message, token }));
+    },
+};

package/dist/queue-query.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Queue query surface: job lookup, state, results, counts, logs, children.
+ * Methods are merged onto Queue.prototype by queue.ts.
+ */
+import { Job } from './job.js';
+import type { Queue } from './queue.js';
+import type { JobCounts } from './types.js';
+type Ctx = Queue<unknown>;
+export declare const queryMethods: {
+    getJob<T = unknown>(this: Ctx, id: string): Promise<Job<T> | null>;
+    getJobByCustomId<T = unknown>(this: Ctx, customId: string): Promise<Job<T> | null>;
+    /** BullMQ v5: resolve the job id registered under a deduplication id. */
+    getDeduplicationJobId(this: Ctx, deduplicationId: string): Promise<string | null>;
+    getJobs<T = unknown>(this: Ctx, opts?: {
+        state?: string | string[];
+        start?: number;
+        end?: number;
+    }): Promise<Job<T>[]>;
+    getWaiting<T = unknown>(this: Ctx, start?: number, end?: number): Promise<Job<T>[]>;
+    getDelayed<T = unknown>(this: Ctx, start?: number, end?: number): Promise<Job<T>[]>;
+    getActive<T = unknown>(this: Ctx, start?: number, end?: number): Promise<Job<T>[]>;
+    getCompleted<T = unknown>(this: Ctx, start?: number, end?: number): Promise<Job<T>[]>;
+    getFailed<T = unknown>(this: Ctx, start?: number, end?: number): Promise<Job<T>[]>;
+    getPrioritized<T = unknown>(this: Ctx, start?: number, end?: number): Promise<Job<T>[]>;
+    getWaitingChildren<T = unknown>(this: Ctx, start?: number, end?: number): Promise<Job<T>[]>;
+    getJobState(this: Ctx, id: string): Promise<string>;
+    getResult<R = unknown>(this: Ctx, id: string): Promise<R>;
+    getChildrenValues<R = unknown>(this: Ctx, id: string): Promise<Record<string, R>>;
+    getFailedChildrenValues(this: Ctx, id: string): Promise<Record<string, string>>;
+    getIgnoredChildrenFailures(this: Ctx, id: string): Promise<Record<string, string>>;
+    /** Detach a child job from its parent's dependency list. */
+    removeChildDependency(this: Ctx, id: string): Promise<void>;
+    /** Remove all still-unprocessed children of a parent job. */
+    removeUnprocessedChildren(this: Ctx, id: string): Promise<void>;
+    /** Block until the job finishes; returns its result. */
+    waitForJob<R = unknown>(this: Ctx, id: string, ttlMs?: number): Promise<R>;
+    /** BullMQ v5 alias for waitForJob (queueEvents param unused over TCP). */
+    waitJobUntilFinished<R = unknown>(this: Ctx, id: string, _queueEvents?: unknown, ttlMs?: number): Promise<R>;
+    getProgress(this: Ctx, id: string): Promise<{
+        progress: number;
+        message: string | null;
+    }>;
+    getJobCounts(this: Ctx): Promise<JobCounts>;
+    getWaitingCount(this: Ctx): Promise<number>;
+    getActiveCount(this: Ctx): Promise<number>;
+    getCompletedCount(this: Ctx): Promise<number>;
+    getFailedCount(this: Ctx): Promise<number>;
+    getDelayedCount(this: Ctx): Promise<number>;
+    getPrioritizedCount(this: Ctx): Promise<number>;
+    getWaitingChildrenCount(this: Ctx): Promise<number>;
+    count(this: Ctx): Promise<number>;
+    getCountsPerPriority(this: Ctx): Promise<Record<string, number>>;
+    addJobLog(this: Ctx, id: string, message: string): Promise<void>;
+    getJobLogs(this: Ctx, id: string, start?: number, end?: number): Promise<string[]>;
+    clearJobLogs(this: Ctx, id: string, keepLogs?: number): Promise<void>;
+};
+export type QueueQueryApi = typeof queryMethods;
+export {};

package/dist/queue-query.js

@@ -0,0 +1,165 @@
+/**
+ * Queue query surface: job lookup, state, results, counts, logs, children.
+ * Methods are merged onto Queue.prototype by queue.ts.
+ */
+import { CommandError } 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 });
+            const raw = response.job;
+            return raw ? new Job(raw, this.connection) : null;
+        }
+        catch (err) {
+            if (err instanceof CommandError)
+                return null; // server: 'Job not found'
+            throw err;
+        }
+    },
+    async getJobByCustomId(customId) {
+        try {
+            const response = await this.call({ cmd: 'GetJobByCustomId', customId });
+            const raw = response.job;
+            return raw ? new Job(raw, this.connection) : null;
+        }
+        catch (err) {
+            if (err instanceof CommandError)
+                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,
+        }));
+        const jobs = (response.jobs ?? []);
+        return jobs.map((raw) => new Job(raw, this.connection));
+    },
+    getWaiting(start, end) {
+        return this.getJobs({ state: ['waiting', 'prioritized'], 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) {
+        const response = await this.call({ cmd: 'GetState', id });
+        return String(response.state);
+    },
+    async getResult(id) {
+        const response = await this.call({ cmd: 'GetResult', id });
+        return response.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 finishes; returns its result. */
+    async waitForJob(id, ttlMs = 30_000) {
+        const response = await this.call({ cmd: 'WaitJob', id, timeout: ttlMs }, ttlMs + 5000);
+        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: Number(response.progress ?? 0),
+            message: response.message ?? null,
+        };
+    },
+    // ------------------------------------------------------------------- counts
+    async getJobCounts() {
+        const response = await this.call({ cmd: 'GetJobCounts', queue: this.name });
+        return response.counts;
+    },
+    async getWaitingCount() {
+        const counts = await this.getJobCounts();
+        return counts.waiting + counts.prioritized;
+    },
+    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() {
+        const response = await this.call({ cmd: 'Count', queue: this.name });
+        return Number(response.count ?? 0);
+    },
+    async getCountsPerPriority() {
+        const response = await this.call({ cmd: 'GetCountsPerPriority', queue: this.name });
+        return (response.counts ?? response.data ?? {});
+    },
+    // --------------------------------------------------------------------- logs
+    async addJobLog(id, message) {
+        await this.call({ cmd: 'AddLog', id, message });
+    },
+    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 ?? []);
+        return logs.map((row) => (typeof row === 'string' ? row : String(row.message ?? row)));
+    },
+    async clearJobLogs(id, keepLogs) {
+        await this.call(compact({ cmd: 'ClearLogs', id, keepLogs }));
+    },
+};

package/dist/queue.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 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, type Response, type TlsOption } from './connection.js';
+import { Job } from './job.js';
+import { type QueueAdminApi } from './queue-admin.js';
+import { type QueueControlApi } from './queue-control.js';
+import { type QueueQueryApi } from './queue-query.js';
+import { type JobOptions } from './types.js';
+export interface QueueOptions {
+    host?: string;
+    port?: number;
+    token?: string;
+    tls?: TlsOption;
+    connection?: Connection;
+    commandTimeoutMs?: number;
+}
+export interface BulkJobEntry<T = unknown> {
+    name: string;
+    data: T;
+    opts?: JobOptions;
+}
+export declare class Queue<T = unknown> {
+    readonly name: string;
+    readonly connection: Connection;
+    private readonly ownsConnection;
+    constructor(name: string, opts?: QueueOptions);
+    /** Send a raw command on this queue's connection (used by area modules). */
+    call(command: Record<string, unknown> & {
+        cmd: string;
+    }, timeoutMs?: number): Promise<Response>;
+    /** Add a job; returns a Job stub carrying the assigned id. */
+    add(name: string, data: T, opts?: JobOptions): Promise<Job<T>>;
+    /** Add many jobs in one round-trip; returns Job stubs. */
+    addBulk(jobs: BulkJobEntry<T>[]): Promise<Job<T>[]>;
+    ping(): Promise<boolean>;
+    waitUntilReady(): Promise<void>;
+    close(): void;
+    /** BullMQ v5 alias for close(). */
+    disconnect(): Promise<void>;
+}
+export interface Queue<T = unknown> extends QueueQueryApi, QueueControlApi, QueueAdminApi {
+}

package/dist/queue.js

@@ -0,0 +1,77 @@
+/**
+ * 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 { 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;
+        this.connection =
+            opts.connection ??
+                new Connection({
+                    host: opts.host,
+                    port: opts.port,
+                    token: opts.token,
+                    tls: opts.tls,
+                    commandTimeoutMs: opts.commandTimeoutMs,
+                });
+        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) => ({
+            data: jobPayload(entry.name, entry.data),
+            ...wireJobOptions(entry.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);