bunqueue-client 0.1.8 → 0.2.0

package/dist/types/src/client/queue/runtime/queries.d.ts

@@ -0,0 +1,66 @@
+import type { Job, JobOptions, JobStateType } from "../../types.js";
+import * as countsOps from "../operations/counts.js";
+import { QueueState } from "./state.js";
+/** Job creation, lookup, state-listing, and count operations. */
+export declare class QueueQueries<T> extends QueueState<T> {
+    getGroupJobsCount(groupId: string): Promise<number>;
+    getGroupsJobsCount(maxCount?: number): Promise<number>;
+    getGroupActiveCount(groupId: string): Promise<number>;
+    setGroupRateLimit(groupId: string, max: number, duration: number): Promise<void>;
+    getGroupRateLimit(groupId: string): Promise<{
+        max: number;
+        duration: number;
+    } | null>;
+    removeGroupRateLimit(groupId: string): Promise<number>;
+    getGroupRateLimitTtl(groupId: string, maxJobs?: number): Promise<number>;
+    setGroupConcurrency(groupId: string, concurrency: number): Promise<void>;
+    getGroupConcurrency(groupId: string): Promise<number | null>;
+    removeGroupConcurrency(groupId: string): Promise<number>;
+    pauseGroup(groupId: string): Promise<boolean>;
+    resumeGroup(groupId: string): Promise<boolean>;
+    isGroupPaused(groupId: string): Promise<boolean>;
+    getGroupJobs(groupId: string, start?: number, end?: number): Promise<Job<T>[]>;
+    getCountsPerPriorityForGroup(groupId: string): Promise<Record<number, number>>;
+    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>>;
+}

package/dist/types/src/client/queue/runtime/scheduling.d.ts

@@ -0,0 +1,33 @@
+import type { GetDependenciesOpts, JobDependencies, JobDependenciesCount } from "../../types.js";
+import * as schedulerOps from "../scheduler.js";
+import type { JobTemplate, RepeatOpts, SchedulerInfo } from "../scheduler.js";
+import { QueueConfiguration } from "./configuration.js";
+/** Scheduler, deduplication, job-transition, and dependency operations. */
+export declare class QueueScheduling<T> extends QueueConfiguration<T> {
+    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;
+    }>;
+}

package/dist/types/src/client/queue/runtime/state.d.ts

@@ -0,0 +1,101 @@
+import type { ChangePriorityOpts, GetDependenciesOpts, QueueOptions } from "../../types.js";
+import { TcpConnectionPool } from "../../tcpPool.js";
+import { AddBatcher } from "../addBatcher.js";
+/** Owns Queue connection state and builds the shared operation contexts. */
+export declare class QueueState<T> {
+    readonly name: string;
+    protected readonly queueKey: string;
+    protected readonly prefixKey: string;
+    protected readonly opts: QueueOptions;
+    protected readonly embedded: boolean;
+    protected readonly tcpPool: TcpConnectionPool | null;
+    protected readonly useSharedPool: boolean;
+    protected readonly addBatcher: AddBatcher<unknown> | null;
+    private connectionReleased;
+    constructor(name: string, opts?: QueueOptions);
+    protected get ctx(): {
+        name: string;
+        embedded: boolean;
+        tcp: TcpConnectionPool | null;
+        prefixKey: string;
+        dataPath: string | undefined;
+    };
+    protected get addCtx(): {
+        opts: QueueOptions;
+        getJobState: (id: string) => Promise<import("../../types.js").JobStateType>;
+        removeAsync: (id: string) => Promise<void>;
+        retryJob: (id: string) => Promise<void>;
+        getChildrenValues: (id: string) => Promise<Record<string, unknown>>;
+        updateJobData: (id: string, data: unknown) => Promise<void>;
+        promoteJob: (id: string) => Promise<void>;
+        changeJobDelay: (id: string, delay: number) => Promise<void>;
+        changeJobPriority: (id: string, options: ChangePriorityOpts) => Promise<void>;
+        extendJobLock: (id: string, token: string, duration: number) => Promise<number>;
+        clearJobLogs: (id: string, keep?: number) => Promise<void>;
+        getJobDependencies: (id: string, options?: GetDependenciesOpts) => Promise<import("../../index.js").JobDependencies>;
+        getJobDependenciesCount: (id: string, options?: GetDependenciesOpts) => Promise<import("../../index.js").JobDependenciesCount>;
+        getJobCountsAsync: () => Promise<unknown>;
+        getJobsAsync: (options: {
+            state?: string | string[];
+            start?: number;
+            end?: number;
+            asc?: boolean;
+        }) => Promise<import("../../index.js").Job<T>[]>;
+        moveJobToCompleted: (id: string, result: 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, options?: {
+            child?: {
+                id: string;
+                queue: string;
+            };
+        }) => Promise<boolean>;
+        waitJobUntilFinished: (id: string, queueEvents: unknown, ttl?: number) => Promise<unknown>;
+        name: string;
+        embedded: boolean;
+        tcp: TcpConnectionPool | null;
+        prefixKey: string;
+        dataPath: string | undefined;
+    };
+    protected get queryCtx(): {
+        getJobState: (id: string) => Promise<import("../../types.js").JobStateType>;
+        removeAsync: (id: string) => Promise<void>;
+        retryJob: (id: string) => Promise<void>;
+        getChildrenValues: (id: string) => Promise<Record<string, unknown>>;
+        updateJobData: (id: string, data: unknown) => Promise<void>;
+        promoteJob: (id: string) => Promise<void>;
+        changeJobDelay: (id: string, delay: number) => Promise<void>;
+        changeJobPriority: (id: string, options: ChangePriorityOpts) => Promise<void>;
+        extendJobLock: (id: string, token: string, duration: number) => Promise<number>;
+        clearJobLogs: (id: string, keep?: number) => Promise<void>;
+        getJobDependencies: (id: string, options?: GetDependenciesOpts) => Promise<import("../../index.js").JobDependencies>;
+        getJobDependenciesCount: (id: string, options?: GetDependenciesOpts) => Promise<import("../../index.js").JobDependenciesCount>;
+        moveJobToCompleted: (id: string, result: 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, options?: {
+            child?: {
+                id: string;
+                queue: string;
+            };
+        }) => Promise<boolean>;
+        waitJobUntilFinished: (id: string, queueEvents: unknown, ttl?: number) => Promise<unknown>;
+        name: string;
+        embedded: boolean;
+        tcp: TcpConnectionPool | null;
+        prefixKey: string;
+        dataPath: string | undefined;
+    };
+    protected get moveCtx(): {
+        getJobState: (id: string) => Promise<import("../../types.js").JobStateType>;
+        getJobDependencies: (id: string) => Promise<import("../../index.js").JobDependencies>;
+        name: string;
+        embedded: boolean;
+        tcp: TcpConnectionPool | null;
+        prefixKey: string;
+        dataPath: string | undefined;
+    };
+    protected releaseConnection(): void;
+}

package/dist/types/src/client/queue/scheduler.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Job Scheduler Operations (BullMQ v5 repeatable jobs)
+ */
+import type { TcpConnectionPool } from "../tcpPool.js";
+import type { JobOptions } from "../types.js";
+interface SchedulerContext {
+    /** Server-side queue key (already prefixed with `prefixKey` if set). */
+    name: string;
+    embedded: boolean;
+    tcp: TcpConnectionPool | null;
+    /**
+     * Namespace prefix from QueueOptions. When set, scheduler IDs are stored
+     * under `${prefixKey}${schedulerId}` so two queues with different prefixes
+     * cannot collide on the global cron-name PRIMARY KEY.
+     */
+    prefixKey?: string;
+    /** Queue-level default job options, merged under the scheduler template opts. */
+    defaultJobOptions?: JobOptions;
+}
+export interface RepeatOpts {
+    pattern?: string;
+    every?: number;
+    limit?: number;
+    immediately?: boolean;
+    count?: number;
+    prevMillis?: number;
+    offset?: number;
+    jobId?: string;
+    timezone?: string;
+    /** Skip missed runs on restart instead of executing them (default: true) */
+    skipMissedOnRestart?: boolean;
+    /** Skip job push if no worker is registered for the queue (default: false) */
+    skipIfNoWorker?: boolean;
+    /** Prevent overlapping cron jobs via automatic dedup (default: true) */
+    preventOverlap?: boolean;
+}
+export interface JobTemplate<T = unknown> {
+    name?: string;
+    data?: T;
+    opts?: JobOptions;
+}
+export interface SchedulerInfo {
+    id: string;
+    name: string;
+    next: number;
+    pattern?: string;
+    every?: number;
+    /** Max number of times the scheduler will fire (RepeatOpts.limit). #111 */
+    limit?: number;
+}
+/** Create or update a job scheduler */
+export declare function upsertJobScheduler(ctx: SchedulerContext, schedulerId: string, repeatOpts: RepeatOpts, jobTemplate?: JobTemplate): Promise<SchedulerInfo | null>;
+export declare function removeJobScheduler(ctx: SchedulerContext, schedulerId: string): Promise<boolean>;
+/** Get a job scheduler by ID */
+export declare function getJobScheduler(ctx: SchedulerContext, schedulerId: string): Promise<SchedulerInfo | null>;
+export declare function getJobSchedulers(ctx: SchedulerContext, start?: number, end?: number, asc?: boolean): Promise<SchedulerInfo[]>;
+export declare function getJobSchedulersCount(ctx: SchedulerContext): Promise<number>;
+export {};

package/dist/types/src/client/queue/schedulerPagination.d.ts

@@ -0,0 +1,7 @@
+interface ScheduledEntry {
+    id: string;
+    next: number;
+}
+/** Sort schedulers like BullMQ's scored range and apply its inclusive indexes. */
+export declare function paginateSchedulers<T extends ScheduledEntry>(schedulers: T[], start: number, end: number, asc: boolean): T[];
+export {};

package/dist/types/src/client/queue/stall.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Stall Detection Operations
+ * setStallConfig, getStallConfig
+ */
+import type { TcpConnectionPool } from "../tcpPool.js";
+import type { StallConfig } from "../types.js";
+interface StallContext {
+    name: string;
+    embedded: boolean;
+    tcp: TcpConnectionPool | null;
+}
+/** Set stall detection configuration */
+export declare function setStallConfig(ctx: StallContext, config: Partial<StallConfig>): void;
+/** Set stall detection configuration and resolve once the server has applied it. */
+export declare function setStallConfigAsync(ctx: StallContext, config: Partial<StallConfig>): Promise<void>;
+/** Get stall detection configuration */
+export declare function getStallConfig(ctx: StallContext): StallConfig;
+/** Get stall detection configuration (async, works in TCP mode) */
+export declare function getStallConfigAsync(ctx: StallContext): Promise<StallConfig>;
+export {};

package/dist/types/src/client/queue/types/add.d.ts

@@ -0,0 +1,40 @@
+import type { TcpConnectionPool } from "../../tcpPool.js";
+import type { GetDependenciesOpts, JobDependencies, JobDependenciesCount, JobOptions, JobStateType, QueueOptions } from "../../types.js";
+export interface ExtendedJobOptions extends JobOptions {
+    ttl?: number;
+    dependsOn?: string[];
+    tags?: string[];
+    groupId?: string;
+}
+export interface AddContext {
+    name: string;
+    opts: QueueOptions;
+    embedded: boolean;
+    tcp: TcpConnectionPool | null;
+    getJobState: (id: string) => Promise<JobStateType>;
+    removeAsync: (id: string) => Promise<void>;
+    retryJob: (id: string) => Promise<void>;
+    getChildrenValues: (id: string) => Promise<Record<string, unknown>>;
+    updateJobData: (id: string, data: unknown) => Promise<void>;
+    promoteJob: (id: string) => Promise<void>;
+    changeJobDelay: (id: string, delay: number) => Promise<void>;
+    changeJobPriority: (id: string, opts: {
+        priority: number;
+        lifo?: boolean;
+    }) => Promise<void>;
+    extendJobLock: (id: string, token: string, duration: number) => Promise<number>;
+    clearJobLogs: (id: string, keepLogs?: number) => Promise<void>;
+    getJobDependencies: (id: string, opts?: GetDependenciesOpts) => Promise<JobDependencies>;
+    getJobDependenciesCount: (id: string, opts?: GetDependenciesOpts) => Promise<JobDependenciesCount>;
+    moveJobToCompleted: (id: string, result: 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>;
+}

package/dist/types/src/client/queue/types/contexts.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Queue Internal Types
+ * Shared types for queue module operations
+ */
+import type { TcpConnectionPool } from "../../tcpPool.js";
+import type { JobStateType, QueueOptions } from "../../types.js";
+/** Internal queue context for operations */
+export interface QueueContext {
+    name: string;
+    opts: QueueOptions;
+    embedded: boolean;
+    tcp: TcpConnectionPool | null;
+    getJobState: (id: string) => Promise<JobStateType>;
+    removeAsync: (id: string) => Promise<void>;
+    retryJob: (id: string) => Promise<void>;
+    getChildrenValues: (id: string) => Promise<Record<string, unknown>>;
+}
+/** Job creation context for proxy */
+export interface JobCreationContext {
+    queueName: string;
+    tcp: TcpConnectionPool | null;
+    getJobState: (id: string) => Promise<string>;
+    removeAsync: (id: string) => Promise<void>;
+    retryJob: (id: string) => Promise<void>;
+    getChildrenValues: (id: string) => Promise<Record<string, unknown>>;
+}
+/** TCP response with optional data */
+export interface TcpResponse {
+    ok: boolean;
+    error?: string;
+    data?: unknown;
+    [key: string]: unknown;
+}

package/dist/types/src/client/queue/types/index.d.ts

@@ -0,0 +1,3 @@
+export type { JobCreationContext, QueueContext, TcpResponse } from "./contexts.js";
+export type { JobReflectionMeta, SimpleJobContext } from "./job.js";
+export type { QueueRuntime } from "./runtime.js";

package/dist/types/src/client/queue/types/job.d.ts

@@ -0,0 +1,50 @@
+import type { TcpConnectionPool } from "../../tcpPool.js";
+import type { JobOptions, JobStateType } from "../../types.js";
+export interface JobProxyContext {
+    queueName: string;
+    tcp: TcpConnectionPool;
+    getJobState: (id: string) => Promise<JobStateType>;
+    removeAsync: (id: string) => Promise<void>;
+    retryJob: (id: string) => Promise<void>;
+    getChildrenValues: (id: string) => Promise<Record<string, unknown>>;
+}
+export interface JobReflectionMeta {
+    attemptsMade?: number;
+    attemptsStarted?: number;
+    progress?: number;
+    stalledCounter?: number;
+    priority?: number;
+    delay?: number;
+    processedOn?: number;
+    finishedOn?: number;
+    opts?: JobOptions;
+    timestamp?: number;
+    stacktrace?: string[] | null;
+    returnvalue?: unknown;
+    failedReason?: string;
+}
+export interface ReflectedFields {
+    delay: number;
+    priority: number;
+    opts: JobOptions;
+    deduplicationId: string | undefined;
+    parentKey: string | undefined;
+    parent: {
+        id: string;
+        queueQualifiedName: string;
+    } | undefined;
+    repeatJobKey: string | undefined;
+    stacktrace: string[] | null;
+    returnvalue: unknown;
+    failedReason: string | undefined;
+}
+export interface SimpleJobContext {
+    queueName: string;
+    embedded?: boolean;
+    tcp?: TcpConnectionPool | null;
+    getJobState: (id: string) => Promise<JobStateType>;
+    removeAsync: (id: string) => Promise<void>;
+    retryJob: (id: string) => Promise<void>;
+    getChildrenValues: (id: string) => Promise<Record<string, unknown>>;
+    meta?: JobReflectionMeta;
+}

package/dist/types/src/client/queue/types/runtime.d.ts

@@ -0,0 +1,35 @@
+import type { ChangePriorityOpts, GetDependenciesOpts, Job, JobDependencies, JobDependenciesCount, JobStateType } from "../../types.js";
+/** Internal contract used by context callbacks across the Queue runtime layers. */
+export interface QueueRuntime<T> {
+    getJobState(id: string): Promise<JobStateType>;
+    removeAsync(id: string): Promise<void>;
+    retryJob(id: string): Promise<void>;
+    getChildrenValues(id: string): Promise<Record<string, unknown>>;
+    updateJobData(id: string, data: unknown): Promise<void>;
+    promoteJob(id: string): 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>;
+    clearJobLogs(id: string, keepLogs?: number): Promise<void>;
+    getJobDependencies(id: string, opts?: GetDependenciesOpts): Promise<JobDependencies>;
+    getJobDependenciesCount(id: string, opts?: GetDependenciesOpts): Promise<JobDependenciesCount>;
+    getJobCountsAsync(): Promise<unknown>;
+    getJobsAsync(options: {
+        state?: string | string[];
+        start?: number;
+        end?: number;
+        asc?: boolean;
+    }): Promise<Job<T>[]>;
+    moveJobToCompleted(id: string, result: 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>;
+    getWaitingAsync(start?: number, end?: number): Promise<Job<T>[]>;
+}

package/dist/types/src/client/queue/workers.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Worker Query Operations
+ */
+import type { TcpConnectionPool } from "../tcpPool.js";
+import type { QueueMetrics, QueueMetricType } from "../../domain/types/metrics.js";
+interface WorkersContext {
+    name: string;
+    embedded: boolean;
+    tcp: TcpConnectionPool | null;
+}
+export interface WorkerInfo {
+    id: string;
+    name: string;
+    addr?: string;
+    queues?: string[];
+    concurrency?: number;
+    hostname?: string;
+    pid?: number;
+    status?: 'active' | 'stale';
+    registeredAt?: number;
+    lastSeen?: number;
+    activeJobs?: number;
+    processedJobs?: number;
+    failedJobs?: number;
+    currentJob?: string | null;
+    uptime?: number;
+}
+/** Get workers processing this queue */
+export declare function getWorkers(ctx: WorkersContext): Promise<WorkerInfo[]>;
+/** Get worker count */
+export declare function getWorkersCount(ctx: WorkersContext): Promise<number>;
+/** Get metrics for this queue */
+export declare function getMetrics(ctx: WorkersContext, type: QueueMetricType, start?: number, end?: number): Promise<QueueMetrics>;
+/** Trim old events from this queue's durable lifecycle journal. */
+export declare function trimEvents(ctx: WorkersContext, maxLength: number): Promise<number>;
+export {};

package/dist/types/src/client/queue-events/tcpSubscription.d.ts

@@ -0,0 +1,23 @@
+import type { JobEvent } from "../../domain/types/queue.js";
+import type { ConnectionOptions } from "../types.js";
+interface TcpEventSubscriptionOptions {
+    connection?: ConnectionOptions;
+    onError: (error: Error) => void;
+    onEvent: (event: JobEvent) => void;
+    queue: string;
+}
+/** One dedicated TCP connection with one broker-side queue subscription. */
+export declare class TcpEventSubscription {
+    private readonly client;
+    private readonly queue;
+    private readonly onError;
+    private closed;
+    private ready;
+    private generation;
+    private subscriptionPromise;
+    constructor(options: TcpEventSubscriptionOptions);
+    waitUntilReady(): Promise<void>;
+    close(): void;
+    private ensureSubscribed;
+}
+export {};

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

@@ -0,0 +1,5 @@
+/**
+ * Queue - Re-exports from queue module
+ * @deprecated Import from './queue' instead
+ */
+export { Queue } from "./queue/queue.js";

package/dist/types/src/client/queueGroup.d.ts

@@ -0,0 +1,51 @@
+/**
+ * QueueGroup - Namespace isolation for queues
+ */
+import { Queue } from "./queue.js";
+import { Worker } from "./worker.js";
+import type { QueueOptions, WorkerOptions, Processor } from "./types.js";
+/**
+ * QueueGroup provides namespace isolation for queues.
+ * All queues in a group share a common prefix.
+ *
+ * @example
+ * ```typescript
+ * const billing = new QueueGroup('billing');
+ *
+ * const invoices = billing.getQueue('invoices');
+ * const payments = billing.getQueue('payments');
+ *
+ * // Creates queues: "billing:invoices", "billing:payments"
+ *
+ * billing.pauseAll(); // Pauses all billing queues
+ * ```
+ */
+export declare class QueueGroup {
+    readonly prefix: string;
+    private readonly queues;
+    constructor(namespace: string);
+    /** Get a queue within this group */
+    getQueue<T = unknown>(name: string, opts?: QueueOptions): Queue<T>;
+    /** Create a worker for a queue in this group */
+    getWorker<T = unknown, R = unknown>(name: string, processor: Processor<T, R>, opts?: WorkerOptions): Worker<T, R>;
+    /** List all queues in this group */
+    listQueues(): string[];
+    /** Pause all queues in this group */
+    pauseAll(): void;
+    /** Resume all queues in this group */
+    resumeAll(): void;
+    /** Drain all queues in this group (remove waiting jobs) */
+    drainAll(): void;
+    /** Obliterate all queues in this group (remove all data) */
+    obliterateAll(): void;
+    /** List queues created through this group, including remote queues. */
+    listQueuesAsync(): Promise<string[]>;
+    /** Pause every queue created through this group. */
+    pauseAllAsync(): Promise<void>;
+    /** Resume every queue created through this group. */
+    resumeAllAsync(): Promise<void>;
+    /** Drain waiting jobs from every queue and return the aggregate count. */
+    drainAllAsync(): Promise<number>;
+    /** Remove all data from every queue created through this group. */
+    obliterateAllAsync(): Promise<void>;
+}

package/dist/types/src/client/resolveToken.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Resolve auth token with priority:
+ *   1. explicitToken (from connection.token) - highest
+ *   2. Bun.env.BQ_TOKEN
+ *   3. Bun.env.BUNQUEUE_TOKEN
+ *   4. undefined if none set
+ *
+ * Empty strings are treated as not set.
+ */
+export declare function resolveToken(explicitToken: string | undefined): string | undefined;

package/dist/types/src/client/sandboxed/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Sandboxed Worker Module
+ * Re-exports all sandboxed worker components
+ */
+export type { SandboxedWorkerOptions, RequiredSandboxedWorkerOptions, WorkerProcess, IPCRequest, IPCResponse, } from "./types/index.js";
+export { createWrapperScript, cleanupWrapperScript } from "./wrapper.js";
+export { SandboxedWorker } from "./worker.js";

package/dist/types/src/client/sandboxed/queueOps.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Queue Operations for SandboxedWorker
+ * Provides a unified interface for embedded and TCP mode queue operations
+ */
+import type { Job as DomainJob, JobId } from "../../domain/types/job.js";
+import type { SharedManager } from "../manager.js";
+import type { TcpConnectionPool } from "../tcpPool.js";
+/** Unified queue operations interface */
+export interface QueueOps {
+    pull(queue: string, workerId: string, timeout: number): Promise<{
+        job: DomainJob | null;
+        token: string | null;
+    }>;
+    ack(id: JobId, result: unknown, token?: string): Promise<boolean>;
+    fail(id: JobId, error: string, token?: string): Promise<boolean>;
+    updateProgress(id: JobId, progress: number): Promise<void>;
+    addLog(id: JobId, message: string): void;
+    sendHeartbeat(ids: string[], tokens: string[]): Promise<void>;
+    countWaiting(queue: string): Promise<number>;
+}
+/** Create embedded mode operations using shared QueueManager */
+export declare function createEmbeddedOps(manager: SharedManager): QueueOps;
+/** Create TCP mode operations using connection pool */
+export declare function createTcpOps(tcp: TcpConnectionPool): QueueOps;

package/dist/types/src/client/sandboxed/runtime/dispatch.d.ts

@@ -0,0 +1,13 @@
+import type { Job as DomainJob } from "../../../domain/types/job.js";
+import type { Job } from "../../types.js";
+import type { IPCResponse, WorkerProcess } from "../types/index.js";
+import { SandboxedPool } from "./pool.js";
+export declare abstract class SandboxedDispatch<T = unknown> extends SandboxedPool<T> {
+    protected dispatch(worker: WorkerProcess, job: DomainJob, token: string | null): void;
+    protected handleMessage(worker: WorkerProcess, message: IPCResponse): void;
+    protected complete(worker: WorkerProcess, result: unknown): Promise<void>;
+    protected fail(worker: WorkerProcess, error: string): Promise<void>;
+    protected handleTimeout(worker: WorkerProcess, job: DomainJob): Promise<void>;
+    protected abstract safeEmitError(error: Error): void;
+    protected abstract createEventJob(domainJob: DomainJob): Job;
+}

package/dist/types/src/client/sandboxed/runtime/lifecycle.d.ts

@@ -0,0 +1,20 @@
+import type { WorkerProcess } from "../types/index.js";
+import { SandboxedState } from "./state.js";
+export declare abstract class SandboxedLifecycle<T = unknown> extends SandboxedState<T> {
+    start(): Promise<void>;
+    stop(force?: boolean): Promise<void>;
+    protected stopAndWatch(): Promise<void>;
+    protected checkAndRestart(): Promise<void>;
+    isRunning(): boolean;
+    getStats(): {
+        total: number;
+        busy: number;
+        idle: number;
+        recycled: number;
+        restarts: number;
+    };
+    protected resetWorkerState(worker: WorkerProcess): void;
+    protected abstract spawnWorker(index: number): Promise<void>;
+    protected abstract pullLoop(): Promise<void>;
+    protected abstract startHeartbeat(): void;
+}