@zudojs/queue 1.2.0 → 1.4.0

package/dist/inMemoryQueue/inMemoryQueue.core.js

@@ -4,11 +4,12 @@ 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 { DEFAULT_DEAD_LETTER_JOBS, createInMemoryDeadLetterStore, } from "../deadLetter/deadLetter.core.js";
+import { InMemoryQueueEventEmitter } from "../queueEmitter/queueEmitter.core.js";
 import { processJob } from "./inMemoryQueue.processing.js";
 import { captureContext } from "../contextCarrier/contextCarrier.core.js";
 import { scheduleJob, promoteDueScheduledJobs, } from "./inMemoryQueue.scheduling.js";
+import { QueuePoller, hasPendingWork, selectNextJob } from "./polling/index.js";
 /** Terminal states a job never leaves. */
 const TERMINAL_STATES = new Set([
     JobStateEnum.COMPLETED,
@@ -38,7 +39,9 @@ export class InMemoryQueue {
     /** Whether the internal poller claims jobs; see `setAutoProcess`. */
     autoProcess;
     activeCount = 0;
-    pollTimer = null;
+    poller;
+    /** Consumers to tell when a job may have become runnable. */
+    readyListeners = new Set();
     scheduledTimers = new Map();
     retryTimers = new Map();
     inFlight = new Map();
@@ -47,6 +50,11 @@ export class InMemoryQueue {
     stalledCounts = new Map();
     deduplicationIndex = new Map();
     deadLetterStore;
+    /**
+     * Whether this queue created its own dead letter store. A store handed in
+     * by the caller outlives the queue and is theirs to clear.
+     */
+    ownsDeadLetterStore;
     emitter;
     counters = {
         processedCount: 0,
@@ -55,17 +63,52 @@ export class InMemoryQueue {
         retriedCount: 0,
         deadLetteredCount: 0,
     };
-    emptySince = 0;
-    backoffMs = 50;
     constructor(name, options) {
         this.name = name;
         this.options = options ?? {};
         this.serializer = this.options.serializer ?? JsonSerializer;
         this.middleware = this.options.middleware ?? [];
-        this.emitter = options?.eventEmitter ?? createNoopQueueEventEmitter();
+        // A working emitter by default: `queue.events` used to be a silent no-op
+        // unless one was passed in.
+        this.emitter =
+            options?.eventEmitter ??
+                new InMemoryQueueEventEmitter(this.options.logger ? { logger: this.options.logger } : {});
+        // A supplied emitter is built before the queue exists, so it cannot have
+        // been given the queue's logger. Hand it over, so a throwing listener is
+        // reported through structured logging rather than `process.emitWarning`.
+        if (this.options.logger &&
+            this.emitter instanceof InMemoryQueueEventEmitter) {
+            this.emitter.setLogger(this.options.logger);
+        }
+        this.ownsDeadLetterStore = this.options.deadLetterStore === undefined;
         this.deadLetterStore =
-            this.options.deadLetterStore ?? createInMemoryDeadLetterStore();
+            this.options.deadLetterStore ??
+                createInMemoryDeadLetterStore({
+                    maxEntries: DEFAULT_DEAD_LETTER_JOBS,
+                });
         this.autoProcess = this.options.autoProcess ?? true;
+        this.poller = new QueuePoller({
+            ...(this.options.pollInterval !== undefined
+                ? { pollInterval: this.options.pollInterval }
+                : {}),
+            tick: () => this.processTick(),
+            isLive: () => !this.disposed && this.processors.size > 0,
+            shouldKeepAlive: () => this.shouldKeepAlive(),
+        });
+    }
+    /**
+     * Subscribes to "a job may have become runnable": one was added, released
+     * or reclaimed, a delay or retry backoff elapsed, or the queue resumed.
+     *
+     * A `Worker` uses this to claim immediately instead of on its next poll.
+     *
+     * @returns A function that unsubscribes.
+     */
+    onJobReady(listener) {
+        this.readyListeners.add(listener);
+        return () => {
+            this.readyListeners.delete(listener);
+        };
     }
     /**
      * Turns the internal poller on or off as a consumer.
@@ -77,6 +120,18 @@ export class InMemoryQueue {
      */
     setAutoProcess(enabled) {
         this.autoProcess = enabled;
+        if (enabled)
+            this.poller.wake();
+    }
+    /**
+     * The emitter this queue publishes lifecycle events on.
+     *
+     * An in-memory emitter when the queue was created without one, so
+     * `queue.events.on(...)` works out of the box and a worker can report its
+     * lifecycle unconditionally.
+     */
+    get events() {
+        return this.emitter;
     }
     async add(jobName, data, options) {
         if (this.disposed)
@@ -118,10 +173,13 @@ export class InMemoryQueue {
             this.deduplicationIndex.set(mergedOptions.deduplicationKey, jobId);
         }
         if (job.state === JobStateEnum.SCHEDULED && job.scheduledAt) {
-            scheduleJob(job, this.scheduledTimers, this.jobs);
+            scheduleJob(job, this.scheduledTimers, this.jobs, () => this.jobReady());
         }
-        this.backoffMs = 50;
-        this.emptySince = 0;
+        // Wake the poller and any worker now. Resetting the back-off without
+        // re-arming the pending timer left a job added after an idle spell
+        // waiting up to 2 s; a delayed job wakes it too, so the pending work
+        // holds the process open.
+        this.jobReady();
         return job;
     }
     process(name, processor) {
@@ -129,8 +187,8 @@ export class InMemoryQueue {
             throw new QueueDisposedError(this.name);
         assertProcessor(processor, name);
         this.processors.set(name, processor);
-        if (!this.pollTimer)
-            this.startPolling();
+        // Jobs already waiting under this name are runnable now.
+        this.poller.wake();
     }
     async getJob(jobId) {
         return this.jobs.get(jobId) ?? null;
@@ -174,6 +232,7 @@ export class InMemoryQueue {
             return false;
         }
         this.jobs.set(jobId, updateJobState(job, JobStateEnum.WAITING, { startedAt: undefined }));
+        this.jobReady();
         return true;
     }
     getProcessor(name) {
@@ -238,10 +297,7 @@ export class InMemoryQueue {
         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();
+        this.jobReady();
     }
     isPaused() {
         return this.paused;
@@ -263,7 +319,8 @@ export class InMemoryQueue {
         // 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();
+        this.poller.stop();
+        this.readyListeners.clear();
         for (const timer of this.scheduledTimers.values())
             clearTimeout(timer);
         this.scheduledTimers.clear();
@@ -277,10 +334,13 @@ export class InMemoryQueue {
         this.settledOrder.length = 0;
         this.stalledCounts.clear();
         this.inFlight.clear();
+        // A dead letter store the queue created dies with it; one handed in by
+        // the caller is theirs and is left alone.
+        if (this.ownsDeadLetterStore) {
+            await this.deadLetterStore.clear();
+        }
         this.activeCount = 0;
         this.paused = false;
-        this.emptySince = 0;
-        this.backoffMs = 50;
     }
     /**
      * Waits for in-flight jobs to settle, aborting them past the timeout.
@@ -315,7 +375,10 @@ export class InMemoryQueue {
      * Round-trips a payload through the configured serializer.
      */
     encodePayload(jobId, data) {
-        if (this.options.serializePayloads === false) {
+        // A passthrough serializer means "store the payload as given": there is
+        // no string form to round-trip through.
+        if (this.options.serializePayloads === false ||
+            this.serializer.passthrough === true) {
             return data;
         }
         try {
@@ -326,62 +389,36 @@ export class InMemoryQueue {
         }
     }
     /**
-     * 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.
+     * Selects the next job that is due and runnable; see {@link selectNextJob}
+     * for the ordering.
      */
     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() {
-        this.scheduleTick(this.options.pollInterval ?? 50);
-    }
-    scheduleNextTick() {
-        this.scheduleTick(this.backoffMs);
+        return selectNextJob(this.jobs.values(), Date.now(), predicate);
     }
-    scheduleTick(interval) {
-        if (this.disposed)
-            return;
-        this.pollTimer = setTimeout(() => {
-            this.pollTimer = null;
-            this.processTick().finally(() => {
-                if (!this.disposed && this.processors.size > 0)
-                    this.scheduleNextTick();
-            });
-        }, interval);
-        // The poll timer must not be the reason a process stays alive.
-        this.pollTimer.unref?.();
+    /**
+     * Whether the poll loop should hold the process open: while the queue is
+     * consuming and has work one of its processors can run. Work nothing can
+     * consume, a paused queue and `keepAlive: false` never do.
+     */
+    shouldKeepAlive() {
+        if (this.options.keepAlive === false)
+            return false;
+        if (this.disposed || this.paused || !this.autoProcess)
+            return false;
+        if (this.activeCount > 0)
+            return true;
+        return hasPendingWork(this.jobs.values(), (job) => this.processors.has(job.name));
     }
-    stopPolling() {
-        if (this.pollTimer) {
-            clearTimeout(this.pollTimer);
-            this.pollTimer = null;
+    /** Wakes the poll loop and tells consumers a job may be runnable. */
+    jobReady() {
+        this.poller.wake();
+        for (const listener of [...this.readyListeners]) {
+            try {
+                listener();
+            }
+            catch {
+                // A consumer's wake-up hook must not break the producer.
+            }
         }
     }
     /**
@@ -400,17 +437,23 @@ export class InMemoryQueue {
         }
         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);
+        // job it dispatched. The forwarder is held so it can be removed once
+        // the job settles: a worker uses one long-lived signal for every job
+        // it dispatches, so a listener left behind accumulates for the life
+        // of the worker and pins that job's controller with it.
+        const consumerSignal = options?.signal;
+        let forwardAbort;
+        if (consumerSignal) {
+            if (consumerSignal.aborted) {
+                abortController.abort(consumerSignal.reason);
             }
             else {
-                options.signal.addEventListener("abort", () => {
+                forwardAbort = () => {
                     if (!abortController.signal.aborted) {
-                        abortController.abort(options.signal?.reason);
+                        abortController.abort(consumerSignal.reason);
                     }
-                }, { once: true });
+                };
+                consumerSignal.addEventListener("abort", forwardAbort, { once: true });
             }
         }
         this.inFlight.set(job.id, abortController);
@@ -440,6 +483,7 @@ export class InMemoryQueue {
                     this.retryTimers.delete(jobId);
                 },
                 onSettled: (settled) => this.recordSettled(settled),
+                onJobReady: () => this.jobReady(),
                 isDisposed: () => this.disposed,
                 ...(this.options.logger ? { logger: this.options.logger } : {}),
             });
@@ -453,12 +497,26 @@ export class InMemoryQueue {
         finally {
             this.activeCount--;
             this.inFlight.delete(job.id);
+            // A slot is free: claim the next job now rather than on the next poll.
+            this.poller.wake();
+            if (forwardAbort && consumerSignal) {
+                consumerSignal.removeEventListener("abort", forwardAbort);
+            }
         }
     }
+    /**
+     * One poll: promotes due delayed jobs, claims runnable jobs up to the
+     * concurrency limit, and reclaims stalled ones.
+     *
+     * @returns Whether any job was dispatched.
+     */
     async processTick() {
         if (this.paused || this.disposed)
-            return;
+            return false;
         const concurrency = Math.max(1, this.options.concurrency ?? 1);
+        // Promote first, so a job whose delay just elapsed is claimable in this
+        // same tick.
+        promoteDueScheduledJobs(this.jobs, this.scheduledTimers);
         let processed = 0;
         while (this.autoProcess && this.activeCount < concurrency) {
             // `claimNextJob` only returns jobs that have a registered
@@ -474,22 +532,8 @@ export class InMemoryQueue {
             // sees the dispatch immediately.
             void this.runJob(job);
         }
-        if (processed > 0) {
-            this.backoffMs = 50;
-            this.emptySince = 0;
-        }
-        else if (this.emptySince === 0) {
-            this.emptySince = Date.now();
-            this.backoffMs = 50;
-        }
-        else {
-            const elapsed = Date.now() - this.emptySince;
-            if (elapsed > 500) {
-                this.backoffMs = Math.min(this.backoffMs * 2, 2000);
-            }
-        }
-        promoteDueScheduledJobs(this.jobs, this.scheduledTimers);
         this.reclaimStalledJobs();
+        return processed > 0;
     }
     /**
      * Returns jobs stuck in `active` to the waiting pool.
@@ -542,6 +586,7 @@ export class InMemoryQueue {
             }
             this.jobs.set(job.id, updateJobState(job, JobStateEnum.WAITING, { startedAt: undefined }));
             this.emitter.emit("job:failed", { job, error });
+            this.jobReady();
         }
     }
     /**

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

@@ -37,6 +37,8 @@ export interface ProcessJobDependencies<TData> {
     readonly deregisterRetryTimer?: (jobId: JobId) => void;
     /** Invoked whenever a job reaches a terminal state. */
     readonly onSettled?: (job: Job<TData>) => void;
+    /** Invoked when a retrying job's backoff elapses and it is runnable again. */
+    readonly onJobReady?: () => void;
     /** Whether the owning queue has been disposed. */
     readonly isDisposed: () => boolean;
     /**

package/dist/inMemoryQueue/inMemoryQueue.processing.js

@@ -48,10 +48,15 @@ export async function processJob(job, processor, options, deps) {
         },
     });
     const timeoutMs = options.timeoutMs ?? DEFAULT_JOB_OPTIONS.timeout ?? 30_000;
+    // Whether this job's own timeout is what aborted it. An abort from
+    // anywhere else — a draining worker, `close()`, a consumer's signal — is a
+    // cancellation, and is reported as one.
+    let timedOut = false;
     const timeoutMiddleware = createTimeoutMiddleware(timeoutMs, () => {
         // Let a cooperative processor observe the timeout and stop working
         // instead of running on with its result discarded.
         if (!abortController.signal.aborted) {
+            timedOut = true;
             abortController.abort(new Error(`Job "${updatedJob.id}" timed out after ${timeoutMs}ms.`));
         }
     });
@@ -92,6 +97,9 @@ export async function processJob(job, processor, options, deps) {
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         await settleWithin(running, options.timeoutGraceMs ?? DEFAULT_TIMEOUT_GRACE_MS);
+        if (abortController.signal.aborted && !timedOut) {
+            emitter.emit("job:cancelled", { job: updatedJob });
+        }
         await handleJobFailure(updatedJob, errorMessage, deps);
     }
     finally {
@@ -140,10 +148,11 @@ export async function handleJobFailure(job, errorMessage, deps) {
                     failedAt: undefined,
                 });
                 jobs.set(job.id, waitingJob);
+                deps.onJobReady?.();
             }
         }, delay);
-        // `unref` keeps a pending retry from holding the process open; the
-        // queue clears the timer explicitly on close.
+        // Unreferenced: the queue's poll loop decides whether a pending retry
+        // holds the process open. The queue clears the timer on close.
         timer.unref?.();
         deps.registerRetryTimer(job.id, timer);
         return;

package/dist/inMemoryQueue/inMemoryQueue.scheduling.d.ts

@@ -4,10 +4,13 @@ import type { JobId } from "../jobTypes/jobTypes.type.js";
  * Schedule a job for future execution.
  *
  * The timer is registered so the queue can clear it on close, and
- * unreferenced so a scheduled job never by itself keeps the process
- * alive.
+ * unreferenced: the queue's poll loop, not each job's timer, decides whether
+ * pending work holds the process open.
+ *
+ * @param onDue - Told when the job has been promoted to `waiting`, so a
+ *   consumer can claim it now rather than on its next poll.
  */
-export declare function scheduleJob<TData>(job: Job<TData>, scheduledTimers: Map<JobId, ReturnType<typeof setTimeout>>, jobs: Map<string, Job<TData>>): void;
+export declare function scheduleJob<TData>(job: Job<TData>, scheduledTimers: Map<JobId, ReturnType<typeof setTimeout>>, jobs: Map<string, Job<TData>>, onDue?: () => void): void;
 /**
  * Promotes scheduled jobs whose time has arrived.
  *

package/dist/inMemoryQueue/inMemoryQueue.scheduling.js

@@ -5,10 +5,13 @@ import { MAX_TIMER_DELAY } from "../retryPolicy/retryPolicy.core.js";
  * Schedule a job for future execution.
  *
  * The timer is registered so the queue can clear it on close, and
- * unreferenced so a scheduled job never by itself keeps the process
- * alive.
+ * unreferenced: the queue's poll loop, not each job's timer, decides whether
+ * pending work holds the process open.
+ *
+ * @param onDue - Told when the job has been promoted to `waiting`, so a
+ *   consumer can claim it now rather than on its next poll.
  */
-export function scheduleJob(job, scheduledTimers, jobs) {
+export function scheduleJob(job, scheduledTimers, jobs, onDue) {
     if (!job.scheduledAt) {
         return;
     }
@@ -17,6 +20,7 @@ export function scheduleJob(job, scheduledTimers, jobs) {
         // An unparseable schedule would otherwise fire immediately via NaN
         // coercion; promote the job instead of guessing at a delay.
         jobs.set(job.id, updateJobState(job, JobStateEnum.WAITING));
+        onDue?.();
         return;
     }
     const delay = Math.min(Math.max(0, scheduledTime - Date.now()), MAX_TIMER_DELAY);
@@ -29,6 +33,7 @@ export function scheduleJob(job, scheduledTimers, jobs) {
         const currentJob = jobs.get(job.id);
         if (currentJob && currentJob.state === JobStateEnum.SCHEDULED) {
             jobs.set(job.id, updateJobState(currentJob, JobStateEnum.WAITING));
+            onDue?.();
         }
     }, delay);
     timer.unref?.();

package/dist/inMemoryQueue/polling/inMemoryQueue.poller.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The in-memory queue's poll loop.
+ *
+ * A tick promotes due delayed jobs, claims runnable ones and reclaims stalled
+ * ones. Three defects lived here: `pollInterval` applied to the first tick
+ * only (every later tick used a built-in 50 ms that backed off to 2 s while
+ * idle), nothing woke the loop when work arrived (so an add after an idle
+ * spell waited out the back-off), and every timer was unreferenced (so a
+ * script whose only work was a queue exited before any job ran).
+ *
+ * @module inMemoryQueue/polling/inMemoryQueue.poller
+ */
+/** First interval, and the floor of the idle back-off, when none is set. */
+export declare const DEFAULT_POLL_INTERVAL_MS = 50;
+/** Ceiling of the idle back-off when no `pollInterval` is set. */
+export declare const MAX_IDLE_POLL_INTERVAL_MS = 2000;
+/** What the poller drives. */
+export interface QueuePollerOptions {
+    /**
+     * A fixed interval between ticks. When set it is used for every tick;
+     * when unset the interval starts at {@link DEFAULT_POLL_INTERVAL_MS} and
+     * backs off while idle.
+     */
+    readonly pollInterval?: number;
+    /** Runs one tick. Resolves true when it dispatched any job. */
+    readonly tick: () => Promise<boolean>;
+    /** Whether the loop should keep running at all. */
+    readonly isLive: () => boolean;
+    /** Whether the armed timer should hold the process open. */
+    readonly shouldKeepAlive: () => boolean;
+}
+/**
+ * Drives a queue's ticks: a fixed or backing-off interval, an immediate
+ * `wake()` when work may have arrived, and at most one tick at a time.
+ */
+export declare class QueuePoller {
+    private readonly options;
+    private timer;
+    private armedDelay;
+    private ticking;
+    private wakeRequested;
+    private backoffMs;
+    private emptySince;
+    constructor(options: QueuePollerOptions);
+    /** Whether a tick is armed or running. */
+    get isRunning(): boolean;
+    /** Arms the first tick, unless the loop is already running. */
+    start(): void;
+    /** Runs a tick as soon as possible, and clears the idle back-off. */
+    wake(): void;
+    /** Clears the idle back-off without arming anything. */
+    resetBackoff(): void;
+    /** Disarms the loop. A tick already running finishes but re-arms nothing. */
+    stop(): void;
+    private arm;
+    /**
+     * Referenced while there is work a consumer can run, so the process waits
+     * for it; unreferenced otherwise, so an idle queue never holds it open.
+     */
+    private applyKeepAlive;
+    private run;
+    private nextDelay;
+}
+//# sourceMappingURL=inMemoryQueue.poller.d.ts.map

package/dist/inMemoryQueue/polling/inMemoryQueue.poller.js

@@ -0,0 +1,132 @@
+/**
+ * The in-memory queue's poll loop.
+ *
+ * A tick promotes due delayed jobs, claims runnable ones and reclaims stalled
+ * ones. Three defects lived here: `pollInterval` applied to the first tick
+ * only (every later tick used a built-in 50 ms that backed off to 2 s while
+ * idle), nothing woke the loop when work arrived (so an add after an idle
+ * spell waited out the back-off), and every timer was unreferenced (so a
+ * script whose only work was a queue exited before any job ran).
+ *
+ * @module inMemoryQueue/polling/inMemoryQueue.poller
+ */
+/** First interval, and the floor of the idle back-off, when none is set. */
+export const DEFAULT_POLL_INTERVAL_MS = 50;
+/** Ceiling of the idle back-off when no `pollInterval` is set. */
+export const MAX_IDLE_POLL_INTERVAL_MS = 2_000;
+/** How long the loop must find nothing before an unset interval backs off. */
+const IDLE_BEFORE_BACKOFF_MS = 500;
+/**
+ * Drives a queue's ticks: a fixed or backing-off interval, an immediate
+ * `wake()` when work may have arrived, and at most one tick at a time.
+ */
+export class QueuePoller {
+    options;
+    timer = null;
+    armedDelay = 0;
+    ticking = false;
+    wakeRequested = false;
+    backoffMs = DEFAULT_POLL_INTERVAL_MS;
+    emptySince = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    /** Whether a tick is armed or running. */
+    get isRunning() {
+        return this.timer !== null || this.ticking;
+    }
+    /** Arms the first tick, unless the loop is already running. */
+    start() {
+        if (this.isRunning)
+            return;
+        this.arm(this.options.pollInterval ?? DEFAULT_POLL_INTERVAL_MS);
+    }
+    /** Runs a tick as soon as possible, and clears the idle back-off. */
+    wake() {
+        this.resetBackoff();
+        if (!this.options.isLive())
+            return;
+        if (this.ticking) {
+            this.wakeRequested = true;
+            return;
+        }
+        if (this.timer !== null && this.armedDelay === 0) {
+            // Already due; the work that woke us may change whether it holds the
+            // process open.
+            this.applyKeepAlive();
+            return;
+        }
+        this.arm(0);
+    }
+    /** Clears the idle back-off without arming anything. */
+    resetBackoff() {
+        this.backoffMs = DEFAULT_POLL_INTERVAL_MS;
+        this.emptySince = 0;
+    }
+    /** Disarms the loop. A tick already running finishes but re-arms nothing. */
+    stop() {
+        if (this.timer !== null)
+            clearTimeout(this.timer);
+        this.timer = null;
+        this.wakeRequested = false;
+        this.resetBackoff();
+    }
+    arm(delay) {
+        if (!this.options.isLive())
+            return;
+        if (this.timer !== null)
+            clearTimeout(this.timer);
+        this.armedDelay = delay;
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            void this.run();
+        }, delay);
+        this.applyKeepAlive();
+    }
+    /**
+     * Referenced while there is work a consumer can run, so the process waits
+     * for it; unreferenced otherwise, so an idle queue never holds it open.
+     */
+    applyKeepAlive() {
+        if (this.timer === null)
+            return;
+        if (this.options.shouldKeepAlive())
+            this.timer.ref?.();
+        else
+            this.timer.unref?.();
+    }
+    async run() {
+        this.ticking = true;
+        let dispatched = false;
+        try {
+            dispatched = await this.options.tick();
+        }
+        catch {
+            // A tick never rejects by design; a defect must not stop the loop.
+        }
+        finally {
+            this.ticking = false;
+        }
+        if (!this.options.isLive() || this.timer !== null)
+            return;
+        const woken = this.wakeRequested;
+        this.wakeRequested = false;
+        this.arm(woken ? 0 : this.nextDelay(dispatched));
+    }
+    nextDelay(dispatched) {
+        if (this.options.pollInterval !== undefined) {
+            return Math.max(0, this.options.pollInterval);
+        }
+        if (dispatched) {
+            this.resetBackoff();
+        }
+        else if (this.emptySince === 0) {
+            this.emptySince = Date.now();
+        }
+        else if (Date.now() - this.emptySince > IDLE_BEFORE_BACKOFF_MS) {
+            this.backoffMs = Math.min(this.backoffMs * 2, MAX_IDLE_POLL_INTERVAL_MS);
+        }
+        return this.backoffMs;
+    }
+}
+//# sourceMappingURL=inMemoryQueue.poller.js.map