bunqueue 2.8.54 → 2.8.57

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

@@ -19,8 +19,12 @@ export declare class WorkerRateLimiter {
      * O(1) amortized — advances head pointer past expired tokens.
      */
     canProcessWithinLimit(): boolean;
-    /** Record a job completion for rate limiting. */
+    /** Atomically reserve one start in the current window. */
+    tryAcquire(): boolean;
+    /** Record a synthetic start, retained for diagnostics and focused unit tests. */
     recordJobForLimiter(): void;
+    /** Number of starts that can be admitted without waiting. */
+    getAvailableSlots(): number;
     /**
      * Get time until rate limiter allows next job (ms).
      * Returns 0 if not rate limited.

package/dist/client/worker/workerRateLimiter.js

@@ -13,6 +13,13 @@ export class WorkerRateLimiter {
     rateLimitExpiration = 0;
     constructor(limiter) {
         this.limiter = limiter;
+        if (limiter &&
+            (!Number.isInteger(limiter.max) ||
+                limiter.max <= 0 ||
+                !Number.isFinite(limiter.duration) ||
+                limiter.duration <= 0)) {
+            throw new RangeError('Worker limiter max and duration must be positive finite values');
+        }
     }
     /**
      * Check if rate limiter allows processing another job.
@@ -20,35 +27,54 @@ export class WorkerRateLimiter {
      * O(1) amortized — advances head pointer past expired tokens.
      */
     canProcessWithinLimit() {
+        return this.getAvailableSlots() > 0;
+    }
+    /** Atomically reserve one start in the current window. */
+    tryAcquire() {
+        const now = Date.now();
+        if (now < this.rateLimitExpiration)
+            return false;
         if (!this.limiter)
             return true;
-        const windowStart = Date.now() - this.limiter.duration;
+        const windowStart = now - this.limiter.duration;
         this.evictExpired(windowStart);
-        return this.activeCount() < this.limiter.max;
+        if (this.activeCount() >= this.limiter.max)
+            return false;
+        this.limiterTokens.push(now);
+        return true;
     }
-    /** Record a job completion for rate limiting. */
+    /** Record a synthetic start, retained for diagnostics and focused unit tests. */
     recordJobForLimiter() {
         if (!this.limiter)
             return;
         this.limiterTokens.push(Date.now());
     }
+    /** Number of starts that can be admitted without waiting. */
+    getAvailableSlots() {
+        const now = Date.now();
+        if (now < this.rateLimitExpiration)
+            return 0;
+        if (!this.limiter)
+            return Number.POSITIVE_INFINITY;
+        this.evictExpired(now - this.limiter.duration);
+        return Math.max(0, this.limiter.max - this.activeCount());
+    }
     /**
      * Get time until rate limiter allows next job (ms).
      * Returns 0 if not rate limited.
      * O(1) — oldest active token is at this.limiterTokens[this.head].
      */
     getTimeUntilNextSlot() {
-        if (!this.limiter)
-            return 0;
         const now = Date.now();
-        const windowStart = now - this.limiter.duration;
-        this.evictExpired(windowStart);
-        if (this.activeCount() < this.limiter.max) {
-            return 0;
-        }
-        // Oldest active token is at head — no need for Math.min(...spread)
+        const overrideWait = Math.max(0, this.rateLimitExpiration - now);
+        if (!this.limiter)
+            return overrideWait;
+        this.evictExpired(now - this.limiter.duration);
+        if (this.activeCount() < this.limiter.max)
+            return overrideWait;
         const oldestToken = this.limiterTokens[this.head];
-        return oldestToken + this.limiter.duration - now;
+        const windowWait = Math.max(0, oldestToken + this.limiter.duration - now);
+        return Math.max(overrideWait, windowWait);
     }
     /** Get rate limiter info (for debugging/monitoring). */
     getRateLimiterInfo() {
@@ -67,15 +93,9 @@ export class WorkerRateLimiter {
      * The worker will not process jobs until the rate limit expires.
      */
     rateLimit(expireTimeMs) {
-        if (expireTimeMs <= 0)
+        if (!Number.isFinite(expireTimeMs) || expireTimeMs <= 0)
             return;
-        if (this.limiter) {
-            const now = Date.now();
-            for (let i = 0; i < this.limiter.max; i++) {
-                this.limiterTokens.push(now + expireTimeMs - this.limiter.duration);
-            }
-        }
-        this.rateLimitExpiration = Date.now() + expireTimeMs;
+        this.rateLimitExpiration = Math.max(this.rateLimitExpiration, Date.now() + expireTimeMs);
     }
     /** Check if worker is currently rate limited. */
     isRateLimited() {

package/dist/client/worker.d.ts

@@ -3,3 +3,4 @@
  * @deprecated Import from './worker' instead
  */
 export { Worker } from './worker/worker';
+export type { ManualJob } from './worker/types';

package/dist/client/workflow/compensationChild.d.ts

@@ -1,4 +1,5 @@
 /** Nested-saga compensation. */
+import type { LostCompensationClaim } from './compensationClaim';
 import type { WorkflowEmitter } from './emitter';
 import type { WorkflowStore } from './store';
 import type { Execution, StepRecord } from './types';
@@ -11,7 +12,7 @@ export interface ChildUnwindRequest {
     workflows?: Map<string, Workflow>;
     retryFailed?: boolean;
 }
-export type ChildUnwind = (request: ChildUnwindRequest) => Promise<'ran' | 'claim-lost'>;
+export type ChildUnwind = (request: ChildUnwindRequest) => Promise<'ran' | LostCompensationClaim>;
 export interface UnwindChildRequest {
     record: StepRecord;
     store: WorkflowStore;

package/dist/client/workflow/compensationChild.js

@@ -30,7 +30,7 @@ export async function unwindChild(request) {
         workflows,
         retryFailed,
     });
-    if (outcome === 'claim-lost') {
+    if (outcome !== 'ran') {
         throw new Error(`child "${child.workflowName}" (${childId}) is being rolled back by another driver; ` +
             'outcome unknown');
     }

package/dist/client/workflow/compensationClaim.d.ts

@@ -0,0 +1,11 @@
+/** Process-local ownership for one workflow unwind. */
+export interface AcquiredCompensationClaim {
+    readonly kind: 'acquired';
+    release(): void;
+}
+export interface LostCompensationClaim {
+    readonly kind: 'claim-lost';
+    readonly sameOwner: boolean;
+    readonly settled: Promise<void>;
+}
+export declare function acquireCompensationClaim(executionId: string, owner: object): AcquiredCompensationClaim | LostCompensationClaim;

package/dist/client/workflow/compensationClaim.js

@@ -0,0 +1,30 @@
+/** Process-local ownership for one workflow unwind. */
+const active = new Map();
+export function acquireCompensationClaim(executionId, owner) {
+    const current = active.get(executionId);
+    if (current) {
+        return {
+            kind: 'claim-lost',
+            sameOwner: current.owner === owner,
+            settled: current.settled,
+        };
+    }
+    let resolveFinished = () => undefined;
+    const settled = new Promise((resolve) => {
+        resolveFinished = resolve;
+    });
+    const claim = { owner, settled, finish: resolveFinished };
+    active.set(executionId, claim);
+    let released = false;
+    return {
+        kind: 'acquired',
+        release() {
+            if (released)
+                return;
+            released = true;
+            if (active.get(executionId) === claim)
+                active.delete(executionId);
+            claim.finish();
+        },
+    };
+}

package/dist/client/workflow/compensator.d.ts

@@ -5,6 +5,7 @@
  * from overlapping in-process drivers. The execution mechanics live in
  * compensationPass.ts; record selection lives in compensationSupport.ts.
  */
+import type { LostCompensationClaim } from './compensationClaim';
 import type { WorkflowEmitter } from './emitter';
 import type { WorkflowStore } from './store';
 import type { Execution } from './types';
@@ -15,8 +16,12 @@ export declare class WaitForSignalError extends Error {
     readonly event: string;
     constructor(event: string);
 }
-/** `claim-lost` means another local driver owns the unwind and this call did nothing. */
-export type UnwindOutcome = 'ran' | 'claim-lost';
+/**
+ * This is not a distributed lock. It prevents two local recovery/operator paths from
+ * reading the same unsettled snapshot and issuing the same reversal twice. A losing
+ * recovery path receives the current owner's completion latch and can retry safely.
+ */
+export type UnwindOutcome = 'ran' | LostCompensationClaim;
 /** Run compensation handlers in reverse start order for every eligible step. */
 export declare function runCompensation(exec: Execution, wf: Workflow, store: WorkflowStore, emitter: WorkflowEmitter | null, workflows?: Map<string, Workflow>, opts?: {
     retryFailed?: boolean;

package/dist/client/workflow/compensator.js

@@ -7,6 +7,7 @@
  */
 import { unwind } from './compensationPass';
 import { AbandonedCompensationError } from './compensationChild';
+import { acquireCompensationClaim } from './compensationClaim';
 import { settle, unwindSet } from './compensationSupport';
 import { owesOutcome } from './unwindPlan';
 export { AbandonedCompensationError, CommittedChildError } from './compensationChild';
@@ -18,13 +19,6 @@ export class WaitForSignalError extends Error {
         this.event = event;
     }
 }
-/**
- * Executions with an unwind in flight in this process.
- *
- * This is not a distributed lock. It prevents two local recovery/operator paths from
- * reading the same unsettled snapshot and issuing the same reversal twice.
- */
-const inFlight = new Set();
 /** Run compensation handlers in reverse start order for every eligible step. */
 // biome-ignore lint/complexity/useMaxParams: registry and operator retry are independent inputs
 export async function runCompensation(exec, wf, store, emitter, workflows, opts = {}) {
@@ -41,14 +35,14 @@ export async function runCompensation(exec, wf, store, emitter, workflows, opts
         store.update(exec);
         return 'ran';
     }
-    if (inFlight.has(exec.id))
-        return 'claim-lost';
-    inFlight.add(exec.id);
+    const claim = acquireCompensationClaim(exec.id, store);
+    if (claim.kind === 'claim-lost')
+        return claim;
     try {
         await unwind({ exec, wf, store, emitter, eligible, workflows, ...opts }, ({ exec, workflow, store, emitter, workflows, retryFailed }) => runCompensation(exec, workflow, store, emitter, workflows, { retryFailed }));
     }
     finally {
-        inFlight.delete(exec.id);
+        claim.release();
     }
     return 'ran';
 }

package/dist/client/workflow/recovery.js

@@ -51,14 +51,37 @@ export async function recoverExecutions(deps) {
             // recoverable until runCompensation writes an explicit rollbackStatus.
             // A lost claim means another driver owns this unwind, so nothing happened here
             // and counting it as a recovery would overstate what recover() did.
-            const outcome = await runCompensation(exec, wf, store, deps.emitter, deps.workflows);
-            if (outcome === 'ran')
+            if (await recoverCompensation(exec.id, wf, deps))
                 result.compensating++;
         }
     }
     result.total = result.running + result.waiting + result.compensating;
     return result;
 }
+async function recoverCompensation(executionId, wf, deps) {
+    while (true) {
+        const exec = deps.store.get(executionId);
+        if (!exec ||
+            (exec.state !== 'compensating' &&
+                !(exec.state === 'failed' && exec.rollbackStatus === undefined))) {
+            return false;
+        }
+        bindExecutionDefinition(exec, wf, (value) => deps.store.update(value));
+        const outcome = await runCompensation(exec, wf, deps.store, deps.emitter, deps.workflows);
+        if (outcome === 'ran')
+            return true;
+        // A live unwind owned by this executor's store is not orphaned. Waiting here
+        // would deadlock callers that deliberately hold the handler open until recover()
+        // returns, and it would make a health-time recovery call wait for user code.
+        if (outcome.sameOwner)
+            return false;
+        // A force-closed Engine can leave its JavaScript compensation handler alive
+        // briefly after its store is closed. A replacement Engine has a different store
+        // identity, so it waits for that owner, then re-reads the durable row: it may have
+        // finished, or this engine must resume the owed unwind.
+        await outcome.settled;
+    }
+}
 async function enqueueExecution(exec, queue) {
     const jobData = {
         executionId: exec.id,

package/dist/client/workflow/rollbackControl.js

@@ -27,7 +27,7 @@ import { abandonCompensation, runCompensation } from './compensator';
 export async function resumeCompensation(deps, executionId) {
     const { exec, wf } = parked(deps, executionId);
     const outcome = await runCompensation(exec, wf, deps.store, deps.emitter, deps.workflows, { retryFailed: true });
-    if (outcome === 'claim-lost') {
+    if (outcome !== 'ran') {
         // Nothing was mutated: `runCompensation` returns this before the unwind begins.
         throw new Error(`execution "${executionId}" is already being rolled back by another driver`);
     }

package/dist/domain/job/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const DEFAULT_MAX_BACKOFF = 3600000;
+export declare const MAX_TIMELINE_ENTRIES = 20;
+export declare const DEFAULT_LOCK_TTL = 30000;
+export declare const JOB_DEFAULTS: {
+    readonly priority: 0;
+    readonly maxAttempts: 3;
+    readonly backoff: 1000;
+    readonly lifo: false;
+    readonly removeOnComplete: false;
+    readonly removeOnFail: false;
+    readonly stackTraceLimit: 10;
+};

package/dist/domain/job/constants.js

@@ -0,0 +1,12 @@
+export const DEFAULT_MAX_BACKOFF = 3_600_000;
+export const MAX_TIMELINE_ENTRIES = 20;
+export const DEFAULT_LOCK_TTL = 30_000;
+export const JOB_DEFAULTS = {
+    priority: 0,
+    maxAttempts: 3,
+    backoff: 1000,
+    lifo: false,
+    removeOnComplete: false,
+    removeOnFail: false,
+    stackTraceLimit: 10,
+};

package/dist/domain/job/create.d.ts

@@ -0,0 +1,2 @@
+import type { Job, JobId, JobInput } from '../types/jobs/model';
+export declare function createJob(id: JobId, queue: string, input: JobInput, now?: number): Job;

package/dist/domain/job/create.js

@@ -0,0 +1,103 @@
+import { JOB_DEFAULTS } from './constants';
+import { normalizeJobPayload } from './payload';
+function parseBackoff(input) {
+    if (typeof input === 'object') {
+        return {
+            backoff: input.delay,
+            backoffConfig: { type: input.type, delay: input.delay },
+        };
+    }
+    return { backoff: input ?? JOB_DEFAULTS.backoff, backoffConfig: null };
+}
+function parseRepeatConfig(repeat) {
+    if (!repeat)
+        return null;
+    return {
+        every: repeat.every,
+        limit: repeat.limit,
+        pattern: repeat.pattern,
+        count: repeat.count ?? 0,
+        startDate: repeat.startDate,
+        endDate: repeat.endDate,
+        tz: repeat.tz,
+        immediately: repeat.immediately,
+        prevMillis: repeat.prevMillis,
+        offset: repeat.offset,
+        jobId: repeat.jobId,
+    };
+}
+function toBoolean(value, fallback) {
+    return value === undefined ? fallback : Boolean(value);
+}
+function parseCoreOptions(input) {
+    return {
+        priority: input.priority ?? JOB_DEFAULTS.priority,
+        lifo: input.lifo ?? JOB_DEFAULTS.lifo,
+        maxAttempts: input.maxAttempts ?? JOB_DEFAULTS.maxAttempts,
+        removeOnComplete: toBoolean(input.removeOnComplete, JOB_DEFAULTS.removeOnComplete),
+        removeOnFail: toBoolean(input.removeOnFail, JOB_DEFAULTS.removeOnFail),
+    };
+}
+function parseOptionalFields(input) {
+    return {
+        ttl: input.ttl ?? null,
+        timeout: input.timeout ?? null,
+        uniqueKey: input.uniqueKey ?? null,
+        customId: input.customId ?? null,
+        parentId: input.parentId ?? null,
+        groupId: input.groupId ?? null,
+        stallTimeout: input.stallTimeout ?? null,
+    };
+}
+function parseBullMQV5Options(input) {
+    return {
+        stackTraceLimit: input.stackTraceLimit ?? JOB_DEFAULTS.stackTraceLimit,
+        keepLogs: input.keepLogs ?? null,
+        sizeLimit: input.sizeLimit ?? null,
+        failParentOnFailure: input.failParentOnFailure ?? false,
+        removeDependencyOnFailure: input.removeDependencyOnFailure ?? false,
+        continueParentOnFailure: input.continueParentOnFailure ?? false,
+        ignoreDependencyOnFailure: input.ignoreDependencyOnFailure ?? false,
+        deduplicationTtl: input.dedup?.ttl ?? null,
+        deduplicationExtend: input.dedup?.extend ?? false,
+        deduplicationReplace: input.dedup?.replace ?? false,
+        debounceId: input.debounceId ?? null,
+        debounceTtl: input.debounceTtl ?? null,
+    };
+}
+export function createJob(id, queue, input, now = Date.now()) {
+    const { backoff, backoffConfig } = parseBackoff(input.backoff);
+    const coreOpts = parseCoreOptions(input);
+    const optionalFields = parseOptionalFields(input);
+    const v5Opts = parseBullMQV5Options(input);
+    const createdAt = input.timestamp ?? now;
+    const payload = normalizeJobPayload(input);
+    return {
+        id,
+        queue,
+        name: payload.name,
+        data: payload.data,
+        createdAt,
+        runAt: createdAt + (input.delay ?? 0),
+        startedAt: null,
+        completedAt: null,
+        attempts: 0,
+        backoff,
+        backoffConfig,
+        dependsOn: input.dependsOn ?? [],
+        childrenIds: input.childrenIds ?? [],
+        childrenCompleted: 0,
+        tags: input.tags ?? [],
+        progress: 0,
+        progressMessage: null,
+        stacktrace: null,
+        repeat: parseRepeatConfig(input.repeat),
+        durable: input.durable ?? false,
+        lastHeartbeat: createdAt,
+        stallCount: 0,
+        ...coreOpts,
+        ...optionalFields,
+        ...v5Opts,
+        timeline: [],
+    };
+}

package/dist/domain/job/ids.d.ts

@@ -0,0 +1,5 @@
+import type { JobId, LockToken } from '../types/jobs/model';
+export declare function jobId(id: string): JobId;
+export declare function generateJobId(): JobId;
+export declare function lockToken(token: string): LockToken;
+export declare function generateLockToken(): LockToken;

package/dist/domain/job/ids.js

@@ -0,0 +1,12 @@
+export function jobId(id) {
+    return id;
+}
+export function generateJobId() {
+    return Bun.randomUUIDv7();
+}
+export function lockToken(token) {
+    return token;
+}
+export function generateLockToken() {
+    return Bun.randomUUIDv7();
+}

package/dist/domain/job/locks.d.ts

@@ -0,0 +1,4 @@
+import type { JobId, JobLock } from '../types/jobs/model';
+export declare function createJobLock(jobId: JobId, owner: string, ttl?: number, now?: number): JobLock;
+export declare function isLockExpired(lock: JobLock, now?: number): boolean;
+export declare function renewLock(lock: JobLock, newTtl?: number, now?: number): void;

package/dist/domain/job/locks.js

@@ -0,0 +1,23 @@
+import { DEFAULT_LOCK_TTL } from './constants';
+import { generateLockToken } from './ids';
+export function createJobLock(jobId, owner, ttl = DEFAULT_LOCK_TTL, now = Date.now()) {
+    return {
+        jobId,
+        token: generateLockToken(),
+        owner,
+        createdAt: now,
+        expiresAt: now + ttl,
+        lastRenewalAt: now,
+        renewalCount: 0,
+        ttl,
+    };
+}
+export function isLockExpired(lock, now = Date.now()) {
+    return now >= lock.expiresAt;
+}
+export function renewLock(lock, newTtl, now = Date.now()) {
+    const ttl = newTtl ?? lock.ttl;
+    lock.expiresAt = now + ttl;
+    lock.lastRenewalAt = now;
+    lock.renewalCount++;
+}

package/dist/domain/job/payload.d.ts

@@ -0,0 +1,18 @@
+export interface JobPayloadSource {
+    readonly name?: unknown;
+    readonly data: unknown;
+}
+export interface NormalizedJobPayload {
+    readonly name: string;
+    readonly data: unknown;
+    readonly legacy: boolean;
+}
+/** Return the stable public validation error for an invalid job name. */
+export declare function validateJobName(name: unknown): string | null;
+/**
+ * Resolve a modern payload. A missing explicit name defaults without inspecting
+ * `data`, so direct QueueManager callers can use `data.name` as an ordinary key.
+ */
+export declare function normalizeJobPayload(source: JobPayloadSource, fallback?: string): NormalizedJobPayload;
+/** Decode a pre-2.8.56 wire or persistence envelope at a known legacy boundary. */
+export declare function normalizeLegacyJobPayload(source: JobPayloadSource, fallback?: string): NormalizedJobPayload;

package/dist/domain/job/payload.js

@@ -0,0 +1,43 @@
+const DEFAULT_JOB_NAME = 'default';
+const MAX_JOB_NAME_LENGTH = 256;
+function legacyEnvelope(data) {
+    if (typeof data !== 'object' || data === null || Array.isArray(data))
+        return null;
+    const record = data;
+    if (typeof record.name !== 'string')
+        return null;
+    const { name, ...userData } = record;
+    return { name, data: userData };
+}
+/** Return the stable public validation error for an invalid job name. */
+export function validateJobName(name) {
+    if (typeof name !== 'string' || name.length === 0 || name.length > MAX_JOB_NAME_LENGTH) {
+        return 'Job name must be a non-empty string of at most 256 characters';
+    }
+    return null;
+}
+function checkedName(name) {
+    const error = validateJobName(name);
+    if (error)
+        throw new Error(error);
+    return name;
+}
+/**
+ * Resolve a modern payload. A missing explicit name defaults without inspecting
+ * `data`, so direct QueueManager callers can use `data.name` as an ordinary key.
+ */
+export function normalizeJobPayload(source, fallback = DEFAULT_JOB_NAME) {
+    if (source.name !== undefined) {
+        return { name: checkedName(source.name), data: source.data, legacy: false };
+    }
+    return { name: checkedName(fallback), data: source.data, legacy: false };
+}
+/** Decode a pre-2.8.56 wire or persistence envelope at a known legacy boundary. */
+export function normalizeLegacyJobPayload(source, fallback = DEFAULT_JOB_NAME) {
+    if (source.name !== undefined)
+        return normalizeJobPayload(source, fallback);
+    const legacy = legacyEnvelope(source.data);
+    if (legacy)
+        return { name: checkedName(legacy.name), data: legacy.data, legacy: true };
+    return { name: checkedName(fallback), data: source.data, legacy: false };
+}

package/dist/domain/job/state.d.ts

@@ -0,0 +1,8 @@
+import type { Job } from '../types/jobs/model';
+export declare function normalizeStacktrace(lines: readonly unknown[] | undefined, limit: number): string[] | null;
+export declare function isDelayed(job: Job, now?: number): boolean;
+export declare function isReady(job: Job, now?: number): boolean;
+export declare function isExpired(job: Job, now?: number): boolean;
+export declare function isTimedOut(job: Job, now?: number): boolean;
+export declare function calculateBackoff(job: Job): number;
+export declare function canRetry(job: Job): boolean;

package/dist/domain/job/state.js

@@ -0,0 +1,51 @@
+import { DEFAULT_MAX_BACKOFF } from './constants';
+export function normalizeStacktrace(lines, limit) {
+    if (!lines || lines.length === 0)
+        return null;
+    const out = [];
+    for (const line of lines) {
+        if (out.length >= limit)
+            break;
+        if (typeof line !== 'string')
+            continue;
+        const trimmed = line.trim();
+        if (trimmed)
+            out.push(trimmed);
+    }
+    return out.length > 0 ? out : null;
+}
+export function isDelayed(job, now = Date.now()) {
+    return job.runAt > now;
+}
+export function isReady(job, now = Date.now()) {
+    return job.runAt <= now;
+}
+export function isExpired(job, now = Date.now()) {
+    if (job.ttl === null)
+        return false;
+    return now > job.createdAt + job.ttl;
+}
+export function isTimedOut(job, now = Date.now()) {
+    if (job.timeout === null || job.startedAt === null)
+        return false;
+    return now > job.startedAt + job.timeout;
+}
+export function calculateBackoff(job) {
+    const maxDelay = job.backoffConfig?.maxDelay ?? DEFAULT_MAX_BACKOFF;
+    if (job.backoffConfig) {
+        if (job.backoffConfig.type === 'fixed') {
+            const base = job.backoffConfig.delay;
+            const jittered = base * (0.8 + Math.random() * 0.4);
+            return Math.min(jittered, maxDelay);
+        }
+        const base = job.backoffConfig.delay * Math.pow(2, job.attempts);
+        const jittered = base * (0.5 + Math.random());
+        return Math.min(jittered, maxDelay);
+    }
+    const base = job.backoff * Math.pow(2, job.attempts);
+    const jittered = base * (0.5 + Math.random());
+    return Math.min(jittered, maxDelay);
+}
+export function canRetry(job) {
+    return job.attempts < job.maxAttempts;
+}

package/dist/domain/job/terminal.d.ts

@@ -0,0 +1,3 @@
+import type { Job } from '../types/job';
+/** Return the most recent persisted processor failure for a job. */
+export declare function lastFailedReason(job: Pick<Job, 'timeline'>): string | undefined;

package/dist/domain/job/terminal.js

@@ -0,0 +1,9 @@
+/** Return the most recent persisted processor failure for a job. */
+export function lastFailedReason(job) {
+    for (let index = job.timeline.length - 1; index >= 0; index--) {
+        const entry = job.timeline[index];
+        if (entry.state === 'failed' && entry.error)
+            return entry.error;
+    }
+    return undefined;
+}

package/dist/domain/queue/dlqShard.d.ts

@@ -9,6 +9,7 @@ import type { StallConfig } from '../types/stall';
 export interface DlqStatsCallback {
     incrementDlq(): void;
     decrementDlq(count?: number): void;
+    onEvict?(entry: DlqEntry): void;
 }
 /**
  * Manages Dead Letter Queue operations for a shard
@@ -57,4 +58,5 @@ export declare class DlqShard {
     getQueueNames(): string[];
     /** Delete queue data */
     deleteQueue(queue: string): number;
+    private evictUntil;
 }