@zudojs/queue 0.1.0 → 1.0.0

package/dist/inMemoryQueue/inMemoryQueue.core.js

@@ -1,12 +1,24 @@
-import { randomBytes } from "node:crypto";
-import { QueueError, QueueClosedError, QueueDisposedError, JobDuplicateError, } from "@zudojs/errors";
-import { createJob } from "../job/job.core.js";
+import { randomUUID } from "node:crypto";
+import { QueueError, QueueDisposedError, JobDuplicateError, JobSerializationError, JobStalledError, } from "@zudojs/errors";
+import { assertProcessor } from "../processor/processor.type.js";
+import { createJob, updateJobState } from "../job/job.core.js";
 import { JobState as JobStateEnum, createJobName, } from "../jobTypes/jobTypes.type.js";
 import { JsonSerializer } from "../serializer/serializer.core.js";
 import { createInMemoryDeadLetterStore } from "../deadLetter/deadLetter.core.js";
 import { createNoopQueueEventEmitter } from "../queueEmitter/queueEmitter.core.js";
 import { processJob } from "./inMemoryQueue.processing.js";
-import { scheduleJob, scheduleDelayedJobs, } from "./inMemoryQueue.scheduling.js";
+import { scheduleJob, promoteDueScheduledJobs, } from "./inMemoryQueue.scheduling.js";
+/** Terminal states a job never leaves. */
+const TERMINAL_STATES = new Set([
+    JobStateEnum.COMPLETED,
+    JobStateEnum.FAILED,
+    JobStateEnum.DEAD_LETTER,
+    JobStateEnum.CANCELLED,
+]);
+/** Retained terminal jobs per outcome when no retention is configured. */
+const DEFAULT_RETAINED_JOBS = 1_000;
+/** How long `close()` waits for in-flight jobs before aborting them. */
+const DEFAULT_CLOSE_TIMEOUT_MS = 30_000;
 /**
  * In-memory queue implementation.
  *
@@ -25,12 +37,21 @@ export class InMemoryQueue {
     activeCount = 0;
     pollTimer = null;
     scheduledTimers = new Map();
+    retryTimers = new Map();
+    inFlight = new Map();
+    settledOrder = [];
+    /** How many times each job has been reclaimed after stalling. */
+    stalledCounts = new Map();
     deduplicationIndex = new Map();
-    deadLetterStore = createInMemoryDeadLetterStore();
-    processedCount = 0;
-    succeededCount = 0;
-    failedCount = 0;
+    deadLetterStore;
     emitter;
+    counters = {
+        processedCount: 0,
+        succeededCount: 0,
+        failedCount: 0,
+        retriedCount: 0,
+        deadLetteredCount: 0,
+    };
     emptySince = 0;
     backoffMs = 50;
     constructor(name, options) {
@@ -39,14 +60,20 @@ export class InMemoryQueue {
         this.serializer = this.options.serializer ?? JsonSerializer;
         this.middleware = this.options.middleware ?? [];
         this.emitter = options?.eventEmitter ?? createNoopQueueEventEmitter();
+        this.deadLetterStore =
+            this.options.deadLetterStore ?? createInMemoryDeadLetterStore();
     }
     async add(jobName, data, options) {
         if (this.disposed)
             throw new QueueDisposedError(this.name);
-        if (this.paused)
+        // Pausing conventionally stops consumption; whether it also stops
+        // production is a policy choice, so it is configurable and defaults
+        // to rejecting adds for backwards compatibility.
+        if (this.paused && (this.options.pauseRejectsAdd ?? true)) {
             throw new QueueError(`Queue "${this.name}" is paused.`, {
                 queueName: this.name,
             });
+        }
         const mergedOptions = { ...this.options.defaultJobOptions, ...options };
         if (mergedOptions.deduplicationKey) {
             const existing = this.deduplicationIndex.get(mergedOptions.deduplicationKey);
@@ -56,11 +83,16 @@ export class InMemoryQueue {
                 });
             }
         }
-        const jobId = `job_${Date.now()}_${randomBytes(6).toString("hex")}`;
+        const jobId = this.createJobId();
+        // Round-tripping through the configured serializer keeps the option
+        // honest, isolates the stored payload from later caller mutation, and
+        // surfaces a non-serializable payload here rather than after a broker
+        // adapter is swapped in.
+        const payload = this.encodePayload(jobId, data);
         const job = createJob({
             name: createJobName(jobName),
             queueName: this.name,
-            data,
+            data: payload,
             options: mergedOptions,
         }, jobId);
         this.jobs.set(jobId, job);
@@ -78,6 +110,7 @@ export class InMemoryQueue {
     process(name, processor) {
         if (this.disposed)
             throw new QueueDisposedError(this.name);
+        assertProcessor(processor, name);
         this.processors.set(name, processor);
         if (!this.pollTimer)
             this.startPolling();
@@ -85,86 +118,239 @@ export class InMemoryQueue {
     async getJob(jobId) {
         return this.jobs.get(jobId) ?? null;
     }
+    /**
+     * Returns the job that would be processed next without claiming it.
+     *
+     * This is a read-only peek. Consumers that intend to run the job must
+     * use {@link claimNextJob}, which transitions it to `active` so no
+     * other consumer can pick up the same job.
+     */
     async getNextJob() {
         if (this.paused || this.disposed)
             return null;
-        const now = Date.now();
-        let nextJob = null;
-        let nextPriority = -1;
-        for (const job of this.jobs.values()) {
-            if (job.state !== JobStateEnum.WAITING)
-                continue;
-            if (job.scheduledAt && new Date(job.scheduledAt).getTime() > now)
-                continue;
-            if (job.priority > nextPriority) {
-                nextPriority = job.priority;
-                nextJob = job;
-            }
-            else if (job.priority === nextPriority && nextJob) {
-                const currentTime = new Date(job.createdAt).getTime();
-                const nextTime = new Date(nextJob.createdAt).getTime();
-                if (currentTime < nextTime)
-                    nextJob = job;
-            }
+        return this.selectJob();
+    }
+    /**
+     * Atomically selects the next runnable job and marks it `active`.
+     *
+     * Claiming is what prevents two consumers — or one consumer polling in
+     * a loop — from processing the same job repeatedly.
+     */
+    async claimNextJob() {
+        if (this.paused || this.disposed)
+            return null;
+        const job = this.selectJob((candidate) => this.processors.has(candidate.name));
+        if (!job)
+            return null;
+        const claimed = updateJobState(job, JobStateEnum.ACTIVE, {
+            startedAt: new Date().toISOString(),
+        });
+        this.jobs.set(claimed.id, claimed);
+        return claimed;
+    }
+    /**
+     * Returns a claimed job to the waiting pool.
+     */
+    async releaseJob(jobId) {
+        const job = this.jobs.get(jobId);
+        if (!job || job.state !== JobStateEnum.ACTIVE) {
+            return false;
         }
-        return nextJob;
+        this.jobs.set(jobId, updateJobState(job, JobStateEnum.WAITING, { startedAt: undefined }));
+        return true;
     }
     getProcessor(name) {
         return this.processors.get(name);
     }
     async getStats() {
-        const allJobs = Array.from(this.jobs.values());
+        let waiting = 0;
+        let active = 0;
+        let completed = 0;
+        let failed = 0;
+        let delayed = 0;
+        let retrying = 0;
+        for (const job of this.jobs.values()) {
+            switch (job.state) {
+                case JobStateEnum.WAITING:
+                    waiting++;
+                    break;
+                case JobStateEnum.ACTIVE:
+                    active++;
+                    break;
+                case JobStateEnum.COMPLETED:
+                    completed++;
+                    break;
+                case JobStateEnum.FAILED:
+                case JobStateEnum.DEAD_LETTER:
+                    failed++;
+                    break;
+                case JobStateEnum.SCHEDULED:
+                    delayed++;
+                    break;
+                case JobStateEnum.RETRYING:
+                    retrying++;
+                    break;
+                default:
+                    break;
+            }
+        }
         return {
-            waiting: allJobs.filter((j) => j.state === JobStateEnum.WAITING).length,
-            active: allJobs.filter((j) => j.state === JobStateEnum.ACTIVE).length,
-            completed: allJobs.filter((j) => j.state === JobStateEnum.COMPLETED)
-                .length,
-            failed: allJobs.filter((j) => j.state === JobStateEnum.FAILED ||
-                j.state === JobStateEnum.DEAD_LETTER).length,
-            delayed: allJobs.filter((j) => j.state === JobStateEnum.SCHEDULED).length,
-            retrying: allJobs.filter((j) => j.state === JobStateEnum.RETRYING).length,
+            waiting,
+            active,
+            completed,
+            failed,
+            delayed,
+            retrying,
+            processed: this.counters.processedCount,
+            succeeded: this.counters.succeededCount,
+            errored: this.counters.failedCount,
+            retried: this.counters.retriedCount,
+            deadLettered: this.counters.deadLetteredCount,
         };
     }
+    /**
+     * Returns the jobs that exhausted their attempts.
+     */
+    async getDeadLetterJobs() {
+        return this.deadLetterStore.getAll();
+    }
     async pause() {
         this.paused = true;
     }
     async resume() {
+        if (this.disposed)
+            throw new QueueDisposedError(this.name);
         this.paused = false;
+        this.backoffMs = 50;
+        this.emptySince = 0;
+        if (!this.pollTimer && this.processors.size > 0)
+            this.startPolling();
     }
     isPaused() {
         return this.paused;
     }
+    isDisposed() {
+        return this.disposed;
+    }
+    /**
+     * Closes the queue, draining in-flight jobs first.
+     *
+     * Nothing is torn down until running jobs have settled, so a job can
+     * never write back into a cleared queue. Jobs that outlast
+     * `closeTimeout` have their `AbortSignal` aborted and are then
+     * abandoned so shutdown cannot hang indefinitely.
+     */
     async close() {
+        if (this.disposed)
+            return;
+        // Stop accepting and dispatching work before draining, so the set of
+        // in-flight jobs cannot grow while we wait for it.
+        this.disposed = true;
         this.stopPolling();
         for (const timer of this.scheduledTimers.values())
             clearTimeout(timer);
         this.scheduledTimers.clear();
+        for (const timer of this.retryTimers.values())
+            clearTimeout(timer);
+        this.retryTimers.clear();
+        await this.drain(this.options.closeTimeout ?? DEFAULT_CLOSE_TIMEOUT_MS);
         this.jobs.clear();
         this.processors.clear();
         this.deduplicationIndex.clear();
+        this.settledOrder.length = 0;
+        this.stalledCounts.clear();
+        this.inFlight.clear();
         this.activeCount = 0;
-        this.processedCount = 0;
-        this.succeededCount = 0;
-        this.failedCount = 0;
         this.paused = false;
-        this.disposed = true;
         this.emptySince = 0;
         this.backoffMs = 50;
     }
+    /**
+     * Waits for in-flight jobs to settle, aborting them past the timeout.
+     */
+    async drain(timeoutMs) {
+        if (this.activeCount === 0)
+            return;
+        const deadline = Date.now() + Math.max(0, timeoutMs);
+        while (this.activeCount > 0 && Date.now() < deadline) {
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+        if (this.activeCount === 0)
+            return;
+        for (const controller of this.inFlight.values()) {
+            if (!controller.signal.aborted) {
+                controller.abort(new QueueDisposedError(this.name));
+            }
+        }
+        // Give aborted processors a brief window to unwind before returning.
+        const abortDeadline = Date.now() + 1_000;
+        while (this.activeCount > 0 && Date.now() < abortDeadline) {
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+    }
+    /**
+     * Generates a collision-resistant job id.
+     */
+    createJobId() {
+        return `job_${Date.now()}_${randomUUID().replace(/-/g, "")}`;
+    }
+    /**
+     * Round-trips a payload through the configured serializer.
+     */
+    encodePayload(jobId, data) {
+        if (this.options.serializePayloads === false) {
+            return data;
+        }
+        try {
+            return this.serializer.deserialize(this.serializer.serialize(data));
+        }
+        catch (error) {
+            throw new JobSerializationError(jobId, `Job payload for queue "${this.name}" is not serializable.`, { queueName: this.name, cause: error });
+        }
+    }
+    /**
+     * Selects the highest-priority job that is due and runnable.
+     *
+     * Ties on priority are broken by creation time, oldest first. The
+     * incumbent is tracked by reference rather than by a sentinel priority,
+     * so jobs with negative priorities are selectable like any other.
+     */
+    selectJob(predicate) {
+        const now = Date.now();
+        let nextJob = null;
+        for (const job of this.jobs.values()) {
+            if (job.state !== JobStateEnum.WAITING)
+                continue;
+            if (job.scheduledAt && new Date(job.scheduledAt).getTime() > now)
+                continue;
+            if (predicate && !predicate(job))
+                continue;
+            if (nextJob === null) {
+                nextJob = job;
+                continue;
+            }
+            if (job.priority > nextJob.priority) {
+                nextJob = job;
+                continue;
+            }
+            if (job.priority === nextJob.priority) {
+                const candidateTime = new Date(job.createdAt).getTime();
+                const incumbentTime = new Date(nextJob.createdAt).getTime();
+                if (candidateTime < incumbentTime)
+                    nextJob = job;
+            }
+        }
+        return nextJob;
+    }
     startPolling() {
-        const pollInterval = this.options.concurrency ? 50 : 100;
-        this.pollTimer = setTimeout(() => {
-            this.pollTimer = null;
-            this.processTick().finally(() => {
-                if (!this.disposed && this.processors.size > 0)
-                    this.scheduleNextTick();
-            });
-        }, pollInterval);
+        this.scheduleTick(this.options.pollInterval ?? 50);
     }
     scheduleNextTick() {
+        this.scheduleTick(this.backoffMs);
+    }
+    scheduleTick(interval) {
         if (this.disposed)
             return;
-        const interval = this.backoffMs;
         this.pollTimer = setTimeout(() => {
             this.pollTimer = null;
             this.processTick().finally(() => {
@@ -172,6 +358,8 @@ export class InMemoryQueue {
                     this.scheduleNextTick();
             });
         }, interval);
+        // The poll timer must not be the reason a process stays alive.
+        this.pollTimer.unref?.();
     }
     stopPolling() {
         if (this.pollTimer) {
@@ -179,34 +367,87 @@ export class InMemoryQueue {
             this.pollTimer = null;
         }
     }
+    /**
+     * Runs an already-claimed job through this queue's processing pipeline.
+     *
+     * The queue owns job state, so every consumer — the internal poller and
+     * any external `Worker` — must run jobs through here. A consumer that
+     * invokes a processor directly leaves the job stuck in `active` and
+     * skips retry, dead-lettering and middleware entirely.
+     */
+    async runJob(job, options) {
+        const processor = this.processors.get(job.name);
+        if (!processor) {
+            await this.releaseJob(job.id);
+            return;
+        }
+        const abortController = new AbortController();
+        // A consumer's own signal (a worker draining, say) must reach the
+        // job it dispatched.
+        if (options?.signal) {
+            if (options.signal.aborted) {
+                abortController.abort(options.signal.reason);
+            }
+            else {
+                options.signal.addEventListener("abort", () => {
+                    if (!abortController.signal.aborted) {
+                        abortController.abort(options.signal?.reason);
+                    }
+                }, { once: true });
+            }
+        }
+        this.inFlight.set(job.id, abortController);
+        this.activeCount++;
+        try {
+            await processJob(job, processor, {
+                timeoutMs: job.timeoutMs ?? options?.timeoutMs,
+                abortController,
+            }, {
+                jobs: this.jobs,
+                emitter: this.emitter,
+                deadLetterStore: this.deadLetterStore,
+                counters: this.counters,
+                middleware: options?.middleware
+                    ? [...this.middleware, ...options.middleware]
+                    : this.middleware,
+                registerRetryTimer: (jobId, timer) => {
+                    this.retryTimers.set(jobId, timer);
+                },
+                onSettled: (settled) => this.recordSettled(settled),
+                isDisposed: () => this.disposed,
+                ...(this.options.logger ? { logger: this.options.logger } : {}),
+            });
+        }
+        catch (error) {
+            this.emitter.emit("job:failed", {
+                job,
+                error: error instanceof Error ? error : new Error(String(error)),
+            });
+        }
+        finally {
+            this.activeCount--;
+            this.inFlight.delete(job.id);
+            this.retryTimers.delete(job.id);
+        }
+    }
     async processTick() {
         if (this.paused || this.disposed)
             return;
         const concurrency = Math.max(1, this.options.concurrency ?? 1);
         let processed = 0;
         while (this.activeCount < concurrency) {
-            const job = await this.getNextJob();
+            // `claimNextJob` only returns jobs that have a registered
+            // processor and moves them out of `waiting`, so this loop always
+            // terminates. Returning an unrunnable job here is what previously
+            // spun the event loop forever.
+            const job = await this.claimNextJob();
             if (!job)
                 break;
-            const processor = this.processors.get(job.name);
-            if (!processor)
-                continue;
-            this.activeCount++;
             processed++;
-            processJob(job, processor, this.middleware, this.jobs, { timeoutMs: job.timeoutMs }, this.emitter, this.deadLetterStore, {
-                processedCount: this.processedCount,
-                succeededCount: this.succeededCount,
-                failedCount: this.failedCount,
-            })
-                .catch((error) => {
-                this.emitter.emit("job:failed", {
-                    job,
-                    error: error instanceof Error ? error : new Error(String(error)),
-                });
-            })
-                .finally(() => {
-                this.activeCount--;
-            });
+            // Not awaited: jobs run concurrently up to the limit. `runJob`
+            // increments `activeCount` synchronously, so the loop condition
+            // sees the dispatch immediately.
+            void this.runJob(job);
         }
         if (processed > 0) {
             this.backoffMs = 50;
@@ -222,8 +463,92 @@ export class InMemoryQueue {
                 this.backoffMs = Math.min(this.backoffMs * 2, 2000);
             }
         }
-        if (this.scheduledTimers.size > 0) {
-            scheduleDelayedJobs(this.jobs);
+        promoteDueScheduledJobs(this.jobs, this.scheduledTimers);
+        this.reclaimStalledJobs();
+    }
+    /**
+     * Returns jobs stuck in `active` to the waiting pool.
+     *
+     * A consumer can claim a job and then die, or be killed mid-run.
+     * Without this the job stays `active` forever and no one picks it up
+     * again. A job that stalls repeatedly is dead-lettered rather than
+     * cycled indefinitely.
+     */
+    reclaimStalledJobs() {
+        const stalledAfter = this.options.stalledAfter ?? 0;
+        if (stalledAfter <= 0) {
+            return;
+        }
+        const now = Date.now();
+        const maxStalled = Math.max(1, this.options.maxStalledCount ?? 3);
+        for (const job of this.jobs.values()) {
+            if (job.state !== JobStateEnum.ACTIVE || !job.startedAt)
+                continue;
+            // A job this queue is currently running is not stalled.
+            if (this.inFlight.has(job.id))
+                continue;
+            const startedAt = new Date(job.startedAt).getTime();
+            if (Number.isNaN(startedAt) || now - startedAt < stalledAfter)
+                continue;
+            const count = (this.stalledCounts.get(job.id) ?? 0) + 1;
+            this.stalledCounts.set(job.id, count);
+            const error = new JobStalledError(job.id, { queueName: this.name });
+            if (count >= maxStalled) {
+                this.stalledCounts.delete(job.id);
+                this.counters.failedCount++;
+                this.counters.deadLetteredCount++;
+                const deadLettered = updateJobState(job, JobStateEnum.DEAD_LETTER, {
+                    error: error.message,
+                    failedAt: new Date().toISOString(),
+                });
+                this.jobs.set(job.id, deadLettered);
+                void this.deadLetterStore
+                    .add({
+                    job: deadLettered,
+                    deadLetterAt: new Date(),
+                    error,
+                    attempts: deadLettered.attempt,
+                    reason: `Stalled ${count} time(s).`,
+                })
+                    .catch(() => { });
+                this.emitter.emit("job:failed", { job: deadLettered, error });
+                this.recordSettled(deadLettered);
+                continue;
+            }
+            this.jobs.set(job.id, updateJobState(job, JobStateEnum.WAITING, { startedAt: undefined }));
+            this.emitter.emit("job:failed", { job, error });
+        }
+    }
+    /**
+     * Records a job that reached a terminal state and prunes history.
+     *
+     * Without this the queue retains every job it has ever run, and every
+     * deduplication key it has ever seen, for the life of the process.
+     */
+    recordSettled(job) {
+        if (job.deduplicationKey) {
+            const owner = this.deduplicationIndex.get(job.deduplicationKey);
+            if (owner === job.id) {
+                this.deduplicationIndex.delete(job.deduplicationKey);
+            }
+        }
+        this.settledOrder.push(job.id);
+        this.pruneSettled();
+    }
+    /**
+     * Drops the oldest terminal jobs beyond the retention limit.
+     */
+    pruneSettled() {
+        const limit = Math.max(0, this.options.retainSettledJobs ?? DEFAULT_RETAINED_JOBS);
+        while (this.settledOrder.length > limit) {
+            const jobId = this.settledOrder.shift();
+            if (jobId === undefined)
+                break;
+            const job = this.jobs.get(jobId);
+            if (job && TERMINAL_STATES.has(job.state)) {
+                this.jobs.delete(jobId);
+                this.stalledCounts.delete(jobId);
+            }
         }
     }
 }

package/dist/inMemoryQueue/inMemoryQueue.processing.d.ts

@@ -1,19 +1,64 @@
 import type { Job } from "../job/job.type.js";
 import type { Processor } from "../processor/processor.type.js";
+import type { JobId } from "../jobTypes/jobTypes.type.js";
+import type { QueueMiddleware } from "../middleware/middleware.type.js";
+import type { QueueEventEmitter } from "../queueEmitter/queueEmitter.type.js";
+import type { DeadLetterStore } from "../deadLetter/deadLetter.type.js";
+import type { QueueLogger } from "../queue/queue.type.js";
 /**
- * Process a single job with middleware, retry, and failure handling.
+ * Mutable throughput counters.
+ *
+ * Passed by reference so increments are visible to the queue that owns
+ * them; a copied object literal would discard every update.
  */
-export declare function processJob<TData>(job: Job<TData>, processor: Processor<TData>, middleware: import("../middleware/middleware.type.js").QueueMiddleware[], jobs: Map<string, Job<TData>>, options: {
-    timeoutMs?: number;
-}, emitter: import("../queueEmitter/queueEmitter.type.js").QueueEventEmitter, deadLetterStore: import("../deadLetter/deadLetter.type.js").DeadLetterStore<TData>, counters: {
+export interface QueueCounters {
     processedCount: number;
     succeededCount: number;
     failedCount: number;
-}): Promise<void>;
+    retriedCount: number;
+    deadLetteredCount: number;
+}
+/**
+ * Collaborators a job needs in order to run.
+ */
+export interface ProcessJobDependencies<TData> {
+    readonly jobs: Map<string, Job<TData>>;
+    readonly emitter: QueueEventEmitter;
+    readonly deadLetterStore: DeadLetterStore<TData>;
+    readonly counters: QueueCounters;
+    readonly middleware: readonly QueueMiddleware[];
+    /**
+     * Registers the timer that returns a retrying job to `waiting`, so the
+     * queue can clear it on close instead of leaking it.
+     */
+    readonly registerRetryTimer: (jobId: JobId, timer: ReturnType<typeof setTimeout>) => void;
+    /** Invoked whenever a job reaches a terminal state. */
+    readonly onSettled?: (job: Job<TData>) => void;
+    /** Whether the owning queue has been disposed. */
+    readonly isDisposed: () => boolean;
+    /**
+     * Destination for lines a processor writes with `context.log()`. Absent
+     * when the queue was configured without a logger.
+     */
+    readonly logger?: QueueLogger;
+}
+/**
+ * Process a single job with middleware, retry, and failure handling.
+ *
+ * The job is expected to already be claimed (`active`); this records the
+ * start time, runs the middleware chain, and routes the outcome to
+ * completion, retry, or the dead letter store.
+ */
+export declare function processJob<TData>(job: Job<TData>, processor: Processor<TData>, options: {
+    timeoutMs?: number;
+    abortController?: AbortController;
+}, deps: ProcessJobDependencies<TData>): Promise<void>;
 /**
  * Handle job failure with retry logic.
+ *
+ * A failure that will be retried is reported as `job:retrying` and counted
+ * separately; only a terminal failure increments `failedCount`, so the
+ * counters describe outcomes rather than attempts.
  */
-export declare function handleJobFailure<TData>(job: Job<TData>, errorMessage: string, processor: Processor<TData>, abortController: AbortController, jobs: Map<string, Job<TData>>, emitter: import("../queueEmitter/queueEmitter.type.js").QueueEventEmitter, deadLetterStore: import("../deadLetter/deadLetter.type.js").DeadLetterStore<TData>, counters: {
-    failedCount: number;
-}): Promise<void>;
+export declare function handleJobFailure<TData>(job: Job<TData>, errorMessage: string, deps: ProcessJobDependencies<TData>): Promise<void>;
 //# sourceMappingURL=inMemoryQueue.processing.d.ts.map