bunqueue-client 0.1.2 → 0.1.3

package/dist/bunqueue/types.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Bunqueue Simple Mode — type definitions.
+ * 1:1 port of src/client/bunqueue/types.ts from the official client, minus
+ * the embedded-mode options (this SDK is TCP-only).
+ */
+import type { TlsOption } from '../connection.js';
+import type { Job } from '../job.js';
+import type { JobOptions } from '../types.js';
+import type { Processor } from '../worker-types.js';
+/** Connection options accepted by Simple Mode (mirrors ConnectionOptions). */
+export interface BunqueueConnection {
+    host?: string;
+    port?: number;
+    token?: string;
+    tls?: TlsOption;
+}
+/** Middleware function: receives job and next(), returns result. */
+export type BunqueueMiddleware<T = unknown, R = unknown> = (job: Job<T>, next: () => Promise<R>) => Promise<R>;
+/** Retry strategy for advanced backoff. */
+export type RetryStrategy = 'fixed' | 'exponential' | 'jitter' | 'fibonacci' | 'custom';
+/** Advanced retry configuration (in-process; the job stays active). */
+export interface RetryConfig {
+    /** Max attempts (default: 3). */
+    maxAttempts?: number;
+    /** Base delay in ms (default: 1000). */
+    delay?: number;
+    /** Strategy (default: exponential). */
+    strategy?: RetryStrategy;
+    /** Custom backoff function: attempt, error -> delay in ms. */
+    customBackoff?: (attempt: number, error: Error) => number;
+    /** Only retry if this returns true. */
+    retryIf?: (error: Error, attempt: number) => boolean;
+}
+/** Circuit breaker configuration. */
+export interface CircuitBreakerConfig {
+    /** Max consecutive failures before opening (default: 5). */
+    threshold?: number;
+    /** Time in ms before half-open retry (default: 30000). */
+    resetTimeout?: number;
+    onOpen?: (failures: number) => void;
+    onClose?: () => void;
+    onHalfOpen?: () => void;
+}
+/** Circuit breaker state. */
+export type CircuitState = 'closed' | 'open' | 'half-open';
+/** Event trigger rule. */
+export interface TriggerRule<T = unknown> {
+    /** Job name that triggers this rule. */
+    on: string;
+    /** Event type (default: completed). */
+    event?: 'completed' | 'failed';
+    /** Job name to create. */
+    create: string;
+    /** Data builder from the triggering job. */
+    data: (result: unknown, job: Job<T>) => T;
+    /** Optional job options. */
+    opts?: JobOptions;
+    /** Optional condition. */
+    condition?: (result: unknown, job: Job<T>) => boolean;
+}
+/** Priority aging configuration. */
+export interface PriorityAgingConfig {
+    /** Check interval in ms (default: 60000). */
+    interval?: number;
+    /** Min age in ms before boost (default: 60000). */
+    minAge?: number;
+    /** Priority boost per interval (default: 1). */
+    boost?: number;
+    /** Max priority cap (default: 100). */
+    maxPriority?: number;
+    /** Max jobs to scan per tick (default: 100). */
+    maxScan?: number;
+}
+/** Batch processor function. */
+export type BatchProcessor<T = unknown, R = unknown> = (jobs: Array<Job<T>>) => Promise<R[]>;
+/** Batch processing configuration. */
+export interface BatchConfig<T = unknown, R = unknown> {
+    /** Batch size (default: 10). */
+    size: number;
+    /** Max wait in ms before flushing a partial batch (default: 5000). */
+    timeout?: number;
+    processor: BatchProcessor<T, R>;
+}
+/** Job TTL configuration. */
+export interface JobTtlConfig {
+    /** Default TTL in ms (0 = no TTL). */
+    defaultTtl?: number;
+    /** Per-job-name TTL overrides. */
+    perName?: Record<string, number>;
+}
+/** Deduplication defaults for Simple Mode. */
+export interface BunqueueDeduplicationConfig {
+    /** Default deduplication TTL in ms (default: 3600000 = 1 hour). */
+    ttl?: number;
+    /** Extend TTL when a duplicate arrives (default: false). */
+    extend?: boolean;
+    /** Replace data when a duplicate arrives in delayed state (default: false). */
+    replace?: boolean;
+}
+/** Debounce defaults for Simple Mode. */
+export interface BunqueueDebounceConfig {
+    /** Debounce TTL in ms. */
+    ttl: number;
+}
+/** DLQ configuration for Simple Mode (forwarded to the server). */
+export interface BunqueueDlqConfig {
+    autoRetry?: boolean;
+    autoRetryInterval?: number;
+    maxAutoRetries?: number;
+    maxAge?: number | null;
+    maxEntries?: number;
+}
+/** Client-side rate limiter options (max job starts per duration window). */
+export interface RateLimiterOptions {
+    max: number;
+    duration: number;
+    /** Group jobs by this data field (e.g. per-customer limits). */
+    groupKey?: string;
+}
+/** Bunqueue Simple Mode options. */
+export interface BunqueueOptions<T = unknown, R = unknown> {
+    processor?: Processor<T, R>;
+    routes?: Record<string, Processor<T, R>>;
+    batch?: BatchConfig<T, R>;
+    concurrency?: number;
+    connection?: BunqueueConnection;
+    defaultJobOptions?: JobOptions;
+    autorun?: boolean;
+    /** Worker heartbeat interval in ms (official-client unit). */
+    heartbeatInterval?: number;
+    batchSize?: number;
+    /** Long-poll timeout in ms. */
+    pollTimeout?: number;
+    limiter?: RateLimiterOptions;
+    removeOnComplete?: boolean;
+    removeOnFail?: boolean;
+    retry?: RetryConfig;
+    circuitBreaker?: CircuitBreakerConfig;
+    ttl?: JobTtlConfig;
+    priorityAging?: PriorityAgingConfig;
+    /** Job deduplication defaults, merged into every add(). */
+    deduplication?: BunqueueDeduplicationConfig;
+    /** Job debouncing defaults, merged into every add(). */
+    debounce?: BunqueueDebounceConfig;
+    /** Rate limiting for the worker (alias of limiter, takes precedence). */
+    rateLimit?: RateLimiterOptions;
+    /** Dead letter queue auto-management (forwarded to the server). */
+    dlq?: BunqueueDlqConfig;
+    /** Namespace prefix prepended to the queue name on the server. */
+    prefixKey?: string;
+}

package/dist/bunqueue/types.js

@@ -0,0 +1,6 @@
+/**
+ * Bunqueue Simple Mode — type definitions.
+ * 1:1 port of src/client/bunqueue/types.ts from the official client, minus
+ * the embedded-mode options (this SDK is TCP-only).
+ */
+export {};

package/dist/connection.d.ts

@@ -22,12 +22,20 @@ export declare class Connection {
     private pending;
     private reqCounter;
     private parser;
+    private connectGeneration;
+    private failedAttempts;
+    private nextAttemptAt;
     constructor(options?: ConnectionOptions);
     get isConnected(): boolean;
+    /**
+     * Monotonic counter, incremented on every successful (re)connect. Consumers
+     * that hold per-connection server state (e.g. a Worker registration) compare
+     * it between operations and re-establish that state after a reconnect.
+     */
+    get generation(): number;
     /** Open the socket (and authenticate) if not already connected. */
     connect(): Promise<void>;
     private doConnect;
-    private openSocket;
     /**
      * Send a command and await its response. Rejects with CommandError when
      * the server answers ok=false. Reconnects lazily if the link was lost.

package/dist/connection.js

@@ -5,12 +5,10 @@
  * pipelining (many in-flight commands per socket). Uses only `node:`
  * builtins (net/tls), which Node, Bun and Deno all support.
  */
-import { readFileSync } from 'node:fs';
-import { connect as netConnect } from 'node:net';
-import { connect as tlsConnect } from 'node:tls';
 import { pack, unpack } from 'msgpackr';
 import { AuthError, CommandError, CommandTimeoutError, ConnectionClosedError } from './errors.js';
 import { compact, FrameParser, frame, PROTOCOL_VERSION } from './frame.js';
+import { openSocket } from './socket-factory.js';
 /** A single pipelined TCP connection to a bunqueue server. */
 export class Connection {
     host;
@@ -26,6 +24,9 @@ export class Connection {
     pending = new Map();
     reqCounter = 0;
     parser = new FrameParser();
+    connectGeneration = 0;
+    failedAttempts = 0;
+    nextAttemptAt = 0;
     constructor(options = {}) {
         this.host = options.host ?? 'localhost';
         this.port = options.port ?? 6789;
@@ -37,21 +38,46 @@ export class Connection {
     get isConnected() {
         return this.connected;
     }
+    /**
+     * Monotonic counter, incremented on every successful (re)connect. Consumers
+     * that hold per-connection server state (e.g. a Worker registration) compare
+     * it between operations and re-establish that state after a reconnect.
+     */
+    get generation() {
+        return this.connectGeneration;
+    }
     /** Open the socket (and authenticate) if not already connected. */
     async connect() {
         if (this.connected)
             return;
         if (this.closed)
             throw new ConnectionClosedError('connection closed by client');
+        // Fast-fail while inside the reconnect backoff window: without this, a
+        // producer calling add() against a downed server pays the full connect
+        // timeout on EVERY call (reconnect storm).
+        if (Date.now() < this.nextAttemptAt) {
+            throw new ConnectionClosedError(`server unreachable, retry in ${this.nextAttemptAt - Date.now()}ms`);
+        }
         if (this.connecting)
             return this.connecting;
-        this.connecting = this.doConnect().finally(() => {
+        this.connecting = this.doConnect()
+            .then(() => {
+            this.failedAttempts = 0;
+            this.nextAttemptAt = 0;
+        })
+            .catch((err) => {
+            this.failedAttempts += 1;
+            const backoff = Math.min(500 * 2 ** (this.failedAttempts - 1), 5000);
+            this.nextAttemptAt = Date.now() + backoff;
+            throw err;
+        })
+            .finally(() => {
             this.connecting = null;
         });
         return this.connecting;
     }
     async doConnect() {
-        const socket = await this.openSocket();
+        const socket = await openSocket(this.host, this.port, this.tls, this.connectTimeoutMs);
         socket.setNoDelay(true);
         this.parser.clear();
         this.socket = socket;
@@ -59,6 +85,7 @@ export class Connection {
         socket.on('error', () => this.teardown());
         socket.on('close', () => this.teardown());
         this.connected = true;
+        this.connectGeneration += 1;
         if (this.token) {
             try {
                 await this.call({ cmd: 'Auth', token: this.token });
@@ -71,48 +98,6 @@ export class Connection {
             }
         }
     }
-    openSocket() {
-        return new Promise((resolve, reject) => {
-            let settled = false;
-            const timer = setTimeout(() => {
-                if (settled)
-                    return;
-                settled = true;
-                socket.destroy();
-                reject(new ConnectionClosedError(`connect timeout to ${this.host}:${this.port}`));
-            }, this.connectTimeoutMs);
-            const onError = (err) => {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timer);
-                reject(new ConnectionClosedError(`connect failed: ${err.message}`));
-            };
-            const onReady = () => {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timer);
-                socket.off('error', onError);
-                resolve(socket);
-            };
-            let socket;
-            if (this.tls) {
-                const tlsOpts = { host: this.host, port: this.port };
-                if (typeof this.tls === 'object') {
-                    if (this.tls.caFile)
-                        tlsOpts.ca = readFileSync(this.tls.caFile);
-                    if (this.tls.rejectUnauthorized === false)
-                        tlsOpts.rejectUnauthorized = false;
-                }
-                socket = tlsConnect(tlsOpts, onReady);
-            }
-            else {
-                socket = netConnect({ host: this.host, port: this.port }, onReady);
-            }
-            socket.on('error', onError);
-        });
-    }
     /**
      * Send a command and await its response. Rejects with CommandError when
      * the server answers ok=false. Reconnects lazily if the link was lost.

package/dist/index.d.ts

@@ -2,6 +2,9 @@
  * bunqueue-client — cross-runtime TypeScript SDK for bunqueue (TCP mode).
  * Works on Node.js ≥20, Bun and Deno ≥2 (uses only node: builtins + msgpackr).
  */
+export { Bunqueue } from './bunqueue/bunqueue.js';
+export type { DlqFilter, DlqStats } from './bunqueue/dlq-rate-limit.js';
+export type { BatchConfig, BatchProcessor, BunqueueConnection, BunqueueDebounceConfig, BunqueueDeduplicationConfig, BunqueueDlqConfig, BunqueueMiddleware, BunqueueOptions, CircuitBreakerConfig, CircuitState, JobTtlConfig, PriorityAgingConfig, RateLimiterOptions, RetryConfig, RetryStrategy, TriggerRule, } from './bunqueue/types.js';
 export type { Command, ConnectionOptions, Response, TlsOption } from './connection.js';
 export { Connection } from './connection.js';
 export { AuthError, BunqueueError, CommandError, CommandTimeoutError, ConnectionClosedError, UnrecoverableError, } from './errors.js';
@@ -16,4 +19,4 @@ export type { SchedulerOptions } from './queue-admin.js';
 export type { BackoffOptions, DeduplicationOptions, JobCounts, JobOptions, JobStateName, RepeatOptions, } from './types.js';
 export { Worker } from './worker.js';
 export type { Processor, WorkerOptions } from './worker-types.js';
-export declare const __version__ = "0.1.0";
+export declare const __version__ = "0.1.2";

package/dist/index.js

@@ -2,6 +2,8 @@
  * bunqueue-client — cross-runtime TypeScript SDK for bunqueue (TCP mode).
  * Works on Node.js ≥20, Bun and Deno ≥2 (uses only node: builtins + msgpackr).
  */
+// Simple Mode (Bunqueue): all-in-one Queue + Worker, 1:1 with the official client
+export { Bunqueue } from './bunqueue/bunqueue.js';
 export { Connection } from './connection.js';
 export { AuthError, BunqueueError, CommandError, CommandTimeoutError, ConnectionClosedError, UnrecoverableError, } from './errors.js';
 export { FlowProducer } from './flow.js';
@@ -9,4 +11,4 @@ export { MAX_FRAME_SIZE, PROTOCOL_VERSION } from './frame.js';
 export { Job } from './job.js';
 export { Queue } from './queue.js';
 export { Worker } from './worker.js';
-export const __version__ = '0.1.0';
+export const __version__ = '0.1.2';

package/dist/job.d.ts

@@ -20,6 +20,8 @@ export declare class Job<T = unknown> {
     get attempts(): number;
     get maxAttempts(): number;
     get createdAt(): number | undefined;
+    /** Creation time in epoch ms (BullMQ-parity alias of createdAt). */
+    get timestamp(): number;
     get startedAt(): number | null;
     get completedAt(): number | null;
     get customId(): string | null;

package/dist/job.js

@@ -44,6 +44,10 @@ export class Job {
     get createdAt() {
         return this.raw.createdAt === undefined ? undefined : Number(this.raw.createdAt);
     }
+    /** Creation time in epoch ms (BullMQ-parity alias of createdAt). */
+    get timestamp() {
+        return this.createdAt ?? Date.now();
+    }
     get startedAt() {
         return this.raw.startedAt === undefined || this.raw.startedAt === null
             ? null

package/dist/queue-admin.js

@@ -138,6 +138,7 @@ export const adminMethods = {
         return (data.webhooks ?? response.webhooks ?? []);
     },
     async setWebhookEnabled(webhookId, enabled) {
-        await this.call({ cmd: 'SetWebhookEnabled', webhookId, enabled });
+        // wire field is `id` (SetWebhookEnabledCommand), unlike RemoveWebhook's `webhookId`
+        await this.call({ cmd: 'SetWebhookEnabled', id: webhookId, enabled });
     },
 };

package/dist/socket-factory.d.ts

@@ -0,0 +1,4 @@
+/** Socket factory: opens a plain or TLS socket with a connect timeout. */
+import { type Socket } from 'node:net';
+import type { TlsOption } from './connection-types.js';
+export declare function openSocket(host: string, port: number, tls: TlsOption, connectTimeoutMs: number): Promise<Socket>;

package/dist/socket-factory.js

@@ -0,0 +1,47 @@
+/** Socket factory: opens a plain or TLS socket with a connect timeout. */
+import { readFileSync } from 'node:fs';
+import { connect as netConnect } from 'node:net';
+import { connect as tlsConnect } from 'node:tls';
+import { ConnectionClosedError } from './errors.js';
+export function openSocket(host, port, tls, connectTimeoutMs) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            socket.destroy();
+            reject(new ConnectionClosedError(`connect timeout to ${host}:${port}`));
+        }, connectTimeoutMs);
+        const onError = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            reject(new ConnectionClosedError(`connect failed: ${err.message}`));
+        };
+        const onReady = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            socket.off('error', onError);
+            resolve(socket);
+        };
+        let socket;
+        if (tls) {
+            const tlsOpts = { host: host, port: port };
+            if (typeof tls === 'object') {
+                if (tls.caFile)
+                    tlsOpts.ca = readFileSync(tls.caFile);
+                if (tls.rejectUnauthorized === false)
+                    tlsOpts.rejectUnauthorized = false;
+            }
+            socket = tlsConnect(tlsOpts, onReady);
+        }
+        else {
+            socket = netConnect({ host: host, port: port }, onReady);
+        }
+        socket.on('error', onError);
+    });
+}

package/dist/worker-base.d.ts

@@ -26,8 +26,10 @@ export declare class WorkerBase extends EventEmitter {
     protected failedCount: number;
     protected readyPromise: Promise<void>;
     protected readyResolve: (() => void) | null;
+    protected readyFired: boolean;
     protected loopPromise: Promise<void> | null;
     protected heartbeatTimer: ReturnType<typeof setInterval> | null;
+    protected registeredGeneration: number;
     constructor(queue: string, opts?: WorkerOptions);
     pause(): void;
     resume(): void;
@@ -35,6 +37,13 @@ export declare class WorkerBase extends EventEmitter {
     isPaused(): boolean;
     isClosed(): boolean;
     waitUntilReady(): Promise<void>;
+    /**
+     * 'ready' is replayed to listeners attached after it fired: with autorun the
+     * loop starts inside the constructor, so a plain once-only event could be
+     * missed by `new Worker(...).on('ready', ...)` patterns.
+     */
+    on(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    once(event: string | symbol, listener: (...args: unknown[]) => void): this;
     /**
      * Cooperative cancel of a locally active job (mirrors the official client):
      * marks the job and emits 'cancelled'; the processor is expected to check
@@ -43,8 +52,10 @@ export declare class WorkerBase extends EventEmitter {
     cancelJob(jobId: string, reason?: string): boolean;
     cancelAllJobs(reason?: string): void;
     isJobCancelled(jobId: string): boolean;
-    /** Graceful shutdown: stop pulling, wait for in-flight jobs. */
-    close(): Promise<void>;
+    /** Graceful shutdown: stop pulling, wait for in-flight jobs.
+     * With `force` the wait for in-flight jobs is skipped (parity with the
+     * official client's `close(force)`). */
+    close(force?: boolean): Promise<void>;
     protected safeCall(command: Record<string, unknown> & {
         cmd: string;
     }): Promise<void>;

package/dist/worker-base.js

@@ -28,8 +28,10 @@ export class WorkerBase extends EventEmitter {
     failedCount = 0;
     readyPromise;
     readyResolve = null;
+    readyFired = false;
     loopPromise = null;
     heartbeatTimer = null;
+    registeredGeneration = -1;
     constructor(queue, opts = {}) {
         super();
         if ((opts.concurrency ?? 4) < 1)
@@ -70,6 +72,23 @@ export class WorkerBase extends EventEmitter {
     async waitUntilReady() {
         await this.readyPromise;
     }
+    /**
+     * 'ready' is replayed to listeners attached after it fired: with autorun the
+     * loop starts inside the constructor, so a plain once-only event could be
+     * missed by `new Worker(...).on('ready', ...)` patterns.
+     */
+    on(event, listener) {
+        if (event === 'ready' && this.readyFired)
+            listener();
+        return super.on(event, listener);
+    }
+    once(event, listener) {
+        if (event === 'ready' && this.readyFired) {
+            listener();
+            return this;
+        }
+        return super.once(event, listener);
+    }
     /**
      * Cooperative cancel of a locally active job (mirrors the official client):
      * marks the job and emits 'cancelled'; the processor is expected to check
@@ -92,20 +111,26 @@ export class WorkerBase extends EventEmitter {
     isJobCancelled(jobId) {
         return this.cancelledJobs.has(jobId);
     }
-    /** Graceful shutdown: stop pulling, wait for in-flight jobs. */
-    async close() {
+    /** Graceful shutdown: stop pulling, wait for in-flight jobs.
+     * With `force` the wait for in-flight jobs is skipped (parity with the
+     * official client's `close(force)`). */
+    async close(force = false) {
         if (this.closedFlag)
             return;
         this.stopped = true;
         if (this.loopPromise)
             await this.loopPromise;
-        while (this.active.size > 0)
+        while (!force && this.active.size > 0)
             await sleep(20);
         if (this.heartbeatTimer) {
             clearInterval(this.heartbeatTimer);
             this.heartbeatTimer = null;
         }
-        await this.safeCall({ cmd: 'UnregisterWorker', workerId: this.workerId });
+        // Only unregister when the loop actually registered (autorun: false and
+        // never run() means the server does not know this worker).
+        if (this.registeredGeneration >= 0) {
+            await this.safeCall({ cmd: 'UnregisterWorker', workerId: this.workerId });
+        }
         this.connection.close();
         this.closedFlag = true;
         this.running = false;

package/dist/worker.js

@@ -32,6 +32,7 @@ export class Worker extends WorkerBase {
     async loop() {
         await this.register();
         this.readyResolve?.();
+        this.readyFired = true;
         this.emit('ready');
         this.startHeartbeat();
         let backoffIdx = 0;
@@ -63,6 +64,12 @@ export class Worker extends WorkerBase {
             await sleep(20);
             return;
         }
+        // The registration is per-connection server state: after a reconnect the
+        // server no longer knows this worker (ListWorkers, skipIfNoWorker crons).
+        // Detect the new connection generation and re-register before pulling.
+        if (this.connection.isConnected && this.connection.generation !== this.registeredGeneration) {
+            await this.register();
+        }
         const response = await this.connection.call({
             cmd: 'PULLB',
             queue: this.queue,
@@ -147,5 +154,6 @@ export class Worker extends WorkerBase {
             pid: process.pid,
             startedAt: Date.now(),
         });
+        this.registeredGeneration = this.connection.generation;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunqueue-client",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Cross-runtime TypeScript client for the bunqueue job queue server — Node.js, Bun, Deno and Cloudflare Workers",
   "license": "MIT",
   "type": "module",

package/src/bunqueue/aging.ts

@@ -0,0 +1,62 @@
+/**
+ * Bunqueue Simple Mode — priority aging.
+ * Port of src/client/bunqueue/aging.ts: automatically boosts the priority of
+ * old waiting jobs. Same semantics; the job scan goes over TCP (GetJobs on
+ * the waiting and prioritized states) instead of the embedded manager.
+ */
+
+import type { Queue } from '../queue.js';
+import type { PriorityAgingConfig } from './types.js';
+
+export class PriorityAger<T = unknown> {
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private readonly config: PriorityAgingConfig;
+  private readonly queue: Queue<T>;
+
+  constructor(config: PriorityAgingConfig, queue: Queue<T>) {
+    this.config = config;
+    this.queue = queue;
+  }
+
+  start(): void {
+    const interval = this.config.interval ?? 60000;
+    this.timer = setInterval(() => {
+      void this.tick();
+    }, interval);
+    this.timer.unref?.();
+  }
+
+  private async tick(): Promise<void> {
+    const minAge = this.config.minAge ?? 60000;
+    const boost = this.config.boost ?? 1;
+    const maxPriority = this.config.maxPriority ?? 100;
+    const maxScan = this.config.maxScan ?? 100;
+
+    // Both waiting and prioritized jobs (priority > 0 means "prioritized")
+    const [waiting, prioritized] = await Promise.all([
+      this.queue.getJobs({ state: 'waiting', start: 0, end: maxScan }),
+      this.queue.getJobs({ state: 'prioritized', start: 0, end: maxScan }),
+    ]);
+    const jobs = [...waiting, ...prioritized];
+    const now = Date.now();
+
+    for (const job of jobs) {
+      const age = now - job.timestamp;
+      if (age >= minAge && job.priority < maxPriority) {
+        const newPriority = Math.min(job.priority + boost, maxPriority);
+        try {
+          await this.queue.changeJobPriority(job.id, { priority: newPriority });
+        } catch {
+          // Best-effort — the job may have been processed meanwhile
+        }
+      }
+    }
+  }
+
+  destroy(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+}