bunqueue 2.8.56 → 2.8.58

package/README.md

@@ -242,13 +242,18 @@ implementation:
 
 | SDK | Runtime invariants | Generated tests | Mutation engine |
 | --- | --- | --- | --- |
-| [TypeScript](./sdk/typescript/README.md) | [contract](./sdk/typescript/INVARIANTS.md) | fast-check | StrykerJS |
+| [TypeScript](./sdk/typescript/README.md) | [contract](./sdk/typescript/INVARIANTS.md) | fast-check | none¹ |
 | [Python](./sdk/python/README.md) | [contract](./sdk/python/INVARIANTS.md) | Hypothesis | mutmut |
 | [PHP](./sdk/php/README.md) | [contract](./sdk/php/INVARIANTS.md) | Eris | Infection |
 | [Go](./sdk/go/README.md) | [contract](./sdk/go/INVARIANTS.md) | Rapid | Gremlins |
 | [Rust](./sdk/rust/README.md) | [contract](./sdk/rust/INVARIANTS.md) | proptest | cargo-mutants |
 | [Elixir](./sdk/elixir/README.md) | [contract](./sdk/elixir/INVARIANTS.md) | StreamData | Muex |
 
+¹ The TypeScript SDK has no mutation engine. StrykerJS was removed because its
+dependency graph produced every advisory the weekly audit had to answer for,
+none of it reachable from the published client; the planners keep their
+fast-check coverage.
+
 Property campaigns run in the ordinary SDK gate with deterministic replay
 seeds. Mutation campaigns run separately against the pure planners and
 snapshot validators. Contributors can reproduce the complete isolated SDK

package/dist/client/bunqueue/aging.d.ts

@@ -6,6 +6,7 @@ import type { Queue } from '../queue/queue';
 import type { PriorityAgingConfig } from './types';
 export declare class PriorityAger<T = unknown> {
     private timer;
+    private generation;
     private readonly config;
     private readonly queue;
     constructor(config: PriorityAgingConfig, queue: Queue<T>);

package/dist/client/bunqueue/aging.js

@@ -4,6 +4,7 @@
  */
 export class PriorityAger {
     timer = null;
+    generation = 0;
     config;
     queue;
     constructor(config, queue) {
@@ -11,12 +12,17 @@ export class PriorityAger {
         this.queue = queue;
     }
     start() {
+        if (this.timer !== null)
+            return;
         const interval = this.config.interval ?? 60000;
+        const generation = ++this.generation;
         this.timer = setInterval(() => {
-            void this.tick();
+            void this.tick(generation);
         }, interval);
     }
-    async tick() {
+    async tick(generation) {
+        if (generation !== this.generation)
+            return;
         const minAge = this.config.minAge ?? 60000;
         const boost = this.config.boost ?? 1;
         const maxPriority = this.config.maxPriority ?? 100;
@@ -26,9 +32,13 @@ export class PriorityAger {
             this.queue.getWaitingAsync(0, maxScan),
             this.queue.getJobsAsync({ state: 'prioritized', start: 0, end: maxScan }),
         ]);
+        if (generation !== this.generation)
+            return;
         const jobs = [...waiting, ...prioritized];
         const now = Date.now();
         for (const job of jobs) {
+            if (generation !== this.generation)
+                return;
             const age = now - job.timestamp;
             if (age >= minAge && job.priority < maxPriority) {
                 const newPriority = Math.min(job.priority + boost, maxPriority);
@@ -44,9 +54,10 @@ export class PriorityAger {
         }
     }
     destroy() {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
+        this.generation++;
+        const timer = this.timer;
+        this.timer = null;
+        if (timer !== null)
+            clearInterval(timer);
     }
 }

package/dist/client/bunqueue/cancellation.d.ts

@@ -3,11 +3,12 @@
  * AbortController-based cancellation with optional grace period.
  */
 export declare class CancellationManager {
-    private readonly controllers;
+    private readonly currentByJob;
+    private readonly registrations;
     /** Register a new AbortController for a job */
     register(jobId: string): AbortController;
     /** Remove a job's controller (on completion) */
-    unregister(jobId: string): void;
+    unregister(jobId: string, controller?: AbortController): void;
     /** Cancel a job with optional grace period */
     cancel(jobId: string, gracePeriodMs?: number): void;
     /** Check if a job is cancelled */
@@ -16,4 +17,5 @@ export declare class CancellationManager {
     getSignal(jobId: string): AbortSignal | null;
     /** Cancel all and clear */
     destroyAll(): void;
+    private clearTimer;
 }

package/dist/client/bunqueue/cancellation.js

@@ -3,45 +3,77 @@
  * AbortController-based cancellation with optional grace period.
  */
 export class CancellationManager {
-    controllers = new Map();
+    currentByJob = new Map();
+    registrations = new Map();
     /** Register a new AbortController for a job */
     register(jobId) {
-        const ac = new AbortController();
-        this.controllers.set(jobId, ac);
-        return ac;
+        const controller = new AbortController();
+        const registration = { jobId, controller, timer: null, deadline: null };
+        this.currentByJob.set(jobId, registration);
+        this.registrations.set(controller, registration);
+        return controller;
     }
     /** Remove a job's controller (on completion) */
-    unregister(jobId) {
-        this.controllers.delete(jobId);
+    unregister(jobId, controller) {
+        const registration = controller
+            ? this.registrations.get(controller)
+            : this.currentByJob.get(jobId);
+        if (!registration || registration.jobId !== jobId)
+            return;
+        this.clearTimer(registration);
+        this.registrations.delete(registration.controller);
+        if (this.currentByJob.get(jobId) === registration)
+            this.currentByJob.delete(jobId);
     }
     /** Cancel a job with optional grace period */
     cancel(jobId, gracePeriodMs = 0) {
-        const ac = this.controllers.get(jobId);
-        if (!ac)
+        const registration = this.currentByJob.get(jobId);
+        if (!registration)
+            return;
+        if (gracePeriodMs <= 0) {
+            this.clearTimer(registration);
+            registration.controller.abort();
             return;
-        if (gracePeriodMs > 0) {
-            setTimeout(() => {
-                ac.abort();
-            }, gracePeriodMs);
-        }
-        else {
-            ac.abort();
         }
+        if (registration.controller.signal.aborted)
+            return;
+        const deadline = Date.now() + gracePeriodMs;
+        if (registration.deadline !== null && registration.deadline <= deadline)
+            return;
+        this.clearTimer(registration);
+        const timer = setTimeout(() => {
+            if (registration.timer !== timer)
+                return;
+            registration.timer = null;
+            registration.deadline = null;
+            registration.controller.abort();
+        }, gracePeriodMs);
+        registration.timer = timer;
+        registration.deadline = deadline;
     }
     /** Check if a job is cancelled */
     isCancelled(jobId) {
-        const ac = this.controllers.get(jobId);
-        return ac ? ac.signal.aborted : false;
+        return this.currentByJob.get(jobId)?.controller.signal.aborted ?? false;
     }
     /** Get the AbortSignal for a job */
     getSignal(jobId) {
-        return this.controllers.get(jobId)?.signal ?? null;
+        return this.currentByJob.get(jobId)?.controller.signal ?? null;
     }
     /** Cancel all and clear */
     destroyAll() {
-        for (const ac of this.controllers.values()) {
-            ac.abort();
-        }
-        this.controllers.clear();
+        const registrations = [...this.registrations.values()];
+        this.currentByJob.clear();
+        this.registrations.clear();
+        for (const registration of registrations)
+            this.clearTimer(registration);
+        for (const registration of registrations)
+            registration.controller.abort();
+    }
+    clearTimer(registration) {
+        const timer = registration.timer;
+        registration.timer = null;
+        registration.deadline = null;
+        if (timer !== null)
+            clearTimeout(timer);
     }
 }

package/dist/client/bunqueue/circuitBreaker.d.ts

@@ -7,6 +7,7 @@ export declare class WorkerCircuitBreaker {
     private state;
     private failures;
     private timer;
+    private destroyed;
     private readonly config;
     private readonly worker;
     constructor(config: CircuitBreakerConfig, worker: Worker);

package/dist/client/bunqueue/circuitBreaker.js

@@ -5,6 +5,7 @@ export class WorkerCircuitBreaker {
     state = 'closed';
     failures = 0;
     timer = null;
+    destroyed = false;
     config;
     worker;
     constructor(config, worker) {
@@ -18,6 +19,8 @@ export class WorkerCircuitBreaker {
         return this.state === 'open';
     }
     onSuccess() {
+        if (this.destroyed)
+            return;
         if (this.state === 'half-open') {
             this.state = 'closed';
             this.failures = 0;
@@ -28,6 +31,8 @@ export class WorkerCircuitBreaker {
         }
     }
     onFailure() {
+        if (this.destroyed)
+            return;
         this.failures++;
         const threshold = this.config.threshold ?? 5;
         if (this.state === 'half-open' || this.failures >= threshold) {
@@ -35,19 +40,31 @@ export class WorkerCircuitBreaker {
         }
     }
     open() {
+        if (this.destroyed)
+            return;
         this.state = 'open';
         this.config.onOpen?.(this.failures);
+        if (this.destroyed)
+            return;
         this.worker.pause();
         const resetTimeout = this.config.resetTimeout ?? 30000;
         if (this.timer)
             clearTimeout(this.timer);
-        this.timer = setTimeout(() => {
+        const timer = setTimeout(() => {
+            if (this.destroyed || this.timer !== timer)
+                return;
+            this.timer = null;
             this.state = 'half-open';
             this.config.onHalfOpen?.();
+            if (this.destroyed)
+                return;
             this.worker.resume();
         }, resetTimeout);
+        this.timer = timer;
     }
     reset() {
+        if (this.destroyed)
+            return;
         this.state = 'closed';
         this.failures = 0;
         if (this.timer) {
@@ -59,6 +76,7 @@ export class WorkerCircuitBreaker {
         }
     }
     destroy() {
+        this.destroyed = true;
         if (this.timer) {
             clearTimeout(this.timer);
             this.timer = null;

package/dist/client/bunqueue/retry.d.ts

@@ -5,4 +5,4 @@ import type { RetryConfig, RetryStrategy } from './types';
 /** Calculate backoff delay based on strategy */
 export declare function calculateBackoff(strategy: RetryStrategy, attempt: number, baseDelay: number, error: Error, config: RetryConfig): number;
 /** Execute a function with retry logic */
-export declare function executeWithRetry<R>(fn: () => Promise<R>, config: RetryConfig): Promise<R>;
+export declare function executeWithRetry<R>(fn: () => Promise<R>, config: RetryConfig, signal?: AbortSignal): Promise<R>;

package/dist/client/bunqueue/retry.js

@@ -30,24 +30,62 @@ export function calculateBackoff(strategy, attempt, baseDelay, error, config) {
             return baseDelay;
     }
 }
+function cancellationError() {
+    return new Error('Job cancelled');
+}
+function waitForRetry(delay, next, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(cancellationError());
+            return;
+        }
+        let timer = null;
+        const onAbort = () => {
+            if (timer !== null)
+                clearTimeout(timer);
+            timer = null;
+            signal?.removeEventListener('abort', onAbort);
+            reject(cancellationError());
+        };
+        timer = setTimeout(() => {
+            timer = null;
+            signal?.removeEventListener('abort', onAbort);
+            if (signal?.aborted) {
+                reject(cancellationError());
+                return;
+            }
+            resolve(next());
+        }, delay);
+        signal?.addEventListener('abort', onAbort, { once: true });
+        if (signal?.aborted)
+            onAbort();
+    });
+}
 /** Execute a function with retry logic */
-export function executeWithRetry(fn, config) {
+export function executeWithRetry(fn, config, signal) {
     const maxAttempts = config.maxAttempts ?? 3;
     const baseDelay = config.delay ?? 1000;
     const strategy = config.strategy ?? 'exponential';
     const attempt = (n) => {
-        return fn().catch((err) => {
+        if (signal?.aborted)
+            return Promise.reject(cancellationError());
+        let execution;
+        try {
+            execution = fn();
+        }
+        catch (error) {
+            execution = Promise.reject(error);
+        }
+        return execution.catch((err) => {
             const error = err instanceof Error ? err : new Error(String(err));
+            if (signal?.aborted)
+                throw cancellationError();
             if (n >= maxAttempts)
                 throw error;
             if (config.retryIf && !config.retryIf(error, n))
                 throw error;
             const delay = calculateBackoff(strategy, n, baseDelay, error, config);
-            return new Promise((resolve) => {
-                setTimeout(() => {
-                    resolve(attempt(n + 1));
-                }, delay);
-            });
+            return waitForRetry(delay, () => attempt(n + 1), signal);
         });
     };
     return attempt(1);

package/dist/client/bunqueue/runtime.js

@@ -103,18 +103,36 @@ export class BunqueueRuntime {
         }
         const abortController = this.cancellation.register(job.id);
         const runChain = () => this.runMiddlewareChain(job, abortController);
-        const execution = this.retryConfig ? executeWithRetry(runChain, this.retryConfig) : runChain();
+        let execution;
+        try {
+            execution = this.retryConfig
+                ? executeWithRetry(runChain, this.retryConfig, abortController.signal)
+                : runChain();
+        }
+        catch (error) {
+            execution = Promise.reject(error);
+        }
         return execution.then((result) => {
-            this.cb?.onSuccess();
-            this.cancellation.unregister(job.id);
-            return result;
+            try {
+                this.cb?.onSuccess();
+                return result;
+            }
+            finally {
+                this.cancellation.unregister(job.id, abortController);
+            }
         }, (error) => {
-            this.cb?.onFailure();
-            this.cancellation.unregister(job.id);
-            throw error;
+            try {
+                this.cb?.onFailure();
+                throw error;
+            }
+            finally {
+                this.cancellation.unregister(job.id, abortController);
+            }
         });
     }
     runMiddlewareChain(job, abortController) {
+        if (abortController.signal.aborted)
+            return Promise.reject(new Error('Job cancelled'));
         const publicJob = job;
         if (this.middlewares.length === 0) {
             const result = this.baseProcessor(job);

package/dist/client/manager.d.ts

@@ -4,7 +4,10 @@
 import { QueueManager } from '../application/queueManager';
 /** Shared manager type export */
 export type SharedManager = QueueManager;
-/** Get shared QueueManager instance. Programmatic dataPath overrides env var. */
+/**
+ * Get the process-wide QueueManager.
+ * A later explicit dataPath must identify the database selected on first use.
+ */
 export declare function getSharedManager(dataPath?: string): QueueManager;
 /** Shutdown shared manager */
 export declare function shutdownManager(): void;

package/dist/client/manager.js

@@ -1,21 +1,59 @@
 /**
  * Shared QueueManager singleton
  */
+import { realpathSync } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
 import { QueueManager } from '../application/queueManager';
-let instance = null;
+let shared = null;
 /** Get data path from environment (priority: BUNQUEUE_DATA_PATH > BQ_DATA_PATH > DATA_PATH) */
 function getDataPath() {
     return (Bun.env.BUNQUEUE_DATA_PATH ?? Bun.env.BQ_DATA_PATH ?? Bun.env.DATA_PATH ?? Bun.env.SQLITE_PATH);
 }
-/** Get shared QueueManager instance. Programmatic dataPath overrides env var. */
+function normalizeDataPath(dataPath) {
+    if (!dataPath)
+        return undefined;
+    if (dataPath === ':memory:')
+        return dataPath;
+    const absolutePath = resolve(dataPath);
+    try {
+        return realpathSync.native(absolutePath);
+    }
+    catch {
+        try {
+            return join(realpathSync.native(dirname(absolutePath)), basename(absolutePath));
+        }
+        catch {
+            return absolutePath;
+        }
+    }
+}
+function displayDataPath(dataPath) {
+    return JSON.stringify(dataPath ?? '<in-memory>');
+}
+/**
+ * Get the process-wide QueueManager.
+ * A later explicit dataPath must identify the database selected on first use.
+ */
 export function getSharedManager(dataPath) {
-    instance ??= new QueueManager({ dataPath: dataPath ?? getDataPath() });
+    if (shared) {
+        if (dataPath !== undefined) {
+            const requestedDataPath = normalizeDataPath(dataPath);
+            if (requestedDataPath !== shared.dataPath) {
+                throw new Error(`Embedded QueueManager dataPath conflict: already initialized with ${displayDataPath(shared.dataPath)}; ` +
+                    `cannot use ${displayDataPath(requestedDataPath)}. Reuse the active dataPath, or close all ` +
+                    'embedded clients and call shutdownManager() before switching databases.');
+            }
+        }
+        return shared.instance;
+    }
+    const selectedDataPath = normalizeDataPath(dataPath ?? getDataPath());
+    const instance = new QueueManager({ dataPath: selectedDataPath });
+    shared = { instance, dataPath: selectedDataPath };
     return instance;
 }
 /** Shutdown shared manager */
 export function shutdownManager() {
-    if (instance) {
-        instance.shutdown();
-        instance = null;
-    }
+    const current = shared;
+    shared = null;
+    current?.instance.shutdown();
 }

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

@@ -11,6 +11,7 @@ export declare class QueueState<T> {
     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;

package/dist/client/queue/runtime/state.js

@@ -14,6 +14,7 @@ export class QueueState {
     tcpPool;
     useSharedPool;
     addBatcher;
+    connectionReleased = false;
     constructor(name, opts = {}) {
         this.name = name;
         this.prefixKey = opts.prefixKey ?? '';
@@ -139,6 +140,9 @@ export class QueueState {
         };
     }
     releaseConnection() {
+        if (this.connectionReleased)
+            return;
+        this.connectionReleased = true;
         if (!this.tcpPool)
             return;
         if (this.useSharedPool)

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

@@ -23,6 +23,7 @@ export interface QueueOptions {
     defaultJobOptions?: JobOptions;
     connection?: ConnectionOptions;
     embedded?: boolean;
+    /** Must match the process-wide embedded manager when one is already active. */
     dataPath?: string;
     autoBatch?: AutoBatchOptions;
     prefixKey?: string;

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

@@ -4,7 +4,7 @@ export interface QueueEventsOptions {
     embedded?: boolean;
     /** TCP connection used when embedded is false. */
     connection?: ConnectionOptions;
-    /** Embedded SQLite path. */
+    /** Embedded SQLite path; must match an already-active shared manager. */
     dataPath?: string;
     /** Namespace prefix applied to the queue name. */
     prefixKey?: string;

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

@@ -10,6 +10,7 @@ export interface WorkerOptions {
     heartbeatInterval?: number;
     connection?: ConnectionOptions;
     embedded?: boolean;
+    /** Must match the process-wide embedded manager when one is already active. */
     dataPath?: string;
     batchSize?: number;
     pollTimeout?: number;

package/dist/client/worker/runtime/control.js

@@ -6,13 +6,10 @@ import { startHeartbeat } from '../workerHeartbeat';
 import { WorkerState } from './state';
 export class WorkerControl extends WorkerState {
     run() {
-        if (this.running || this.closed)
+        if (this.running || this.closed || this._closing || this._closingPromise !== null)
             return;
         this.running = true;
         this.paused = false;
-        this._closing = false;
-        this._forceClose = false;
-        this._closingPromise = null;
         queueMicrotask(() => {
             if (!this.closed)
                 this.emit('ready');
@@ -88,10 +85,7 @@ export class WorkerControl extends WorkerState {
             return;
         this.running = false;
         this.paused = true;
-        if (this.pollTimer) {
-            clearTimeout(this.pollTimer);
-            this.pollTimer = null;
-        }
+        this.clearPollTimer();
     }
     resume() {
         if (this.closed)

package/dist/client/worker/runtime/lifecycle.js

@@ -19,10 +19,7 @@ export class WorkerLifecycle extends WorkerManual {
         this._closing = true;
         this.running = false;
         this.paused = false;
-        if (this.pollTimer) {
-            clearTimeout(this.pollTimer);
-            this.pollTimer = null;
-        }
+        this.clearPollTimer();
         if (this.heartbeatTimer) {
             clearInterval(this.heartbeatTimer);
             this.heartbeatTimer = null;

package/dist/client/worker/runtime/polling.d.ts

@@ -6,6 +6,7 @@ export declare abstract class WorkerPolling<T = unknown, R = unknown> extends Wo
     protected tryProcess(): Promise<void>;
     protected doPullBatch(): Promise<PulledJob[]>;
     private scheduleRateLimitPoll;
+    private schedulePoll;
     protected handlePullError(errorValue: unknown): void;
     protected abstract startJob(delivery: WorkerDelivery): boolean;
     protected abstract getPullConfig(): PullConfig;

package/dist/client/worker/runtime/polling.js

@@ -3,12 +3,11 @@ import { pullEmbedded, pullTcp } from '../workerPull';
 import { WorkerBuffer } from './buffer';
 export class WorkerPolling extends WorkerBuffer {
     poll() {
+        this.clearPollTimer();
         if (!this.running || this._closing)
             return;
         if (this.activeJobs >= this.opts.concurrency) {
-            this.pollTimer = setTimeout(() => {
-                this.poll();
-            }, 10);
+            this.schedulePoll(10);
             return;
         }
         if (!this.rateLimiter.canProcessWithinLimit()) {
@@ -46,9 +45,7 @@ export class WorkerPolling extends WorkerBuffer {
             if (item) {
                 if (this.activeJobs >= this.opts.concurrency) {
                     this.requeueItem(item);
-                    this.pollTimer = setTimeout(() => {
-                        this.poll();
-                    }, 10);
+                    this.schedulePoll(10);
                     return;
                 }
                 this.consecutiveErrors = 0;
@@ -60,9 +57,7 @@ export class WorkerPolling extends WorkerBuffer {
             else {
                 const hasBuffered = this.pendingJobsHead < this.pendingJobs.length;
                 if (hasBuffered && this.groupLimiter) {
-                    this.pollTimer = setTimeout(() => {
-                        this.poll();
-                    }, 10);
+                    this.schedulePoll(10);
                     return;
                 }
                 const now = Date.now();
@@ -71,9 +66,7 @@ export class WorkerPolling extends WorkerBuffer {
                     this.emit('drained');
                 }
                 const waitTime = this.opts.pollTimeout > 0 ? 10 : this.opts.drainDelay;
-                this.pollTimer = setTimeout(() => {
-                    this.poll();
-                }, waitTime);
+                this.schedulePoll(waitTime);
             }
         }
         catch (error) {
@@ -103,9 +96,25 @@ export class WorkerPolling extends WorkerBuffer {
     }
     scheduleRateLimitPoll() {
         const waitTime = this.rateLimiter.getTimeUntilNextSlot();
-        this.pollTimer = setTimeout(() => {
+        this.schedulePoll(Math.max(waitTime, 10));
+    }
+    schedulePoll(delay) {
+        if (!this.running || this._closing || this.closed)
+            return;
+        const deadline = Date.now() + delay;
+        if (this.pollTimer !== null && this.pollDeadline !== null && this.pollDeadline <= deadline) {
+            return;
+        }
+        this.clearPollTimer();
+        const timer = setTimeout(() => {
+            if (this.pollTimer !== timer)
+                return;
+            this.pollTimer = null;
+            this.pollDeadline = null;
             this.poll();
-        }, Math.max(waitTime, 10));
+        }, delay);
+        this.pollTimer = timer;
+        this.pollDeadline = deadline;
     }
     handlePullError(errorValue) {
         this.consecutiveErrors++;
@@ -116,8 +125,6 @@ export class WorkerPolling extends WorkerBuffer {
             context: 'pull',
         }));
         const backoffMs = Math.min(WORKER_CONSTANTS.BASE_BACKOFF_MS * Math.pow(2, this.consecutiveErrors - 1), WORKER_CONSTANTS.MAX_BACKOFF_MS);
-        this.pollTimer = setTimeout(() => {
-            this.poll();
-        }, backoffMs);
+        this.schedulePoll(backoffMs);
     }
 }

package/dist/client/worker/runtime/state.d.ts

@@ -34,6 +34,7 @@ export declare abstract class WorkerState<T = unknown, R = unknown> extends Even
     protected closed: boolean;
     protected activeJobs: number;
     protected pollTimer: ReturnType<typeof setTimeout> | null;
+    protected pollDeadline: number | null;
     protected consecutiveErrors: number;
     protected readonly pulledJobIds: Set<string>;
     protected readonly jobTokens: Map<string, string>;
@@ -102,6 +103,7 @@ export declare abstract class WorkerState<T = unknown, R = unknown> extends Even
     protected hasActiveDelivery(jobId: string): boolean;
     protected activeDeliveryIds(): IterableIterator<string>;
     protected clearDeliveries(): void;
+    protected clearPollTimer(): void;
     abstract run(): void;
     protected abstract registerWithServer(): void;
     protected abstract getHeartbeatDeps(): HeartbeatDeps;

package/dist/client/worker/runtime/state.js

@@ -24,6 +24,7 @@ export class WorkerState extends EventEmitter {
     closed = false;
     activeJobs = 0;
     pollTimer = null;
+    pollDeadline = null;
     consecutiveErrors = 0;
     pulledJobIds = new Set();
     jobTokens = new Map();
@@ -153,4 +154,11 @@ export class WorkerState extends EventEmitter {
         this.currentDeliveries.clear();
         this.activeDeliveries.clear();
     }
+    clearPollTimer() {
+        const timer = this.pollTimer;
+        this.pollTimer = null;
+        this.pollDeadline = null;
+        if (timer !== null)
+            clearTimeout(timer);
+    }
 }

package/dist/infrastructure/backup/s3Backup.d.ts

@@ -19,6 +19,7 @@ export declare class S3BackupManager {
     private readonly telemetry;
     private backupInterval;
     private initialBackupTimeout;
+    private schedulerGeneration;
     private dashboardEmit;
     /** Set the dashboard event emitter callback */
     setDashboardEmit(callback: (event: string, data: Record<string, unknown>) => void): void;

package/dist/infrastructure/backup/s3Backup.js

@@ -20,6 +20,7 @@ export class S3BackupManager {
     telemetry;
     backupInterval = null;
     initialBackupTimeout = null;
+    schedulerGeneration = 0;
     dashboardEmit = null;
     /** Set the dashboard event emitter callback */
     setDashboardEmit(callback) {
@@ -73,30 +74,43 @@ export class S3BackupManager {
         if (!this.config.enabled) {
             return;
         }
+        if (this.initialBackupTimeout !== null || this.backupInterval !== null)
+            return;
         const validation = this.validate();
         if (!validation.valid) {
             backupLog.error('S3 backup configuration invalid', { errors: validation.errors });
             return;
         }
+        const generation = ++this.schedulerGeneration;
         // Run initial backup after 1 minute
-        this.initialBackupTimeout = setTimeout(() => {
+        const initialBackupTimeout = setTimeout(() => {
+            if (generation !== this.schedulerGeneration ||
+                this.initialBackupTimeout !== initialBackupTimeout) {
+                return;
+            }
             this.initialBackupTimeout = null;
             this.backup().catch((err) => {
                 backupLog.error('Initial backup failed', { error: String(err) });
             });
         }, 60 * 1000);
+        this.initialBackupTimeout = initialBackupTimeout;
         // Schedule periodic backups
-        this.backupInterval = setInterval(() => {
+        const backupInterval = setInterval(() => {
+            if (generation !== this.schedulerGeneration || this.backupInterval !== backupInterval) {
+                return;
+            }
             this.backup().catch((err) => {
                 backupLog.error('Scheduled backup failed', { error: String(err) });
             });
         }, this.config.intervalMs);
+        this.backupInterval = backupInterval;
         this.telemetry.setSchedulerRunning(true);
     }
     /**
      * Stop automated backup scheduler
      */
     stop() {
+        this.schedulerGeneration++;
         if (this.initialBackupTimeout) {
             clearTimeout(this.initialBackupTimeout);
             this.initialBackupTimeout = null;

package/dist/infrastructure/cloud/cloudAgent.d.ts

@@ -22,6 +22,7 @@ export declare class CloudAgent {
     private statsUpdateTimer;
     private unsubscribeEvents;
     private sequenceId;
+    private started;
     private stopped;
     private serverHandles?;
     /** Event buffer — flushed into each HTTP snapshot */

package/dist/infrastructure/cloud/cloudAgent.js

@@ -27,6 +27,7 @@ export class CloudAgent {
     statsUpdateTimer = null;
     unsubscribeEvents = null;
     sequenceId = 0;
+    started = false;
     stopped = false;
     serverHandles;
     /** Event buffer — flushed into each HTTP snapshot */
@@ -59,6 +60,9 @@ export class CloudAgent {
     }
     /** Start both channels */
     start() {
+        if (this.started || this.stopped)
+            return;
+        this.started = true;
         cloudLog.info('Connecting to dashboard', {
             url: this.config.url,
             instance: this.config.instanceName,
@@ -156,15 +160,19 @@ export class CloudAgent {
     }
     /** Schedule next snapshot with dynamic interval */
     scheduleNext() {
-        if (this.stopped)
+        if (this.stopped || !this.started)
             return;
         const intervalMs = this.computeInterval();
         cloudLog.debug('Next snapshot', { intervalMs, compressedKB: this.httpSender.lastCompressedKB });
-        this.snapshotTimer = setTimeout(() => {
+        const snapshotTimer = setTimeout(() => {
+            if (this.stopped || this.snapshotTimer !== snapshotTimer)
+                return;
+            this.snapshotTimer = null;
             void this.sendSnapshot().then(() => {
                 this.scheduleNext();
             });
         }, intervalMs);
+        this.snapshotTimer = snapshotTimer;
     }
     /** Collect and send a snapshot via HTTP */
     async sendSnapshot(_forceHeavy = false) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunqueue",
-  "version": "2.8.56",
+  "version": "2.8.58",
   "description": "High-performance job queue for Bun & AI agents. SQLite persistence, cron scheduling, priorities, retries, DLQ, webhooks, native MCP server. Zero external infrastructure.",
   "type": "module",
   "main": "dist/main.js",

package/dist/application/types.d.ts

@@ -1,148 +0,0 @@
-/**
- * Shared types for QueueManager modules
- */
-import type { Job, JobId, JobLock } from '../domain/types/job';
-import type { JobLocation } from '../domain/types/queue';
-import type { JobLogEntry } from '../domain/types/worker';
-import type { Shard } from '../domain/queue/shard';
-import type { SqliteStorage } from '../infrastructure/persistence/sqlite';
-import type { RWLock } from '../shared/lock';
-import type { LRUMap, BoundedSet, BoundedMap, SetLike, MapLike } from '../shared/lru';
-import type { EventsManager } from './eventsManager';
-import type { WebhookManager } from './webhookManager';
-import type { WorkerManager } from './workerManager';
-import type { MonitoringState } from './monitoringChecks';
-import type { DependencyResultTracker } from './dependencyResultTracker';
-import type { DependencyCompletionTracker } from './dependencyCompletions';
-/** Queue Manager configuration */
-export interface QueueManagerConfig {
-    dataPath?: string;
-    maxCompletedJobs?: number;
-    maxJobResults?: number;
-    maxJobLogs?: number;
-    maxCustomIds?: number;
-    maxWaitingDeps?: number;
-    /** Maximum queue label values emitted in one Prometheus scrape; zero disables them. */
-    maxPrometheusQueues?: number;
-    cleanupIntervalMs?: number;
-    jobTimeoutCheckMs?: number;
-    dependencyCheckMs?: number;
-    stallCheckMs?: number;
-    dlqMaintenanceMs?: number;
-    validateWebhookUrls?: boolean;
-}
-export declare const DEFAULT_CONFIG: {
-    maxCompletedJobs: number;
-    maxJobResults: number;
-    maxJobLogs: number;
-    maxCustomIds: number;
-    maxWaitingDeps: number;
-    maxPrometheusQueues: number;
-    cleanupIntervalMs: number;
-    jobTimeoutCheckMs: number;
-    dependencyCheckMs: number;
-    stallCheckMs: number;
-    dlqMaintenanceMs: number;
-};
-/** Shared state accessible by all modules */
-export interface QueueManagerState {
-    readonly config: typeof DEFAULT_CONFIG & {
-        dataPath?: string;
-    };
-    readonly storage: SqliteStorage | null;
-    readonly shards: Shard[];
-    readonly shardLocks: RWLock[];
-    readonly processingShards: Map<JobId, Job>[];
-    readonly processingLocks: RWLock[];
-    readonly jobIndex: Map<JobId, JobLocation>;
-    readonly completedJobs: BoundedSet<JobId>;
-    readonly jobResults: LRUMap<JobId, unknown>;
-    readonly dependencyResults: DependencyResultTracker;
-    readonly customIdMap: LRUMap<string, JobId>;
-    readonly jobLogs: LRUMap<JobId, JobLogEntry[]>;
-    readonly jobLocks: Map<JobId, JobLock>;
-    readonly clientJobs: Map<string, Set<JobId>>;
-    readonly stalledCandidates: Set<JobId>;
-    readonly pendingDepChecks: Set<JobId>;
-    readonly queueNamesCache: Set<string>;
-    readonly eventsManager: EventsManager;
-    readonly webhookManager: WebhookManager;
-    readonly metrics: {
-        totalPushed: {
-            value: bigint;
-        };
-        totalPulled: {
-            value: bigint;
-        };
-        totalCompleted: {
-            value: bigint;
-        };
-        totalFailed: {
-            value: bigint;
-        };
-    };
-    readonly startTime: number;
-    readonly perQueueMetrics: MapLike<string, {
-        totalCompleted: bigint;
-        totalFailed: bigint;
-    }>;
-}
-/** Context for lock operations */
-export interface LockContext {
-    jobIndex: Map<JobId, JobLocation>;
-    jobLocks: Map<JobId, JobLock>;
-    clientJobs: Map<string, Set<JobId>>;
-    processingShards: Map<JobId, Job>[];
-    processingLocks: RWLock[];
-    shards: Shard[];
-    shardLocks: RWLock[];
-    eventsManager: EventsManager;
-    dashboardEmit?: (event: string, data: Record<string, unknown>) => void;
-    storage: SqliteStorage | null;
-}
-/** Context for background tasks */
-export interface BackgroundContext extends QueueManagerState {
-    fail: (jobId: JobId, error?: string) => Promise<void>;
-    registerQueueName: (queue: string) => void;
-    unregisterQueueName: (queue: string) => void;
-    dashboardEmit?: (event: string, data: Record<string, unknown>) => void;
-    workerManager: WorkerManager;
-    monitoringState: MonitoringState;
-    completedJobsData: BoundedMap<JobId, Job>;
-    depCompletions?: DependencyCompletionTracker;
-    maxDependencyCompletions: number;
-    timedOutJobs?: BoundedSet<JobId>;
-}
-/** Context for stats operations */
-export interface StatsContext {
-    shards: Shard[];
-    processingShards: Map<JobId, Job>[];
-    completedJobs: SetLike<JobId>;
-    jobIndex: Map<JobId, JobLocation>;
-    jobResults: LRUMap<JobId, unknown>;
-    jobLogs: LRUMap<JobId, JobLogEntry[]>;
-    customIdMap: LRUMap<string, JobId>;
-    jobLocks: Map<JobId, JobLock>;
-    clientJobs: Map<string, Set<JobId>>;
-    pendingDepChecks: Set<JobId>;
-    stalledCandidates: Set<JobId>;
-    metrics: {
-        totalPushed: {
-            value: bigint;
-        };
-        totalPulled: {
-            value: bigint;
-        };
-        totalCompleted: {
-            value: bigint;
-        };
-        totalFailed: {
-            value: bigint;
-        };
-    };
-    startTime: number;
-    perQueueMetrics?: MapLike<string, {
-        totalCompleted: bigint;
-        totalFailed: bigint;
-    }>;
-}

package/dist/application/types.js

@@ -1,16 +0,0 @@
-/**
- * Shared types for QueueManager modules
- */
-export const DEFAULT_CONFIG = {
-    maxCompletedJobs: 50_000,
-    maxJobResults: 10_000,
-    maxJobLogs: 10_000,
-    maxCustomIds: 50_000,
-    maxWaitingDeps: 10_000,
-    maxPrometheusQueues: 100,
-    cleanupIntervalMs: 10_000,
-    jobTimeoutCheckMs: 5_000,
-    dependencyCheckMs: 30_000, // Safety fallback only; event-driven handles fast path
-    stallCheckMs: 5_000,
-    dlqMaintenanceMs: 60_000,
-};

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

@@ -1,33 +0,0 @@
-/**
- * Queue Internal Types
- * Shared types for queue module operations
- */
-import type { TcpConnectionPool } from '../tcpPool';
-import type { QueueOptions, JobStateType } from '../types';
-/** 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/client/queue/queueTypes.js

@@ -1,5 +0,0 @@
-/**
- * Queue Internal Types
- * Shared types for queue module operations
- */
-export {};

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

@@ -1,79 +0,0 @@
-/**
- * Sandboxed Worker Types
- * Type definitions for sandboxed worker processes
- */
-import type { SharedManager } from '../manager';
-import type { ConnectionOptions } from '../types';
-import type { Job as DomainJob } from '../../domain/types/job';
-/** Sandboxed worker configuration */
-export interface SandboxedWorkerOptions {
-    /** Path to processor file (must export default async function) */
-    processor: string;
-    /** Number of worker processes (default: 1) */
-    concurrency?: number;
-    /** Max memory per worker in MB - uses smol mode if <= 64 (default: 256) */
-    maxMemory?: number;
-    /** Job timeout in ms (default: 30000) */
-    timeout?: number;
-    /** Auto-restart crashed workers (default: true) */
-    autoRestart?: boolean;
-    /** Max restarts before giving up (default: 10) */
-    maxRestarts?: number;
-    /** Poll interval when no workers are idle (default: 10ms) */
-    pollInterval?: number;
-    /** Custom QueueManager (for testing, defaults to shared manager) */
-    manager?: SharedManager;
-    /** TCP connection options (if provided, uses TCP mode instead of embedded) */
-    connection?: ConnectionOptions;
-    /** Heartbeat interval in ms for TCP lock renewal (default: 10000 for TCP, 0 for embedded) */
-    heartbeatInterval?: number;
-    /** Auto-stop after this many ms of inactivity (0 = disabled, default: 0) */
-    idleTimeout?: number;
-    /** Recycle individual idle worker processes after this many ms (default: 30000, 0 = disabled) */
-    idleRecycleMs?: number;
-    /** Auto-restart worker pool when new jobs arrive after idle shutdown (default: false) */
-    autoStart?: boolean;
-    /** Poll interval in ms for checking new jobs while in idle-shutdown state (default: 5000) */
-    autoStartPollMs?: number;
-}
-/** Required options with defaults applied */
-export interface RequiredSandboxedWorkerOptions {
-    processor: string;
-    concurrency: number;
-    maxMemory: number;
-    timeout: number;
-    autoRestart: boolean;
-    maxRestarts: number;
-    pollInterval: number;
-}
-/** Worker process state */
-export interface WorkerProcess {
-    worker: Worker;
-    busy: boolean;
-    currentJob: DomainJob | null;
-    currentToken: string | null;
-    restarts: number;
-    timeoutId: Timer | null;
-    lastIdleAt: number;
-    terminated: boolean;
-}
-/** IPC message from main to worker */
-export interface IPCRequest {
-    type: 'job';
-    job: {
-        id: string;
-        data: unknown;
-        queue: string;
-        attempts: number;
-        parentId?: string;
-    };
-}
-/** IPC message from worker to main */
-export interface IPCResponse {
-    type: 'result' | 'error' | 'progress' | 'log' | 'fail' | 'ready';
-    jobId?: string;
-    result?: unknown;
-    error?: string;
-    progress?: number;
-    message?: string;
-}

package/dist/client/sandboxed/types.js

@@ -1,5 +0,0 @@
-/**
- * Sandboxed Worker Types
- * Type definitions for sandboxed worker processes
- */
-export {};

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

@@ -1,50 +0,0 @@
-/**
- * Worker Types
- * Type definitions for worker module
- */
-import type { ConnectionOptions } from '../types';
-/** Pending ACK item with result and optional lock token */
-export interface PendingAck {
-    id: string;
-    result: unknown;
-    token?: string;
-    resolve: () => void;
-    reject: (err: Error) => void;
-}
-/** Extended options with all defaults */
-export interface ExtendedWorkerOptions {
-    concurrency: number;
-    autorun: boolean;
-    heartbeatInterval: number;
-    batchSize: number;
-    pollTimeout: number;
-    embedded: boolean;
-    useLocks: boolean;
-    skipLockRenewal: boolean;
-    skipStalledCheck: boolean;
-    drainDelay: number;
-    lockDuration: number;
-    maxStalledCount: number;
-    removeOnComplete?: boolean | number | {
-        age?: number;
-        count?: number;
-    };
-    removeOnFail?: boolean | number | {
-        age?: number;
-        count?: number;
-    };
-    connection?: ConnectionOptions;
-}
-/** TCP connection interface */
-export interface TcpConnection {
-    send: (cmd: Record<string, unknown>) => Promise<Record<string, unknown>>;
-}
-/** Check if embedded mode should be forced (for tests) */
-export declare const FORCE_EMBEDDED: boolean;
-/** Worker constants */
-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/client/worker/types.js

@@ -1,13 +0,0 @@
-/**
- * Worker Types
- * Type definitions for worker module
- */
-/** Check if embedded mode should be forced (for tests) */
-export const FORCE_EMBEDDED = Bun.env.BUNQUEUE_EMBEDDED === '1';
-/** Worker constants */
-export const WORKER_CONSTANTS = {
-    MAX_BACKOFF_MS: 30_000,
-    BASE_BACKOFF_MS: 100,
-    MAX_POLL_TIMEOUT: 30_000,
-    DEFAULT_ACK_INTERVAL: 50,
-};