bunqueue 2.8.53 → 2.8.56

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

@@ -4,6 +4,7 @@
  */
 import { getSharedManager } from '../../manager';
 import { jobId } from '../../../domain/types/job';
+import { assertFlowTcpOk } from '../../flowJobTypes';
 // ============ Remove Operations ============
 /** Remove a job (sync, fire-and-forget; use removeAsync to await the removal) */
 export function remove(ctx, id) {
@@ -54,15 +55,43 @@ export async function retryJob(ctx, id) {
 }
 /** Retry jobs matching criteria */
 export async function retryJobs(ctx, opts) {
+    const state = opts?.state ?? 'failed';
     if (ctx.embedded) {
-        if (opts?.state === 'failed') {
-            // #111-class: forward the count cap (was ignored → retried the whole DLQ).
-            getSharedManager().retryDlq(ctx.name, undefined, opts?.count);
+        const manager = getSharedManager();
+        if (state === 'completed') {
+            manager.retryCompleted(ctx.name, undefined, {
+                limit: opts?.count,
+                timestamp: opts?.timestamp,
+            });
+        }
+        else if (opts?.timestamp !== undefined) {
+            manager.retryDlqByFilter(ctx.name, {
+                olderThan: opts.timestamp,
+                limit: opts.count,
+            });
+        }
+        else {
+            manager.retryDlq(ctx.name, undefined, opts?.count);
         }
         return;
     }
-    if (opts?.state === 'failed') {
-        await ctx.tcp.send({ cmd: 'RetryDlq', queue: ctx.name, count: opts?.count });
+    if (state === 'completed') {
+        await ctx.tcp.send({
+            cmd: 'RetryCompleted',
+            queue: ctx.name,
+            count: opts?.count,
+            timestamp: opts?.timestamp,
+        });
+    }
+    else {
+        await ctx.tcp.send({
+            cmd: 'RetryDlq',
+            queue: ctx.name,
+            count: opts?.count,
+            filter: opts?.timestamp === undefined
+                ? undefined
+                : { olderThan: opts.timestamp, limit: opts.count },
+        });
     }
 }
 // ============ Clean Operations ============
@@ -165,7 +194,7 @@ export async function updateJobData(ctx, id, data) {
         await getSharedManager().updateJobData(jobId(id), data);
         return;
     }
-    await ctx.tcp.send({ cmd: 'Update', id, data });
+    assertFlowTcpOk(await ctx.tcp.send({ cmd: 'Update', id, data }), 'Update');
 }
 /** Change job delay */
 export async function changeJobDelay(ctx, id, delay) {

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

@@ -1,10 +1,6 @@
-/**
- * Queue Query Operations
- * getJob, getJobs, getJobState, getJobsAsync
- */
 import type { TcpConnectionPool } from '../../tcpPool';
 import type { Job, JobStateType, GetDependenciesOpts, JobDependencies, JobDependenciesCount } from '../../types';
-interface QueryContext {
+export interface QueryContext {
     name: string;
     embedded: boolean;
     tcp: TcpConnectionPool | null;
@@ -51,19 +47,4 @@ interface GetJobsOptions {
 export declare function getJobs<T>(ctx: QueryContext, options?: GetJobsOptions): Job<T>[];
 /** Get jobs with filtering (async, works with TCP) */
 export declare function getJobsAsync<T>(ctx: QueryContext, options?: GetJobsOptions): Promise<Job<T>[]>;
-/** Get waiting jobs */
-export declare function getWaiting<T>(ctx: QueryContext, start?: number, end?: number): Job<T>[];
-export declare function getWaitingAsync<T>(ctx: QueryContext, start?: number, end?: number): Promise<Job<T>[]>;
-/** Get delayed jobs */
-export declare function getDelayed<T>(ctx: QueryContext, start?: number, end?: number): Job<T>[];
-export declare function getDelayedAsync<T>(ctx: QueryContext, start?: number, end?: number): Promise<Job<T>[]>;
-/** Get active jobs */
-export declare function getActive<T>(ctx: QueryContext, start?: number, end?: number): Job<T>[];
-export declare function getActiveAsync<T>(ctx: QueryContext, start?: number, end?: number): Promise<Job<T>[]>;
-/** Get completed jobs */
-export declare function getCompleted<T>(ctx: QueryContext, start?: number, end?: number): Job<T>[];
-export declare function getCompletedAsync<T>(ctx: QueryContext, start?: number, end?: number): Promise<Job<T>[]>;
-/** Get failed jobs */
-export declare function getFailed<T>(ctx: QueryContext, start?: number, end?: number): Job<T>[];
-export declare function getFailedAsync<T>(ctx: QueryContext, start?: number, end?: number): Promise<Job<T>[]>;
 export {};

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

@@ -1,49 +1,33 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion, @typescript-eslint/no-unnecessary-condition, @typescript-eslint/switch-exhaustiveness-check */
-/**
- * Queue Query Operations
- * getJob, getJobs, getJobState, getJobsAsync
- */
 import { getSharedManager } from '../../manager';
 import { toPublicJob } from '../../types';
 import { jobId } from '../../../domain/types/job';
 import { createSimpleJob } from '../jobProxy';
-import { buildJobOpts } from '../../jobHelpers';
-/** Last failure's error message from the job timeline (#74) */
-function lastFailedError(timeline) {
-    if (!timeline)
-        return undefined;
-    for (let i = timeline.length - 1; i >= 0; i--) {
-        const entry = timeline[i];
-        if (entry.state === 'failed' && entry.error)
-            return entry.error;
-    }
-    return undefined;
-}
-/** Build reflection meta (priority/delay/opts/stacktrace) from an internal job shape */
-function metaFromJob(job) {
-    const opts = buildJobOpts(job);
-    return {
-        priority: job.priority ?? 0,
-        delay: opts.delay ?? 0,
-        opts,
-        // Persisted server-side on FAIL (#74); absent on pre-#74 servers
-        stacktrace: job.stacktrace ?? null,
-        failedReason: lastFailedError(job.timeline),
-    };
-}
+import { resolvePublicJobPayload } from '../../jobHelpers';
+import { removeJobDeduplicationKey } from '../../jobDeduplication';
+import { fetchTcpJobRows } from './queryTcpPages';
+import { metadataFromJob } from '../jobMetadata';
 /** Get a single job by ID */
 export async function getJob(ctx, id) {
     if (ctx.embedded) {
-        const job = await getSharedManager().getJob(jobId(id));
+        const manager = getSharedManager();
+        const job = await manager.getJob(jobId(id));
         if (!job)
             return null;
-        const name = job.data?.name ?? 'unknown';
+        const { name, data } = resolvePublicJobPayload(job);
+        const meta = metadataFromJob(job, manager.getResult(job.id));
         // Use toPublicJob with full wiring (all callbacks route to the shared manager)
         if (ctx.updateJobData) {
-            const mgr = getSharedManager();
+            const mgr = manager;
             return toPublicJob({
                 job,
                 name,
+                returnvalue: meta.returnvalue,
+                failedReason: meta.failedReason,
+                updateProgress: async (jid, progress, message) => {
+                    await mgr.updateProgress(jobId(jid), progress, message);
+                },
+                log: (jid, message) => Promise.resolve(void mgr.addLog(jobId(jid), message)),
                 getState: (jid) => ctx.getJobState(jid),
                 remove: (jid) => ctx.removeAsync(jid),
                 retry: (jid) => ctx.retryJob(jid),
@@ -72,13 +56,14 @@ export async function getJob(ctx, id) {
                 getFailedChildrenValues: (jid) => mgr.getFailedChildrenValues(jobId(jid)),
                 getIgnoredChildrenFailures: (jid) => mgr.getIgnoredChildrenFailures(jobId(jid)),
                 removeChildDependency: (jid) => mgr.removeChildDependency(jobId(jid)),
+                removeDeduplicationKey: (jid) => removeJobDeduplicationKey(jid, true, null),
                 removeUnprocessedChildren: async (jid) => {
                     await mgr.removeUnprocessedChildren(jobId(jid));
                 },
             });
         }
         // Fallback to simple job — reflect priority/delay/opts from the real job (#88)
-        return createSimpleJob(String(job.id), name, job.data, job.createdAt, {
+        return createSimpleJob(String(job.id), name, data, job.createdAt, {
             queueName: ctx.name,
             embedded: ctx.embedded,
             tcp: ctx.tcp,
@@ -86,15 +71,15 @@ export async function getJob(ctx, id) {
             removeAsync: ctx.removeAsync,
             retryJob: ctx.retryJob,
             getChildrenValues: ctx.getChildrenValues,
-            meta: metaFromJob(job),
+            meta,
         });
     }
     const response = await ctx.tcp.send({ cmd: 'GetJob', id });
     if (!response.ok || !response.job)
         return null;
     const j = response.job;
-    const name = j.data?.name ?? 'unknown';
-    const result = createSimpleJob(String(j.id), name, j.data, j.createdAt ?? Date.now(), {
+    const { name, data } = resolvePublicJobPayload(j);
+    return createSimpleJob(String(j.id), name, data, j.createdAt ?? Date.now(), {
         queueName: ctx.name,
         embedded: ctx.embedded,
         tcp: ctx.tcp,
@@ -102,16 +87,8 @@ export async function getJob(ctx, id) {
         removeAsync: ctx.removeAsync,
         retryJob: ctx.retryJob,
         getChildrenValues: ctx.getChildrenValues,
-        meta: metaFromJob(j),
+        meta: metadataFromJob(j),
     });
-    if (j.progress !== undefined)
-        result.progress = j.progress;
-    // Mirror getJob/buildJobProperties: a number maps through, null → undefined (#104)
-    if (typeof j.startedAt === 'number')
-        result.processedOn = j.startedAt;
-    if (typeof j.completedAt === 'number')
-        result.finishedOn = j.completedAt;
-    return result;
 }
 /** Get job state by ID */
 export async function getJobState(ctx, id) {
@@ -161,11 +138,16 @@ export function getJobs(ctx, options = {}) {
     const jobs = manager.getJobs(ctx.name, {
         state: options.state,
         start: options.start ?? 0,
-        end: options.end !== undefined && options.end >= 0 ? options.end : 100,
+        asc: options.asc,
+        end: options.end === -1
+            ? Number.MAX_SAFE_INTEGER
+            : options.end !== undefined && options.end >= 0
+                ? options.end
+                : 100,
     });
     return jobs.map((j) => {
-        const name = j.data?.name ?? 'unknown';
-        const result = createSimpleJob(String(j.id), name, j.data, j.createdAt, {
+        const { name, data } = resolvePublicJobPayload(j);
+        return createSimpleJob(String(j.id), name, data, j.createdAt, {
             queueName: ctx.name,
             embedded: ctx.embedded,
             tcp: ctx.tcp,
@@ -173,40 +155,27 @@ export function getJobs(ctx, options = {}) {
             removeAsync: ctx.removeAsync,
             retryJob: ctx.retryJob,
             getChildrenValues: ctx.getChildrenValues,
+            meta: metadataFromJob(j, manager.getResult(j.id)),
         });
-        // Mirror getJob/buildJobProperties: a number maps through, null → undefined (#104)
-        if (typeof j.startedAt === 'number')
-            result.processedOn = j.startedAt;
-        if (typeof j.completedAt === 'number')
-            result.finishedOn = j.completedAt;
-        return result;
     });
 }
 /** Get jobs with filtering (async, works with TCP) */
 export async function getJobsAsync(ctx, options = {}) {
     if (ctx.embedded)
         return getJobs(ctx, options);
-    // Handle end=-1 as "get all"
-    const end = options.end !== undefined && options.end >= 0 ? options.end : 1000;
-    const start = options.start ?? 0;
-    const response = await ctx.tcp.send({
-        cmd: 'GetJobs',
-        queue: ctx.name,
-        state: options.state,
-        offset: start,
-        limit: end - start,
-    });
-    if (!response.ok || !Array.isArray(response.jobs)) {
+    if (!ctx.tcp)
+        return [];
+    const rows = await fetchTcpJobRows({ name: ctx.name, tcp: ctx.tcp }, options);
+    if (!rows)
         return [];
-    }
     // handleGetJobs returns the full internal job per element ({ ...job, state }),
     // so reflect the complete opts via metaFromJob instead of a slim subset (#90).
-    const jobs = response.jobs;
+    const jobs = rows;
     const now = Date.now();
     return jobs.map((j) => {
-        const name = j.data?.name ?? 'unknown';
+        const { name, data } = resolvePublicJobPayload(j);
         const createdAt = j.createdAt ?? now;
-        const result = createSimpleJob(String(j.id), name, j.data, createdAt, {
+        return createSimpleJob(String(j.id), name, data, createdAt, {
             queueName: ctx.name,
             embedded: ctx.embedded,
             tcp: ctx.tcp,
@@ -214,54 +183,7 @@ export async function getJobsAsync(ctx, options = {}) {
             removeAsync: ctx.removeAsync,
             retryJob: ctx.retryJob,
             getChildrenValues: ctx.getChildrenValues,
-            meta: metaFromJob(j),
+            meta: metadataFromJob(j),
         });
-        if (j.progress !== undefined)
-            result.progress = j.progress;
-        if (j.priority !== undefined)
-            result.priority = j.priority;
-        if (j.attempts !== undefined)
-            result.attemptsMade = j.attempts;
-        // Mirror getJob/buildJobProperties: a number maps through, null → undefined (#104)
-        if (typeof j.startedAt === 'number')
-            result.processedOn = j.startedAt;
-        if (typeof j.completedAt === 'number')
-            result.finishedOn = j.completedAt;
-        return result;
     });
 }
-/** Get waiting jobs */
-export function getWaiting(ctx, start = 0, end = 100) {
-    return getJobs(ctx, { state: 'waiting', start, end });
-}
-export async function getWaitingAsync(ctx, start = 0, end = 100) {
-    return getJobsAsync(ctx, { state: 'waiting', start, end });
-}
-/** Get delayed jobs */
-export function getDelayed(ctx, start = 0, end = 100) {
-    return getJobs(ctx, { state: 'delayed', start, end });
-}
-export async function getDelayedAsync(ctx, start = 0, end = 100) {
-    return getJobsAsync(ctx, { state: 'delayed', start, end });
-}
-/** Get active jobs */
-export function getActive(ctx, start = 0, end = 100) {
-    return getJobs(ctx, { state: 'active', start, end });
-}
-export async function getActiveAsync(ctx, start = 0, end = 100) {
-    return getJobsAsync(ctx, { state: 'active', start, end });
-}
-/** Get completed jobs */
-export function getCompleted(ctx, start = 0, end = 100) {
-    return getJobs(ctx, { state: 'completed', start, end });
-}
-export async function getCompletedAsync(ctx, start = 0, end = 100) {
-    return getJobsAsync(ctx, { state: 'completed', start, end });
-}
-/** Get failed jobs */
-export function getFailed(ctx, start = 0, end = 100) {
-    return getJobs(ctx, { state: 'failed', start, end });
-}
-export async function getFailedAsync(ctx, start = 0, end = 100) {
-    return getJobsAsync(ctx, { state: 'failed', start, end });
-}

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

@@ -0,0 +1,13 @@
+/** State-specific aliases over the generic queue query operations. */
+import type { Job } from '../../types';
+import { type QueryContext } from './query';
+export declare function getWaiting<T>(ctx: QueryContext, start?: number, end?: number): Job<T>[];
+export declare function getWaitingAsync<T>(ctx: QueryContext, start?: number, end?: number): Promise<Job<T>[]>;
+export declare function getDelayed<T>(ctx: QueryContext, start?: number, end?: number): Job<T>[];
+export declare function getDelayedAsync<T>(ctx: QueryContext, start?: number, end?: number): Promise<Job<T>[]>;
+export declare function getActive<T>(ctx: QueryContext, start?: number, end?: number): Job<T>[];
+export declare function getActiveAsync<T>(ctx: QueryContext, start?: number, end?: number): Promise<Job<T>[]>;
+export declare function getCompleted<T>(ctx: QueryContext, start?: number, end?: number): Job<T>[];
+export declare function getCompletedAsync<T>(ctx: QueryContext, start?: number, end?: number): Promise<Job<T>[]>;
+export declare function getFailed<T>(ctx: QueryContext, start?: number, end?: number): Job<T>[];
+export declare function getFailedAsync<T>(ctx: QueryContext, start?: number, end?: number): Promise<Job<T>[]>;

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

@@ -0,0 +1,32 @@
+/** State-specific aliases over the generic queue query operations. */
+import { getJobs, getJobsAsync } from './query';
+export function getWaiting(ctx, start = 0, end = 100) {
+    return getJobs(ctx, { state: 'waiting', start, end });
+}
+export function getWaitingAsync(ctx, start = 0, end = 100) {
+    return getJobsAsync(ctx, { state: 'waiting', start, end });
+}
+export function getDelayed(ctx, start = 0, end = 100) {
+    return getJobs(ctx, { state: 'delayed', start, end });
+}
+export function getDelayedAsync(ctx, start = 0, end = 100) {
+    return getJobsAsync(ctx, { state: 'delayed', start, end });
+}
+export function getActive(ctx, start = 0, end = 100) {
+    return getJobs(ctx, { state: 'active', start, end });
+}
+export function getActiveAsync(ctx, start = 0, end = 100) {
+    return getJobsAsync(ctx, { state: 'active', start, end });
+}
+export function getCompleted(ctx, start = 0, end = 100) {
+    return getJobs(ctx, { state: 'completed', start, end });
+}
+export function getCompletedAsync(ctx, start = 0, end = 100) {
+    return getJobsAsync(ctx, { state: 'completed', start, end });
+}
+export function getFailed(ctx, start = 0, end = 100) {
+    return getJobs(ctx, { state: 'failed', start, end });
+}
+export function getFailedAsync(ctx, start = 0, end = 100) {
+    return getJobsAsync(ctx, { state: 'failed', start, end });
+}

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

@@ -0,0 +1,14 @@
+import type { TcpConnectionPool } from '../../tcpPool';
+interface TcpQueryContext {
+    name: string;
+    tcp: TcpConnectionPool;
+}
+export interface TcpJobQueryOptions {
+    state?: string | string[];
+    start?: number;
+    end?: number;
+    asc?: boolean;
+}
+/** Read a finite range once, or page until exhaustion when `end` is -1. */
+export declare function fetchTcpJobRows(ctx: TcpQueryContext, options: TcpJobQueryOptions): Promise<Record<string, unknown>[] | null>;
+export {};

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

@@ -0,0 +1,40 @@
+const QUERY_PAGE_SIZE = 1000;
+async function fetchPage(ctx, options, offset, limit) {
+    const response = await ctx.tcp.send({
+        cmd: 'GetJobs',
+        queue: ctx.name,
+        state: options.state,
+        offset,
+        limit,
+        asc: options.asc,
+    });
+    if (!response.ok || !Array.isArray(response.jobs))
+        return null;
+    return response.jobs;
+}
+/** Read a finite range once, or page until exhaustion when `end` is -1. */
+export async function fetchTcpJobRows(ctx, options) {
+    const start = options.start ?? 0;
+    if (options.end !== -1) {
+        const end = options.end !== undefined && options.end >= 0 ? options.end : 1000;
+        return fetchPage(ctx, options, start, end - start);
+    }
+    const rows = [];
+    const seen = new Set();
+    let offset = start;
+    while (true) {
+        const page = await fetchPage(ctx, options, offset, QUERY_PAGE_SIZE);
+        if (!page)
+            return null;
+        for (const row of page) {
+            const id = String(row.id);
+            if (!seen.has(id)) {
+                seen.add(id);
+                rows.push(row);
+            }
+        }
+        if (page.length < QUERY_PAGE_SIZE)
+            return rows;
+        offset += page.length;
+    }
+}

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

@@ -1,195 +1,12 @@
-/**
- * Queue
- * BullMQ-style queue for job management
- */
-import type { Job, JobOptions, QueueOptions, StallConfig, DlqConfig, DlqEntry, DlqStats, DlqFilter, ChangePriorityOpts, GetDependenciesOpts, JobDependencies, JobDependenciesCount, JobStateType } from '../types';
+/** BullMQ-style queue for job management. */
 import { Forwarder, type ForwardOptions } from '../forwarder';
-import * as countsOps from './operations/counts';
-import * as schedulerOps from './scheduler';
-import type { RepeatOpts, JobTemplate, SchedulerInfo } from './scheduler';
-import * as workersOps from './workers';
-/**
- * Queue class for adding and managing jobs
- */
-export declare class Queue<T = unknown> {
-    readonly name: string;
-    /**
-     * Server-side queue key. Equals `name` unless `prefixKey` is set, in which
-     * case it is `prefixKey + name`. All TCP/embedded operations route through
-     * this key so that two queues with the same logical name but different
-     * `prefixKey` values are fully isolated on the broker.
-     */
-    private readonly queueKey;
-    private readonly prefixKey;
-    private readonly opts;
-    private readonly embedded;
-    private readonly tcpPool;
-    private readonly useSharedPool;
-    private readonly addBatcher;
-    constructor(name: string, opts?: QueueOptions);
-    private get ctx();
-    private get addCtx();
-    private get queryCtx();
-    private get moveCtx();
-    add(name: string, data: T, opts?: JobOptions): Promise<Job<T>>;
-    addBulk(jobs: Array<{
-        name: string;
-        data: T;
-        opts?: JobOptions;
-    }>): Promise<Job<T>[]>;
-    getJob(id: string): Promise<Job<T> | null>;
-    getJobState(id: string): Promise<JobStateType>;
-    getChildrenValues(id: string): Promise<Record<string, unknown>>;
-    getJobs(opts?: {
-        state?: string | string[];
-        start?: number;
-        end?: number;
-        asc?: boolean;
-    }): Job<T>[];
-    getJobsAsync(opts?: {
-        state?: string | string[];
-        start?: number;
-        end?: number;
-        asc?: boolean;
-    }): Promise<Job<unknown>[]>;
-    getWaiting(start?: number, end?: number): Job<T>[];
-    getWaitingAsync(start?: number, end?: number): Promise<Job<T>[]>;
-    getDelayed(start?: number, end?: number): Job<T>[];
-    getDelayedAsync(start?: number, end?: number): Promise<Job<T>[]>;
-    getActive(start?: number, end?: number): Job<T>[];
-    getActiveAsync(start?: number, end?: number): Promise<Job<T>[]>;
-    getCompleted(start?: number, end?: number): Job<T>[];
-    getCompletedAsync(start?: number, end?: number): Promise<Job<T>[]>;
-    getFailed(start?: number, end?: number): Job<T>[];
-    getFailedAsync(start?: number, end?: number): Promise<Job<T>[]>;
-    getJobCounts(): countsOps.JobCounts | Promise<countsOps.JobCounts>;
-    getJobCountsAsync(): Promise<countsOps.JobCounts>;
-    getWaitingCount(): Promise<number>;
-    getActiveCount(): Promise<number>;
-    getCompletedCount(): Promise<number>;
-    getFailedCount(): Promise<number>;
-    getDelayedCount(): Promise<number>;
-    count(): number;
-    countAsync(): Promise<number>;
-    getCountsPerPriority(): Record<number, number>;
-    getCountsPerPriorityAsync(): Promise<Record<number, number>>;
-    pause(): void;
-    pauseAsync(): Promise<void>;
-    resume(): void;
-    resumeAsync(): Promise<void>;
-    drain(): void;
-    drainAsync(): Promise<number>;
-    obliterate(): void;
-    obliterateAsync(): Promise<void>;
-    isPaused(): boolean;
-    isPausedAsync(): Promise<boolean>;
-    waitUntilReady(): Promise<void>;
-    remove(id: string): void;
-    removeAsync(id: string): Promise<void>;
-    retryJob(id: string): Promise<void>;
-    retryJobs(opts?: {
-        state?: 'failed' | 'completed';
-        count?: number;
-        timestamp?: number;
-    }): Promise<void>;
-    clean(grace: number, limit: number, type?: string): string[];
-    cleanAsync(grace: number, limit: number, type?: string): Promise<string[]>;
-    promoteJobs(opts?: {
-        count?: number;
-    }): Promise<number>;
-    promoteJob(id: string): Promise<void>;
-    updateJobProgress(id: string, progress: number | object): Promise<void>;
-    getJobLogs(id: string, start?: number, end?: number, _asc?: boolean): Promise<{
-        logs: string[];
-        count: number;
-    }>;
-    addJobLog(id: string, logRow: string, _keepLogs?: number): Promise<number>;
-    clearJobLogs(id: string, keepLogs?: number): Promise<void>;
-    updateJobData(id: string, data: unknown): Promise<void>;
-    changeJobDelay(id: string, delay: number): Promise<void>;
-    changeJobPriority(id: string, opts: ChangePriorityOpts): Promise<void>;
-    extendJobLock(id: string, token: string, duration: number): Promise<number>;
-    setStallConfig(config: Partial<StallConfig>): void;
-    setStallConfigAsync(config: Partial<StallConfig>): Promise<void>;
-    getStallConfig(): StallConfig;
-    getStallConfigAsync(): Promise<StallConfig>;
-    setDlqConfig(config: Partial<DlqConfig>): void;
-    setDlqConfigAsync(config: Partial<DlqConfig>): Promise<void>;
-    getDlqConfig(): DlqConfig;
-    getDlqConfigAsync(): Promise<DlqConfig>;
-    getDlq(filter?: DlqFilter): DlqEntry<T>[];
-    getDlqJobsAsync(count?: number): Promise<Job<T>[]>;
-    getDlqStats(): DlqStats;
-    retryDlq(id?: string): number;
-    retryDlqAsync(id?: string): Promise<number>;
-    retryDlqByFilter(filter: DlqFilter): number;
-    purgeDlq(): number;
-    purgeDlqAsync(): Promise<number>;
-    retryCompleted(id?: string): number;
-    retryCompletedAsync(id?: string): Promise<number>;
-    setGlobalConcurrency(concurrency: number): void;
-    setGlobalConcurrencyAsync(concurrency: number): Promise<void>;
-    removeGlobalConcurrency(): void;
-    removeGlobalConcurrencyAsync(): Promise<void>;
-    getGlobalConcurrency(): Promise<number | null>;
-    setGlobalRateLimit(max: number, duration?: number): void;
-    setGlobalRateLimitAsync(max: number, duration?: number): Promise<void>;
-    removeGlobalRateLimit(): void;
-    removeGlobalRateLimitAsync(): Promise<void>;
-    getGlobalRateLimit(): Promise<{
-        max: number;
-        duration: number;
-    } | null>;
-    rateLimit(expireTimeMs: number): Promise<void>;
-    getRateLimitTtl(maxJobs?: number): Promise<number>;
-    isMaxed(): Promise<boolean>;
-    upsertJobScheduler(schedulerId: string, repeatOpts: RepeatOpts, jobTemplate?: JobTemplate<T>): Promise<SchedulerInfo | null>;
-    removeJobScheduler(schedulerId: string): Promise<boolean>;
-    getJobScheduler(schedulerId: string): Promise<schedulerOps.SchedulerInfo | null>;
-    getJobSchedulers(start?: number, end?: number, asc?: boolean): Promise<schedulerOps.SchedulerInfo[]>;
-    getJobSchedulersCount(): Promise<number>;
-    getDeduplicationJobId(deduplicationId: string): Promise<string | null>;
-    removeDeduplicationKey(deduplicationId: string): Promise<number>;
-    moveJobToCompleted(id: string, returnValue: unknown, token?: string): Promise<unknown>;
-    moveJobToFailed(id: string, error: Error, token?: string): Promise<void>;
-    moveJobToWait(id: string, token?: string): Promise<boolean>;
-    moveJobToDelayed(id: string, timestamp: number, token?: string): Promise<void>;
-    moveJobToWaitingChildren(id: string, token?: string, opts?: {
-        child?: {
-            id: string;
-            queue: string;
-        };
-    }): Promise<boolean>;
-    waitJobUntilFinished(id: string, queueEvents: unknown, ttl?: number): Promise<unknown>;
-    getJobDependencies(id: string, opts?: GetDependenciesOpts): Promise<JobDependencies>;
-    getJobDependenciesCount(id: string, opts?: GetDependenciesOpts): Promise<JobDependenciesCount>;
-    getDependencies(parentId: string, type?: 'processed' | 'unprocessed', start?: number, end?: number): Promise<{
-        processed?: Record<string, unknown>;
-        unprocessed?: string[];
-        nextProcessedCursor?: number;
-        nextUnprocessedCursor?: number;
-    }>;
-    getPrioritized(start?: number, end?: number): Promise<Job<T>[]>;
-    getPrioritizedCount(): Promise<number>;
-    getWaitingChildren(start?: number, end?: number): Promise<Job<T>[]>;
-    getWaitingChildrenCount(): Promise<number>;
-    trimEvents(maxLength: number): Promise<number>;
-    getWorkers(): Promise<workersOps.WorkerInfo[]>;
-    getWorkersCount(): Promise<number>;
-    getMetrics(type: 'completed' | 'failed', start?: number, end?: number): Promise<{
-        meta: {
-            count: number;
-        };
-        data: number[];
-    }>;
+import { QueueConnection } from './runtime/connection';
+/** Public Queue façade; behavior is implemented by focused runtime layers. */
+export declare class Queue<T = unknown> extends QueueConnection<T> {
     /**
      * Drain this queue's jobs to a remote bunqueue server (store-and-forward).
-     * Typical edge pattern: embedded local queue as offline buffer, forwarded
-     * to a central server over TCP/TLS. Remote failures leave jobs local
-     * (retry → DLQ) — nothing is lost while the uplink is down. Forwarded jobs
-     * carry a deterministic remote jobId so re-forwards never duplicate.
+     * Remote failures leave jobs local and deterministic remote IDs prevent
+     * duplicate delivery when a forward is retried.
      */
     forward(options: ForwardOptions): Forwarder;
-    disconnect(): Promise<void>;
-    close(): void;
 }