bunqueue-client 0.1.8 → 0.2.0

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

@@ -0,0 +1,45 @@
+import type { Job } from "./job.js";
+export interface DlqConfig {
+    autoRetry?: boolean;
+    autoRetryInterval?: number;
+    maxAutoRetries?: number;
+    maxAge?: number | null;
+    maxEntries?: number;
+}
+export type FailureReason = 'explicit_fail' | 'max_attempts_exceeded' | 'timeout' | 'stalled' | 'ttl_expired' | 'worker_lost' | 'unknown';
+export interface DlqEntry<T = unknown> {
+    job: Job<T>;
+    enteredAt: number;
+    reason: FailureReason;
+    error: string | null;
+    attempts: Array<{
+        attempt: number;
+        startedAt: number;
+        failedAt: number;
+        reason: FailureReason;
+        error: string | null;
+        duration: number;
+    }>;
+    retryCount: number;
+    lastRetryAt: number | null;
+    nextRetryAt: number | null;
+    expiresAt: number | null;
+}
+export interface DlqStats {
+    total: number;
+    byReason: Record<FailureReason, number>;
+    byQueue: Record<string, number>;
+    pendingRetry: number;
+    expired: number;
+    oldestEntry: number | null;
+    newestEntry: number | null;
+}
+export interface DlqFilter {
+    reason?: FailureReason;
+    olderThan?: number;
+    newerThan?: number;
+    retriable?: boolean;
+    expired?: boolean;
+    limit?: number;
+    offset?: number;
+}

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

@@ -0,0 +1,54 @@
+import type { ConnectionOptions } from "./connection.js";
+export interface QueueEventsOptions {
+    /** Select the embedded manager instead of the TCP broker. */
+    embedded?: boolean;
+    /** TCP connection used when embedded is false. */
+    connection?: ConnectionOptions;
+    /** Embedded SQLite path; must match an already-active shared manager. */
+    dataPath?: string;
+    /** Namespace prefix applied to the queue name. */
+    prefixKey?: string;
+}
+export interface WaitingEvent {
+    jobId: string;
+}
+export interface ActiveEvent {
+    jobId: string;
+}
+export interface CompletedEvent<R = unknown> {
+    jobId: string;
+    returnvalue: R;
+}
+export interface FailedEvent {
+    jobId: string;
+    failedReason: string;
+    data?: unknown;
+}
+export interface ProgressEvent<P = unknown> {
+    jobId: string;
+    data: P;
+}
+export interface StalledEvent {
+    jobId: string;
+}
+export interface RemovedEvent {
+    jobId: string;
+    prev: string;
+}
+export interface DelayedEvent {
+    jobId: string;
+    delay: number;
+}
+export interface DuplicatedEvent {
+    jobId: string;
+}
+export interface RetriedEvent {
+    jobId: string;
+    prev: string;
+}
+export interface WaitingChildrenEvent {
+    jobId: string;
+}
+export interface DrainedEvent {
+    id: string;
+}

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

@@ -0,0 +1,22 @@
+import type { Job } from "./job.js";
+export interface FlowJobData {
+    __flowParentId?: string;
+    __flowParentIds?: string[];
+    __parentId?: string;
+    __parentQueue?: string;
+    __childrenIds?: string[];
+}
+export interface ProcessorContext {
+    signal: AbortSignal;
+}
+export interface ObservableLike<T> {
+    subscribe(observer: {
+        next(value: T): void;
+        error(error: unknown): void;
+        complete(): void;
+    }): {
+        unsubscribe(): void;
+    } | (() => void) | undefined;
+}
+export type Processor<T = unknown, R = unknown> = (job: Job<T & FlowJobData>, context?: ProcessorContext) => Promise<R> | ObservableLike<R> | R;
+export type QueueEventType = 'waiting' | 'active' | 'completed' | 'failed' | 'progress' | 'removed' | 'drained';

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

@@ -0,0 +1,10 @@
+export type { AutoBatchOptions, ClientTlsOptions, ConnectionOptions, QueueOptions, } from "./connection.js";
+export type { DlqConfig, DlqEntry, DlqFilter, DlqStats, FailureReason } from "./dlq.js";
+export type { ActiveEvent, CompletedEvent, DelayedEvent, DrainedEvent, DuplicatedEvent, FailedEvent, ProgressEvent, QueueEventsOptions, RemovedEvent, RetriedEvent, StalledEvent, WaitingChildrenEvent, WaitingEvent, } from "./events.js";
+export type { FlowJobData, ObservableLike, Processor, ProcessorContext, QueueEventType, } from "./flow.js";
+export type { ChangePriorityOpts, GetDependenciesOpts, Job, JobDependencies, JobDependenciesCount, JobJson, JobJsonRaw, JobStateType, } from "./job.js";
+export type { QueueMetrics, QueueMetricsMeta, QueueMetricType } from "./metrics.js";
+export type { BackoffOptions, DebounceOptions, DeduplicationOptions, GroupJobOptions, JobOptions, KeepJobs, ParentOpts, RepeatOptions, } from "./options.js";
+export type { BatchWorkerOptions, GroupWorkerOptions, RateLimiterOptions, StallConfig, WorkerOptions, } from "./worker.js";
+export { createPublicJob, toDlqEntry, toPublicJob } from "../jobConversion.js";
+export type { CreatePublicJobOptions, ToPublicJobOptions } from "../jobConversion.js";

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

@@ -0,0 +1,131 @@
+import type { JobOptions } from "./options.js";
+export type JobStateType = 'waiting' | 'prioritized' | 'delayed' | 'active' | 'completed' | 'failed' | 'waiting-children' | 'unknown';
+export interface JobJson<T = unknown> {
+    id: string;
+    name: string;
+    data: T;
+    opts: JobOptions;
+    progress: number;
+    delay: number;
+    timestamp: number;
+    attemptsMade: number;
+    stacktrace: string[] | null;
+    returnvalue?: unknown;
+    failedReason?: string;
+    finishedOn?: number;
+    processedOn?: number;
+    queueQualifiedName: string;
+    parentKey?: string;
+}
+export interface JobJsonRaw {
+    id: string;
+    name: string;
+    data: string;
+    opts: string;
+    progress: string;
+    delay: string;
+    timestamp: string;
+    attemptsMade: string;
+    stacktrace: string | null;
+    returnvalue?: string;
+    failedReason?: string;
+    finishedOn?: string;
+    processedOn?: string;
+    parentKey?: string;
+}
+export interface ChangePriorityOpts {
+    priority: number;
+    lifo?: boolean;
+}
+export interface GetDependenciesOpts {
+    processed?: {
+        cursor?: number;
+        count?: number;
+    };
+    unprocessed?: {
+        cursor?: number;
+        count?: number;
+    };
+}
+export interface JobDependencies {
+    processed: Record<string, unknown>;
+    unprocessed: string[];
+    nextProcessedCursor?: number;
+    nextUnprocessedCursor?: number;
+}
+export interface JobDependenciesCount {
+    processed: number;
+    unprocessed: number;
+}
+/** Public BullMQ-compatible job contract. */
+export interface Job<T = unknown> {
+    id: string;
+    name: string;
+    data: T;
+    queueName: string;
+    attemptsMade: number;
+    timestamp: number;
+    progress: number;
+    returnvalue?: unknown;
+    failedReason?: string;
+    parent?: {
+        id: string;
+        queueQualifiedName: string;
+    };
+    delay: number;
+    processedOn?: number;
+    finishedOn?: number;
+    stacktrace: string[] | null;
+    stalledCounter: number;
+    priority: number;
+    parentKey?: string;
+    opts: JobOptions;
+    token?: string;
+    processedBy?: string;
+    deduplicationId?: string;
+    repeatJobKey?: string;
+    attemptsStarted: number;
+    updateProgress(progress: number, message?: string): Promise<void>;
+    log(message: string): Promise<void>;
+    getState(): Promise<JobStateType>;
+    remove(): Promise<void>;
+    retry(): Promise<void>;
+    getChildrenValues<R = unknown>(): Promise<Record<string, R>>;
+    isWaiting(): Promise<boolean>;
+    isActive(): Promise<boolean>;
+    isDelayed(): Promise<boolean>;
+    isCompleted(): Promise<boolean>;
+    isFailed(): Promise<boolean>;
+    isWaitingChildren(): Promise<boolean>;
+    updateData(data: T): Promise<void>;
+    promote(): Promise<void>;
+    changeDelay(delay: number): Promise<void>;
+    changePriority(opts: ChangePriorityOpts): Promise<void>;
+    extendLock(token: string, duration: number): Promise<number>;
+    clearLogs(keepLogs?: number): Promise<void>;
+    getDependencies(opts?: GetDependenciesOpts): Promise<JobDependencies>;
+    getDependenciesCount(opts?: GetDependenciesOpts): Promise<JobDependenciesCount>;
+    toJSON(): JobJson<T>;
+    asJSON(): JobJsonRaw;
+    moveToCompleted(returnValue: unknown, token?: string, fetchNext?: boolean): Promise<unknown>;
+    moveToFailed(error: Error, token?: string, fetchNext?: boolean): Promise<void>;
+    moveToWait(token?: string): Promise<boolean>;
+    moveToDelayed(timestamp: number, token?: string): Promise<void>;
+    moveToWaitingChildren(token?: string, opts?: {
+        child?: {
+            id: string;
+            queue: string;
+        };
+    }): Promise<boolean>;
+    waitUntilFinished(queueEvents: unknown, ttl?: number): Promise<unknown>;
+    discard(): void;
+    getFailedChildrenValues(): Promise<Record<string, string>>;
+    getIgnoredChildrenFailures(): Promise<Record<string, string>>;
+    removeChildDependency(): Promise<boolean>;
+    removeDeduplicationKey(): Promise<boolean>;
+    removeUnprocessedChildren(): Promise<void>;
+    /** Available on a native batch processor's leading job. */
+    getBatch?(): Job<T>[];
+    /** Mark only this member as failed while allowing the rest of its batch to complete. */
+    setAsFailed?(error: Error): void;
+}

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

@@ -0,0 +1 @@
+export type { QueueMetrics, QueueMetricsMeta, QueueMetricType } from "../../domain/types/metrics.js";

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

@@ -0,0 +1,70 @@
+export interface ParentOpts {
+    id: string;
+    queue: string;
+}
+export interface BackoffOptions {
+    type: 'fixed' | 'exponential';
+    delay: number;
+}
+export interface KeepJobs {
+    age?: number;
+    count?: number;
+}
+export interface DeduplicationOptions {
+    id: string;
+    ttl?: number;
+    extend?: boolean;
+    replace?: boolean;
+}
+export interface DebounceOptions {
+    id: string;
+    ttl: number;
+}
+export interface RepeatOptions {
+    every?: number;
+    limit?: number;
+    pattern?: string;
+    startDate?: Date | string | number;
+    endDate?: Date | string | number;
+    tz?: string;
+    immediately?: boolean;
+    count?: number;
+    prevMillis?: number;
+    offset?: number;
+    jobId?: string;
+}
+export interface GroupJobOptions {
+    id: string | number;
+    /** Maximum number of pending jobs admitted for this group. */
+    maxSize?: number;
+    /** Intra-group priority from 0 to 2,097,151; lower values run first. */
+    priority?: number;
+}
+/** Options accepted when adding a job. */
+export interface JobOptions {
+    priority?: number;
+    delay?: number;
+    attempts?: number;
+    backoff?: number | BackoffOptions;
+    timeout?: number;
+    jobId?: string;
+    /** Age/count retention is intentionally unsupported. */
+    removeOnComplete?: boolean;
+    removeOnFail?: boolean;
+    stallTimeout?: number;
+    repeat?: RepeatOptions;
+    durable?: boolean;
+    parent?: ParentOpts;
+    lifo?: boolean;
+    stackTraceLimit?: number;
+    keepLogs?: number;
+    sizeLimit?: number;
+    failParentOnFailure?: boolean;
+    removeDependencyOnFailure?: boolean;
+    continueParentOnFailure?: boolean;
+    ignoreDependencyOnFailure?: boolean;
+    timestamp?: number;
+    deduplication?: DeduplicationOptions;
+    debounce?: DebounceOptions;
+    group?: GroupJobOptions;
+}

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

@@ -0,0 +1,54 @@
+import type { ConnectionOptions } from "./connection.js";
+export interface RateLimiterOptions {
+    max: number;
+    duration: number;
+    groupKey?: string;
+}
+export interface GroupWorkerOptions {
+    concurrency?: number;
+    limit?: {
+        max: number;
+        duration: number;
+    };
+}
+export interface BatchWorkerOptions {
+    size: number;
+    minSize?: number;
+    timeout?: number;
+    groupAffinity?: boolean;
+}
+export interface WorkerOptions {
+    concurrency?: number;
+    autorun?: boolean;
+    heartbeatInterval?: number;
+    connection?: ConnectionOptions;
+    embedded?: boolean;
+    /** Must match the process-wide embedded manager when one is already active. */
+    dataPath?: string;
+    batchSize?: number;
+    pollTimeout?: number;
+    useLocks?: boolean;
+    limiter?: RateLimiterOptions;
+    group?: GroupWorkerOptions;
+    batch?: BatchWorkerOptions;
+    lockDuration?: number;
+    maxStalledCount?: number;
+    skipStalledCheck?: boolean;
+    skipLockRenewal?: boolean;
+    drainDelay?: number;
+    removeOnComplete?: boolean | number | {
+        age?: number;
+        count?: number;
+    };
+    removeOnFail?: boolean | number | {
+        age?: number;
+        count?: number;
+    };
+    prefixKey?: string;
+}
+export interface StallConfig {
+    enabled?: boolean;
+    stallInterval?: number;
+    maxStalls?: number;
+    gracePeriod?: number;
+}

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

@@ -0,0 +1,2 @@
+/** Backwards-compatible barrel for the public client types. */
+export * from "./types/index.js";

package/dist/types/src/client/worker/ackBatcher.d.ts

@@ -0,0 +1,55 @@
+/**
+ * ACK Batcher
+ * Batches acknowledgments for efficient TCP communication
+ */
+import type { TcpConnection } from "./types/index.js";
+/** ACK batcher configuration */
+export interface AckBatcherConfig {
+    batchSize: number;
+    interval: number;
+    embedded: boolean;
+    maxBatchSize?: (pendingCount: number) => number;
+    /** Receives an error thrown by `maxBatchSize`; the static `batchSize` applies instead. */
+    onThresholdError?: (error: Error) => void;
+    maxRetries?: number;
+    retryDelayMs?: number;
+}
+/**
+ * Batches ACK operations for efficient processing
+ */
+export declare class AckBatcher {
+    private readonly MAX_PENDING_ACKS;
+    private readonly pendingAcks;
+    private ackTimer;
+    private readonly config;
+    private tcp;
+    private stopped;
+    private readonly inFlightFlushes;
+    constructor(config: AckBatcherConfig);
+    /** Set TCP connection */
+    setTcp(tcp: TcpConnection | null): void;
+    /** Queue ACK for batch processing (with optional lock token) */
+    queue(id: string, result: unknown, token?: string, removeOnComplete?: boolean, onQueued?: () => void): Promise<boolean>;
+    /** Re-evaluate a dynamic batch ceiling after worker capacity changes. */
+    notifyCapacityChanged(): void;
+    /** Flush pending ACKs with retry logic */
+    flush(): Promise<void>;
+    /** Send batch with exponential backoff retry */
+    private sendBatchWithRetry;
+    /** Stop and cleanup - clears pending acks without processing */
+    stop(): void;
+    /** Check if there are pending acks */
+    hasPending(): boolean;
+    /** Wait for all in-flight flush operations to complete */
+    waitForInFlight(): Promise<void>;
+    /**
+     * Never throws: `queue()` evaluates this after an ACK is already buffered, and
+     * `notifyCapacityChanged()` runs from worker setters and failure paths. A
+     * throwing dynamic ceiling falls back to the static `batchSize`, so the ACK
+     * stays owned by this batcher and is still flushed by size or by the timer.
+     */
+    private effectiveBatchSize;
+    private reportThresholdError;
+    private flushIfThresholdReached;
+    private startTrackedFlush;
+}

package/dist/types/src/client/worker/ackFrontier.d.ts

@@ -0,0 +1,21 @@
+import type { Job } from "../../domain/types/job.js";
+import type { GroupConcurrencyLimiter } from "./groupConcurrency.js";
+interface BufferedDelivery {
+    generation: number;
+    job: Job;
+}
+interface StartableAckDeliveryOptions<T extends BufferedDelivery> {
+    activeExecutions: number;
+    concurrency: number;
+    running: boolean;
+    closing: boolean;
+    nativeBatch: boolean;
+    rateSlots: number;
+    deliveries: readonly T[];
+    head: number;
+    isCurrent: (delivery: T) => boolean;
+    groupLimiter: GroupConcurrencyLimiter | null;
+}
+/** Count buffered scalar deliveries that can start without settling an ACK first. */
+export declare function countImmediatelyStartableAckDeliveries<T extends BufferedDelivery>(options: StartableAckDeliveryOptions<T>): number;
+export {};

package/dist/types/src/client/worker/ackOutcome.d.ts

@@ -0,0 +1,8 @@
+interface AckEntry {
+    readonly id: string;
+}
+/** Parse structured ACKB evidence, retaining duplicate job-ID positions. */
+export declare function ignoredAckIndices(data: unknown, batch: readonly AckEntry[]): ReadonlySet<number>;
+/** Parse a single ACK response; normal historical responses carry no data. */
+export declare function outcomeWasApplied(data: unknown): boolean;
+export {};

package/dist/types/src/client/worker/batchExecution.d.ts

@@ -0,0 +1,14 @@
+import type { Processor } from "../types.js";
+/** Coordinates one processor invocation across independently acknowledged jobs. */
+export declare class BatchExecution<T, R> {
+    private readonly processor;
+    private readonly size;
+    private readonly jobs;
+    private readonly failures;
+    private readonly signals;
+    private readonly ready;
+    private registered;
+    private outcome;
+    constructor(processor: Processor<T, R>, size: number);
+    handler(index: number): Processor<T, R>;
+}

package/dist/types/src/client/worker/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const FORCE_EMBEDDED: boolean;
+export declare const WORKER_CONSTANTS: {
+    readonly MAX_BACKOFF_MS: 30000;
+    readonly BASE_BACKOFF_MS: 100;
+    readonly MAX_POLL_TIMEOUT: 30000;
+    readonly DEFAULT_ACK_INTERVAL: 50;
+};

package/dist/types/src/client/worker/groupConcurrency.d.ts

@@ -0,0 +1,49 @@
+/**
+ * GroupConcurrencyLimiter - Per-group concurrency limiting for workers
+ *
+ * When a worker has limiter.groupKey set, this tracks how many jobs
+ * are active per group and enforces the limiter.max cap per group.
+ */
+import type { RateLimiterOptions } from "../types.js";
+import type { Job as InternalJob } from "../../domain/types/job.js";
+export declare class GroupConcurrencyLimiter {
+    private readonly groupKey;
+    private readonly maxPerGroup;
+    private readonly activeByGroup;
+    constructor(groupKey: string, max: number);
+    /**
+     * Create a GroupConcurrencyLimiter from limiter options, or null if
+     * groupKey is not configured.
+     */
+    static fromOptions(limiter: RateLimiterOptions | null | undefined): GroupConcurrencyLimiter | null;
+    /**
+     * Extract the group key value from a job's data.
+     * Returns null if the job data doesn't contain the group key field.
+     * Total: never throws, because the ACK frontier, admission and group
+     * accounting all call it on producer-controlled data.
+     */
+    getGroupValue(job: InternalJob): string | null;
+    /**
+     * Check if a job's group has capacity for another active job.
+     * Jobs without a group value are always allowed (no group limit applies).
+     */
+    canProcess(job: InternalJob): boolean;
+    /**
+     * Increment the active count for a job's group.
+     * Call this when a job starts processing.
+     */
+    increment(job: InternalJob): void;
+    /**
+     * Decrement the active count for a job's group.
+     * Call this when a job finishes (completed or failed).
+     */
+    decrement(job: InternalJob): void;
+    /** Get the current active count for a specific group. */
+    getGroupCount(group: string): number;
+    /** Get max per group. */
+    getMax(): number;
+    /** Get the group key field name. */
+    getGroupKey(): string;
+    /** Clear all tracking state. */
+    clear(): void;
+}

package/dist/types/src/client/worker/handlers/completion.d.ts

@@ -0,0 +1,29 @@
+import type { Job as InternalJob } from "../../../domain/types/job.js";
+import type { AckBatcher } from "../ackBatcher.js";
+import type { TcpConnection } from "../types/index.js";
+export declare function computeStackLines(error: Error): {
+    stackLines: string[];
+    wireStack: string[] | undefined;
+};
+interface MoveToFailedHandlerOptions {
+    embedded: boolean;
+    tcp: TcpConnection | null;
+    internalJob: InternalJob;
+    token: string | null | undefined;
+    removeOnFail: boolean | undefined;
+    onCalled: (error: Error) => void;
+    onIgnored: () => void;
+}
+export declare function createMoveToFailedHandler(options: MoveToFailedHandlerOptions): (id: string, error: Error, _lockToken?: string) => Promise<void>;
+interface MoveToCompletedHandlerOptions {
+    embedded: boolean;
+    ackBatcher: AckBatcher;
+    internalJob: InternalJob;
+    token: string | null | undefined;
+    removeOnComplete: boolean | undefined;
+    onAckQueued?: () => void;
+    onCalled: (value: unknown) => void;
+    onIgnored: () => void;
+}
+export declare function createMoveToCompletedHandler(options: MoveToCompletedHandlerOptions): (id: string, returnValue: unknown, _lockToken?: string) => Promise<unknown>;
+export {};

package/dist/types/src/client/worker/handlers/dependencies.d.ts

@@ -0,0 +1,11 @@
+import { type Job as InternalJob } from "../../../domain/types/job.js";
+import type { JobDependencies, JobDependenciesCount } from "../../types.js";
+import type { PendingTransitionSettlement, TcpConnection } from "../types/index.js";
+export declare function createWaitUntilFinishedHandler(embedded: boolean, tcp: TcpConnection | null): (id: string, _queueEvents: unknown, ttl?: number) => Promise<unknown>;
+export declare function createDiscardHandler(embedded: boolean, tcp: TcpConnection | null, options?: {
+    token?: string;
+    onPending?: (pending: Promise<PendingTransitionSettlement>) => void;
+}): (id: string) => void;
+export declare function createGetDependenciesHandler(embedded: boolean, tcp: TcpConnection | null, internalJob: InternalJob): (_id: string) => Promise<JobDependencies>;
+export declare function createGetDependenciesCountHandler(embedded: boolean, tcp: TcpConnection | null, internalJob: InternalJob): (_id: string) => Promise<JobDependenciesCount>;
+export declare function createRemoveDeduplicationKeyHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<boolean>;

package/dist/types/src/client/worker/handlers/mutations.d.ts

@@ -0,0 +1,23 @@
+import { type Job as InternalJob } from "../../../domain/types/job.js";
+import type { ChangePriorityOpts } from "../../types.js";
+import type { TcpConnection } from "../types/index.js";
+export declare function createRemoveHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<void>;
+export declare function createRetryHandler(embedded: boolean, tcp: TcpConnection | null, options: {
+    internalJob: InternalJob;
+    token?: string;
+    onTransitionApplied?: () => void;
+}): (id: string) => Promise<void>;
+export declare function createUpdateDataHandler(embedded: boolean, tcp: TcpConnection | null): (id: string, data: unknown) => Promise<void>;
+export declare function createPromoteHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<void>;
+export declare function createChangeDelayHandler(embedded: boolean, tcp: TcpConnection | null, token?: string, onTransitionApplied?: () => void): (id: string, delay: number) => Promise<void>;
+export declare function createChangePriorityHandler(embedded: boolean, tcp: TcpConnection | null): (id: string, options: ChangePriorityOpts) => Promise<void>;
+export declare function createExtendLockHandler(embedded: boolean, tcp: TcpConnection | null): (id: string, token: string, duration: number) => Promise<number>;
+export declare function createClearLogsHandler(embedded: boolean, tcp: TcpConnection | null): (id: string, keepLogs?: number) => Promise<void>;
+export declare function createMoveToWaitHandler(embedded: boolean, tcp: TcpConnection | null, onTransitionApplied?: () => void): (id: string, token?: string) => Promise<boolean>;
+export declare function createMoveToDelayedHandler(embedded: boolean, tcp: TcpConnection | null, onTransitionApplied?: () => void): (id: string, timestamp: number, token?: string) => Promise<void>;
+export declare function createMoveToWaitingChildrenHandler(embedded: boolean, tcp: TcpConnection | null, onTransitionApplied?: () => void): (id: string, token?: string, _opts?: {
+    child?: {
+        id: string;
+        queue: string;
+    };
+}) => Promise<boolean>;

package/dist/types/src/client/worker/handlers/queries.d.ts

@@ -0,0 +1,15 @@
+import type { EventEmitter } from 'events';
+import type { FlowJobData, Job, JobStateType } from "../../types.js";
+import type { TcpConnection } from "../types/index.js";
+export declare function createProgressHandler<T extends FlowJobData>(embedded: boolean, tcp: TcpConnection | null, emitter: EventEmitter, jobHolder: {
+    current: Job<T> | null;
+}): (id: string, progress: number, message?: string) => Promise<void>;
+export declare function createLogHandler<T extends FlowJobData>(embedded: boolean, tcp: TcpConnection | null, emitter: EventEmitter, jobHolder: {
+    current: Job<T> | null;
+}): (id: string, message: string) => Promise<void>;
+export declare function createGetStateHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<JobStateType>;
+export declare function createGetChildrenValuesHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<Record<string, unknown>>;
+export declare function createGetFailedChildrenValuesHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<Record<string, string>>;
+export declare function createGetIgnoredChildrenFailuresHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<Record<string, string>>;
+export declare function createRemoveChildDependencyHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<boolean>;
+export declare function createRemoveUnprocessedChildrenHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<void>;

package/dist/types/src/client/worker/jobParser.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Job Parser
+ * Parses job data from TCP responses
+ */
+import type { Job as InternalJob } from "../../domain/types/job.js";
+/**
+ * Parse job from TCP response data
+ */
+export declare function parseJobFromResponse(jobData: Record<string, unknown>, queueName: string): InternalJob;

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

@@ -0,0 +1,11 @@
+/**
+ * Job Processor
+ * Handles job execution and result reporting
+ */
+import type { Job as InternalJob } from "../../domain/types/job.js";
+import type { ProcessorConfig } from "./types/index.js";
+export type { ProcessorConfig } from "./types/index.js";
+/**
+ * Process a single job
+ */
+export declare function processJob<T, R>(internalJob: InternalJob, config: ProcessorConfig<T, R>): Promise<void>;