bunqueue 2.8.53 → 2.8.56

package/dist/shared/lock.d.ts

@@ -1,75 +1,13 @@
-/**
- * Async Lock implementation
- * Provides read-write locks with timeout support
- * Optimized with O(1) queue operations using wrapped resolvers
- */
-/** Lock acquisition result */
-export interface LockGuard {
-    release(): void;
-}
-/** Lock timeout error */
-export declare class LockTimeoutError extends Error {
-    constructor(message?: string);
-}
-/**
- * Simple async mutex lock
- * FIFO ordering for fairness
- * O(1) timeout cancellation using marked entries instead of indexOf+splice
- */
-export declare class AsyncLock {
-    private locked;
-    private readonly queue;
-    /**
-     * Acquire the lock
-     * @param timeoutMs - Maximum time to wait (default: DEFAULT_LOCK_TIMEOUT_MS)
-     */
-    acquire(timeoutMs?: number): Promise<LockGuard>;
-    /** Check if lock is held */
-    isLocked(): boolean;
-    /** Get queue length (includes cancelled entries) */
-    getQueueLength(): number;
-}
-/**
- * Read-Write Lock
- * Multiple readers OR single writer
- * Writers have priority to prevent starvation
- * O(1) timeout cancellation using marked entries
- */
-export declare class RWLock {
-    private readers;
-    private writer;
-    private writerWaiting;
-    private readonly readerQueue;
-    private readonly writerQueue;
-    /**
-     * Acquire read lock
-     * Multiple readers can hold simultaneously
-     */
-    acquireRead(timeoutMs?: number): Promise<LockGuard>;
-    /**
-     * Acquire write lock
-     * Exclusive access, no readers or other writers
-     * Optimized: synchronous fast path when uncontested
-     */
-    acquireWrite(timeoutMs?: number): Promise<LockGuard>;
-    /** Create write lock guard - extracted to avoid code duplication */
-    private createWriteGuard;
-    /** Get current state */
-    getState(): {
-        readers: number;
-        writer: boolean;
-        writerWaiting: number;
-    };
-}
-/**
- * Execute with lock, ensuring release on error
- */
+/** Async lock facade and scoped execution helpers. */
+import { AsyncLock } from './asyncLock';
+import { RWLock } from './rwLock';
+export { AsyncLock } from './asyncLock';
+export { LockTimeoutError } from './lockError';
+export { RWLock } from './rwLock';
+export type { LockGuard } from './types/lock';
+/** Execute with an exclusive lock and always release it. */
 export declare function withLock<T>(lock: AsyncLock, fn: () => T | Promise<T>, timeoutMs?: number): Promise<T>;
-/**
- * Execute with read lock
- */
+/** Execute with a read lock and always release it. */
 export declare function withReadLock<T>(lock: RWLock, fn: () => T | Promise<T>, timeoutMs?: number): Promise<T>;
-/**
- * Execute with write lock
- */
+/** Execute with a write lock and always release it. */
 export declare function withWriteLock<T>(lock: RWLock, fn: () => T | Promise<T>, timeoutMs?: number): Promise<T>;

package/dist/shared/lock.js

@@ -1,228 +1,8 @@
-/**
- * Async Lock implementation
- * Provides read-write locks with timeout support
- * Optimized with O(1) queue operations using wrapped resolvers
- */
-/** Default lock timeout in milliseconds */
-const DEFAULT_LOCK_TIMEOUT_MS = parseInt(Bun.env.LOCK_TIMEOUT_MS ?? '5000', 10);
-/** Lock timeout error */
-export class LockTimeoutError extends Error {
-    constructor(message = 'Lock acquisition timed out') {
-        super(message);
-        this.name = 'LockTimeoutError';
-    }
-}
-/**
- * Simple async mutex lock
- * FIFO ordering for fairness
- * O(1) timeout cancellation using marked entries instead of indexOf+splice
- */
-export class AsyncLock {
-    locked = false;
-    queue = [];
-    /**
-     * Acquire the lock
-     * @param timeoutMs - Maximum time to wait (default: DEFAULT_LOCK_TIMEOUT_MS)
-     */
-    async acquire(timeoutMs = DEFAULT_LOCK_TIMEOUT_MS) {
-        const start = Date.now();
-        while (this.locked) {
-            const remaining = timeoutMs - (Date.now() - start);
-            if (remaining <= 0) {
-                throw new LockTimeoutError();
-            }
-            await new Promise((resolve) => {
-                const entry = { resolve, cancelled: false };
-                const timer = setTimeout(() => {
-                    // O(1) cancellation - just mark as cancelled
-                    entry.cancelled = true;
-                    resolve();
-                }, remaining);
-                entry.resolve = () => {
-                    clearTimeout(timer);
-                    resolve();
-                };
-                this.queue.push(entry);
-            });
-        }
-        this.locked = true;
-        let released = false;
-        return {
-            release: () => {
-                // Idempotent: ignore double-release on the same guard.
-                // Prevents stale releases from clobbering the next owner's `locked` flag
-                // and breaking the mutual-exclusion invariant.
-                if (released)
-                    return;
-                released = true;
-                this.locked = false;
-                // Skip cancelled entries - O(k) where k = cancelled entries at head
-                let next = this.queue.shift();
-                while (next) {
-                    if (!next.cancelled) {
-                        next.resolve();
-                        break;
-                    }
-                    next = this.queue.shift();
-                }
-            },
-        };
-    }
-    /** Check if lock is held */
-    isLocked() {
-        return this.locked;
-    }
-    /** Get queue length (includes cancelled entries) */
-    getQueueLength() {
-        return this.queue.length;
-    }
-}
-/**
- * Read-Write Lock
- * Multiple readers OR single writer
- * Writers have priority to prevent starvation
- * O(1) timeout cancellation using marked entries
- */
-export class RWLock {
-    readers = 0;
-    writer = false;
-    writerWaiting = 0;
-    readerQueue = [];
-    writerQueue = [];
-    /**
-     * Acquire read lock
-     * Multiple readers can hold simultaneously
-     */
-    async acquireRead(timeoutMs = DEFAULT_LOCK_TIMEOUT_MS) {
-        const start = Date.now();
-        // Wait if writer is active or writers are waiting (writer priority)
-        while (this.writer || this.writerWaiting > 0) {
-            const remaining = timeoutMs - (Date.now() - start);
-            if (remaining <= 0) {
-                throw new LockTimeoutError('Read lock acquisition timed out');
-            }
-            await new Promise((resolve) => {
-                const entry = { resolve, cancelled: false };
-                const timer = setTimeout(() => {
-                    // O(1) cancellation - just mark as cancelled
-                    entry.cancelled = true;
-                    resolve();
-                }, remaining);
-                entry.resolve = () => {
-                    clearTimeout(timer);
-                    resolve();
-                };
-                this.readerQueue.push(entry);
-            });
-        }
-        this.readers++;
-        let released = false;
-        return {
-            release: () => {
-                if (released)
-                    return;
-                released = true;
-                this.readers--;
-                if (this.readers === 0 && this.writerWaiting > 0) {
-                    // Skip cancelled entries
-                    let next = this.writerQueue.shift();
-                    while (next) {
-                        if (!next.cancelled) {
-                            next.resolve();
-                            break;
-                        }
-                        next = this.writerQueue.shift();
-                    }
-                }
-            },
-        };
-    }
-    /**
-     * Acquire write lock
-     * Exclusive access, no readers or other writers
-     * Optimized: synchronous fast path when uncontested
-     */
-    async acquireWrite(timeoutMs = DEFAULT_LOCK_TIMEOUT_MS) {
-        // Fast path: uncontested - acquire synchronously without Promise overhead
-        if (!this.writer && this.readers === 0) {
-            this.writer = true;
-            return this.createWriteGuard();
-        }
-        // Slow path: contention - wait asynchronously
-        const start = Date.now();
-        this.writerWaiting++;
-        try {
-            while (this.writer || this.readers > 0) {
-                const remaining = timeoutMs - (Date.now() - start);
-                if (remaining <= 0) {
-                    throw new LockTimeoutError('Write lock acquisition timed out');
-                }
-                await new Promise((resolve) => {
-                    const entry = { resolve, cancelled: false };
-                    const timer = setTimeout(() => {
-                        // O(1) cancellation - just mark as cancelled
-                        entry.cancelled = true;
-                        resolve();
-                    }, remaining);
-                    entry.resolve = () => {
-                        clearTimeout(timer);
-                        resolve();
-                    };
-                    this.writerQueue.push(entry);
-                });
-            }
-            this.writerWaiting--;
-            this.writer = true;
-            return this.createWriteGuard();
-        }
-        catch (e) {
-            this.writerWaiting--;
-            throw e;
-        }
-    }
-    /** Create write lock guard - extracted to avoid code duplication */
-    createWriteGuard() {
-        let released = false;
-        return {
-            release: () => {
-                if (released)
-                    return;
-                released = true;
-                this.writer = false;
-                // Notify waiting writers first (priority)
-                if (this.writerWaiting > 0) {
-                    // Skip cancelled entries
-                    let next = this.writerQueue.shift();
-                    while (next) {
-                        if (!next.cancelled) {
-                            next.resolve();
-                            return;
-                        }
-                        next = this.writerQueue.shift();
-                    }
-                }
-                // Then notify all waiting readers (skip cancelled)
-                const readers = this.readerQueue.splice(0);
-                for (const entry of readers) {
-                    if (!entry.cancelled) {
-                        entry.resolve();
-                    }
-                }
-            },
-        };
-    }
-    /** Get current state */
-    getState() {
-        return {
-            readers: this.readers,
-            writer: this.writer,
-            writerWaiting: this.writerWaiting,
-        };
-    }
-}
-/**
- * Execute with lock, ensuring release on error
- */
+/** Async lock facade and scoped execution helpers. */
+export { AsyncLock } from './asyncLock';
+export { LockTimeoutError } from './lockError';
+export { RWLock } from './rwLock';
+/** Execute with an exclusive lock and always release it. */
 export async function withLock(lock, fn, timeoutMs) {
     const guard = await lock.acquire(timeoutMs);
     try {
@@ -232,9 +12,7 @@ export async function withLock(lock, fn, timeoutMs) {
         guard.release();
     }
 }
-/**
- * Execute with read lock
- */
+/** Execute with a read lock and always release it. */
 export async function withReadLock(lock, fn, timeoutMs) {
     const guard = await lock.acquireRead(timeoutMs);
     try {
@@ -244,9 +22,7 @@ export async function withReadLock(lock, fn, timeoutMs) {
         guard.release();
     }
 }
-/**
- * Execute with write lock
- */
+/** Execute with a write lock and always release it. */
 export async function withWriteLock(lock, fn, timeoutMs) {
     const guard = await lock.acquireWrite(timeoutMs);
     try {

package/dist/shared/lockError.d.ts

@@ -0,0 +1,3 @@
+export declare class LockTimeoutError extends Error {
+    constructor(message?: string);
+}

package/dist/shared/lockError.js

@@ -0,0 +1,6 @@
+export class LockTimeoutError extends Error {
+    constructor(message = 'Lock acquisition timed out') {
+        super(message);
+        this.name = 'LockTimeoutError';
+    }
+}

package/dist/shared/lockTimeout.d.ts

@@ -0,0 +1,2 @@
+/** Default lock acquisition timeout shared by lock implementations. */
+export declare const DEFAULT_LOCK_TIMEOUT_MS: number;

package/dist/shared/lockTimeout.js

@@ -0,0 +1,2 @@
+/** Default lock acquisition timeout shared by lock implementations. */
+export const DEFAULT_LOCK_TIMEOUT_MS = parseInt(Bun.env.LOCK_TIMEOUT_MS ?? '5000', 10);

package/dist/shared/rwLock.d.ts

@@ -0,0 +1,22 @@
+/** Writer-priority read/write lock with FIFO writer handoff. */
+import type { LockGuard } from './types/lock';
+export declare class RWLock {
+    private readers;
+    private writer;
+    private writerWaiting;
+    private readonly readerQueue;
+    private readonly writerQueue;
+    acquireRead(timeoutMs?: number): Promise<LockGuard>;
+    acquireWrite(timeoutMs?: number): Promise<LockGuard>;
+    getState(): {
+        readers: number;
+        writer: boolean;
+        writerWaiting: number;
+    };
+    private createWaiter;
+    private drain;
+    private takeWriter;
+    private grantReaders;
+    private createReadGuard;
+    private createWriteGuard;
+}

package/dist/shared/rwLock.js

@@ -0,0 +1,124 @@
+/** Writer-priority read/write lock with FIFO writer handoff. */
+import { LockTimeoutError } from './lockError';
+import { DEFAULT_LOCK_TIMEOUT_MS } from './lockTimeout';
+export class RWLock {
+    readers = 0;
+    writer = false;
+    writerWaiting = 0;
+    readerQueue = [];
+    writerQueue = [];
+    acquireRead(timeoutMs = DEFAULT_LOCK_TIMEOUT_MS) {
+        if (!this.writer && this.writerWaiting === 0) {
+            this.readers++;
+            return Promise.resolve(this.createReadGuard());
+        }
+        if (timeoutMs <= 0) {
+            return Promise.reject(new LockTimeoutError('Read lock acquisition timed out'));
+        }
+        return new Promise((resolve, reject) => {
+            const waiter = this.createWaiter(resolve, reject, timeoutMs, () => {
+                waiter.reject(new LockTimeoutError('Read lock acquisition timed out'));
+                this.drain();
+            });
+            this.readerQueue.push(waiter);
+        });
+    }
+    acquireWrite(timeoutMs = DEFAULT_LOCK_TIMEOUT_MS) {
+        if (!this.writer && this.readers === 0 && this.writerWaiting === 0) {
+            this.writer = true;
+            return Promise.resolve(this.createWriteGuard());
+        }
+        if (timeoutMs <= 0) {
+            return Promise.reject(new LockTimeoutError('Write lock acquisition timed out'));
+        }
+        return new Promise((resolve, reject) => {
+            const waiter = this.createWaiter(resolve, reject, timeoutMs, () => {
+                this.writerWaiting--;
+                waiter.reject(new LockTimeoutError('Write lock acquisition timed out'));
+                this.drain();
+            });
+            this.writerWaiting++;
+            this.writerQueue.push(waiter);
+            this.drain();
+        });
+    }
+    getState() {
+        return { readers: this.readers, writer: this.writer, writerWaiting: this.writerWaiting };
+    }
+    createWaiter(resolve, reject, timeoutMs, onTimeout) {
+        const waiter = {
+            resolve,
+            reject,
+            settled: false,
+        };
+        waiter.timer = setTimeout(() => {
+            if (waiter.settled)
+                return;
+            waiter.settled = true;
+            onTimeout();
+        }, timeoutMs);
+        return waiter;
+    }
+    drain() {
+        if (this.writer)
+            return;
+        if (this.writerWaiting > 0) {
+            if (this.readers > 0)
+                return;
+            const waiter = this.takeWriter();
+            if (waiter) {
+                waiter.settled = true;
+                if (waiter.timer)
+                    clearTimeout(waiter.timer);
+                this.writerWaiting--;
+                this.writer = true;
+                waiter.resolve(this.createWriteGuard());
+                return;
+            }
+            this.writerWaiting = 0;
+        }
+        this.grantReaders();
+    }
+    takeWriter() {
+        let waiter = this.writerQueue.shift();
+        while (waiter?.settled)
+            waiter = this.writerQueue.shift();
+        return waiter;
+    }
+    grantReaders() {
+        const waiters = this.readerQueue.splice(0);
+        for (const waiter of waiters) {
+            if (waiter.settled)
+                continue;
+            waiter.settled = true;
+            if (waiter.timer)
+                clearTimeout(waiter.timer);
+            this.readers++;
+            waiter.resolve(this.createReadGuard());
+        }
+    }
+    createReadGuard() {
+        let released = false;
+        return {
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                this.readers--;
+                this.drain();
+            },
+        };
+    }
+    createWriteGuard() {
+        let released = false;
+        return {
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                this.writer = false;
+                this.drain();
+            },
+        };
+    }
+}

package/dist/shared/serialization.js

@@ -10,6 +10,7 @@ export function serializeJob(job) {
     return {
         id: job.id.toString(),
         queue: job.queue,
+        name: job.name,
         data: job.data,
         priority: job.priority,
         createdAt: job.createdAt,

package/dist/shared/skipList.d.ts

@@ -1,8 +1,3 @@
-/**
- * Skip List Implementation
- * Probabilistic data structure with O(log n) insert, delete, search
- * Ideal for sorted collections with frequent modifications
- */
 /**
  * Skip List with O(log n) operations
  * - insert: O(log n)

package/dist/shared/skipList.js

@@ -1,19 +1,4 @@
-/**
- * Skip List Implementation
- * Probabilistic data structure with O(log n) insert, delete, search
- * Ideal for sorted collections with frequent modifications
- */
-/** Sentinel node (head) */
-function createHead(maxLevel) {
-    const forward = [];
-    for (let i = 0; i <= maxLevel; i++) {
-        forward.push(null);
-    }
-    return {
-        value: null,
-        forward,
-    };
-}
+import { collectSkipRange, createSkipHead, iterateSkipValues, randomSkipLevel, removeMatchingSkipValues, } from './skipListNodes';
 /**
  * Skip List with O(log n) operations
  * - insert: O(log n)
@@ -43,7 +28,7 @@ export class SkipList {
         this.maxLevel = maxLevel;
         this.probability = probability;
         this.equals = equals;
-        this.head = createHead(maxLevel);
+        this.head = createSkipHead(maxLevel);
     }
     /** Current number of elements */
     get size() {
@@ -55,11 +40,7 @@ export class SkipList {
     }
     /** Generate random level for new node */
     randomLevel() {
-        let lvl = 0;
-        while (Math.random() < this.probability && lvl < this.maxLevel) {
-            lvl++;
-        }
-        return lvl;
+        return randomSkipLevel(this.probability, this.maxLevel);
     }
     /**
      * Insert value - O(log n)
@@ -226,15 +207,7 @@ export class SkipList {
      * @param limit Maximum number of results
      */
     rangeUntil(maxValue, limit) {
-        const result = [];
-        let current = this.head.forward[0];
-        while (current !== null && this.compare(current.value, maxValue) <= 0) {
-            result.push(current.value);
-            if (limit !== undefined && result.length >= limit)
-                break;
-            current = current.forward[0];
-        }
-        return result;
+        return collectSkipRange(this.head.forward[0], (value) => this.compare(value, maxValue) <= 0, limit);
     }
     /**
      * Get all values where predicate is true, starting from first
@@ -242,25 +215,13 @@ export class SkipList {
      * O(k) where k = matching results
      */
     takeWhile(predicate, limit) {
-        const result = [];
-        let current = this.head.forward[0];
-        while (current !== null && predicate(current.value)) {
-            result.push(current.value);
-            if (limit !== undefined && result.length >= limit)
-                break;
-            current = current.forward[0];
-        }
-        return result;
+        return collectSkipRange(this.head.forward[0], predicate, limit);
     }
     /**
      * Iterate all values in order
      */
     *values() {
-        let current = this.head.forward[0];
-        while (current !== null) {
-            yield current.value;
-            current = current.forward[0];
-        }
+        yield* iterateSkipValues(this.head.forward[0]);
     }
     /**
      * Convert to array
@@ -272,7 +233,7 @@ export class SkipList {
      * Clear all elements
      */
     clear() {
-        this.head = createHead(this.maxLevel);
+        this.head = createSkipHead(this.maxLevel);
         this.level = 0;
         this._size = 0;
     }
@@ -282,16 +243,8 @@ export class SkipList {
      * O(n) but removes in-place
      */
     removeAll(predicate) {
-        const removed = [];
-        let current = this.head.forward[0];
-        while (current !== null) {
-            const next = current.forward[0];
-            if (predicate(current.value)) {
-                removed.push(current.value);
-                this.delete(current.value);
-            }
-            current = next;
-        }
-        return removed;
+        return removeMatchingSkipValues(this.head.forward[0], predicate, (value) => {
+            this.delete(value);
+        });
     }
 }

package/dist/shared/skipListNodes.d.ts

@@ -0,0 +1,6 @@
+import type { SkipNode } from './types/skipList';
+export declare function randomSkipLevel(probability: number, maxLevel: number): number;
+export declare function createSkipHead<T>(maxLevel: number): SkipNode<T>;
+export declare function collectSkipRange<T>(first: SkipNode<T> | null, predicate: (value: T) => boolean, limit?: number): T[];
+export declare function iterateSkipValues<T>(first: SkipNode<T> | null): Generator<T>;
+export declare function removeMatchingSkipValues<T>(first: SkipNode<T> | null, predicate: (value: T) => boolean, remove: (value: T) => void): T[];