groupmq-plus 1.1.0 → 1.1.2

package/dist/index.d.cts

@@ -37,6 +37,7 @@ declare class Job<T = any> {
   readonly timestamp: number;
   readonly orderMs?: number;
   readonly status: Status$1 | 'unknown';
+  readonly parentId?: string;
   constructor(args: {
     queue: Queue<T>;
     id: string;
@@ -56,6 +57,7 @@ declare class Job<T = any> {
     timestamp: number;
     orderMs?: number;
     status?: Status$1 | 'unknown';
+    parentId?: string;
   });
   getState(): Promise<Status$1 | 'stuck' | 'waiting-children' | 'prioritized' | 'unknown'>;
   toJSON(): {
@@ -84,6 +86,31 @@ declare class Job<T = any> {
   retry(_state?: Extract<Status$1, 'completed' | 'failed'>): Promise<void>;
   updateData(jobData: T): Promise<void>;
   update(jobData: T): Promise<void>;
+  /**
+   * Wait until this job is completed or failed.
+   * @param timeoutMs Optional timeout in milliseconds (0 = no timeout)
+   */
+  waitUntilFinished(timeoutMs?: number): Promise<unknown>;
+  /**
+   * Get all child jobs of this job (if it's a parent in a flow).
+   * @returns Array of child Job instances
+   */
+  getChildren(): Promise<Job<any>[]>;
+  /**
+   * Get the return values of all child jobs in a flow.
+   * @returns Object mapping child job IDs to their return values
+   */
+  getChildrenValues(): Promise<Record<string, any>>;
+  /**
+   * Get the number of remaining child jobs that haven't completed yet.
+   * @returns Number of remaining dependencies, or null if not a parent job
+   */
+  getDependenciesCount(): Promise<number | null>;
+  /**
+   * Get the parent job of this job (if it's a child in a flow).
+   * @returns Parent Job instance, or undefined if no parent or parent was deleted
+   */
+  getParent(): Promise<Job<any> | undefined>;
   static fromReserved<T = any>(queue: Queue<T>, reserved: ReservedJob<T>, meta?: {
     processedOn?: number;
     finishedOn?: number;
@@ -493,6 +520,9 @@ declare class Queue<T = any> {
   orderingDelayMs: number;
   name: string;
   private _consecutiveEmptyReserves;
+  private subscriber?;
+  private eventsSubscribed;
+  private waitingJobs;
   private promoterRedis?;
   private promoterRunning;
   private promoterLockId?;
@@ -529,6 +559,18 @@ declare class Queue<T = any> {
    * @returns An object mapping child job IDs to their results
    */
   getFlowResults(parentId: string): Promise<Record<string, any>>;
+  /**
+   * Gets all child job IDs for a parent job in a flow.
+   * @param parentId The ID of the parent job
+   * @returns An array of child job IDs
+   */
+  getFlowChildrenIds(parentId: string): Promise<string[]>;
+  /**
+   * Gets all child jobs for a parent job in a flow.
+   * @param parentId The ID of the parent job
+   * @returns An array of Job instances for all children
+   */
+  getFlowChildren(parentId: string): Promise<Job<any>[]>;
   private addSingle;
   private flushBatch;
   reserve(): Promise<ReservedJob<T> | null>;
@@ -765,6 +807,12 @@ declare class Queue<T = any> {
    * Attempts to mimic BullMQ's Job shape for fields commonly used by BullBoard.
    */
   getJob(id: string): Promise<Job<T>>;
+  private setupSubscriber;
+  private handleJobEvent;
+  /**
+   * Wait for a job to complete or fail, similar to BullMQ's waitUntilFinished.
+   */
+  waitUntilFinished(jobId: string, timeoutMs?: number): Promise<unknown>;
   /**
    * Fetch jobs by statuses, emulating BullMQ's Queue.getJobs API used by BullBoard.
    * Only getter functionality; ordering is best-effort.
@@ -917,7 +965,10 @@ interface DispatchStrategy {
 }
 //#endregion
 //#region src/worker.d.ts
-type BackoffStrategy = (attempt: number) => number;
+declare class UnrecoverableError extends Error {
+  constructor(message?: string);
+}
+type BackoffStrategy = (attempt: number, error: unknown) => number;
 interface WorkerEvents<T = any> extends Record<string, (...args: any[]) => void> {
   error: (error: Error) => void;
   closed: () => void;
@@ -950,10 +1001,10 @@ type WorkerOptions<T> = {
   name?: string;
   /**
    * The function that processes jobs. Must be async and handle job failures gracefully.
-   * @param job The reserved job to process
+   * @param job The Job instance to process, with access to all Job methods
    * @returns Promise that resolves when job is complete
    */
-  handler: (job: ReservedJob<T>) => Promise<unknown>;
+  handler: (job: Job<T>) => Promise<unknown>;
   /**
    * Heartbeat interval in milliseconds to keep jobs alive during processing.
    * Prevents jobs from timing out during long-running operations.
@@ -970,9 +1021,9 @@ type WorkerOptions<T> = {
   /**
    * Error handler called when job processing fails or worker encounters errors
    * @param err The error that occurred
-   * @param job The job that failed (if applicable)
+   * @param job The Job instance that failed (if applicable)
    */
-  onError?: (err: unknown, job?: ReservedJob<T>) => void;
+  onError?: (err: unknown, job?: Job<T>) => void;
   /**
    * Maximum number of retry attempts for failed jobs at the worker level.
    * This overrides the queue's default maxAttempts setting.
@@ -988,9 +1039,11 @@ type WorkerOptions<T> = {
   maxAttempts?: number;
   /**
    * Backoff strategy for retrying failed jobs. Determines delay between retries.
+    * Receives the error object to allow smarter strategies.
    *
    * @default Exponential backoff with jitter (500ms, 1s, 2s, 4s, 8s, 16s, 30s max)
-   * @example (attempt) => Math.min(10000, attempt * 1000) // Linear backoff
+    * @example (attempt, err) =>
+    *   err instanceof RateLimitError ? err.retryAfterMs : Math.min(10000, attempt * 1000)
    *
    * **When to adjust:**
    * - Rate-limited APIs: Use longer delays
@@ -1237,14 +1290,14 @@ declare class _Worker<T = any> extends TypedEventEmitter<WorkerEvents<T>> {
    * For concurrency > 1, returns the oldest job in progress
    */
   getCurrentJob(): {
-    job: ReservedJob<T>;
+    job: Job<T>;
     processingTimeMs: number;
   } | null;
   /**
    * Get information about all currently processing jobs
    */
   getCurrentJobs(): Array<{
-    job: ReservedJob<T>;
+    job: Job<T>;
     processingTimeMs: number;
   }>;
   /**
@@ -1296,5 +1349,5 @@ declare function getWorkersStatus<T = any>(workers: Worker<T>[]): {
   }>;
 };
 //#endregion
-export { AddOptions, BackoffStrategy, BullBoardGroupMQAdapter, FlowJob, FlowOptions, GroupMQBullBoardAdapterOptions, Job, Queue, QueueOptions, RepeatOptions, ReservedJob, Worker, WorkerEvents, WorkerOptions, getWorkersStatus, waitForQueueToEmpty };
+export { AddOptions, BackoffStrategy, BullBoardGroupMQAdapter, FlowJob, FlowOptions, GroupMQBullBoardAdapterOptions, Job, Queue, QueueOptions, RepeatOptions, ReservedJob, UnrecoverableError, Worker, WorkerEvents, WorkerOptions, getWorkersStatus, waitForQueueToEmpty };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -37,6 +37,7 @@ declare class Job<T = any> {
   readonly timestamp: number;
   readonly orderMs?: number;
   readonly status: Status$1 | 'unknown';
+  readonly parentId?: string;
   constructor(args: {
     queue: Queue<T>;
     id: string;
@@ -56,6 +57,7 @@ declare class Job<T = any> {
     timestamp: number;
     orderMs?: number;
     status?: Status$1 | 'unknown';
+    parentId?: string;
   });
   getState(): Promise<Status$1 | 'stuck' | 'waiting-children' | 'prioritized' | 'unknown'>;
   toJSON(): {
@@ -84,6 +86,31 @@ declare class Job<T = any> {
   retry(_state?: Extract<Status$1, 'completed' | 'failed'>): Promise<void>;
   updateData(jobData: T): Promise<void>;
   update(jobData: T): Promise<void>;
+  /**
+   * Wait until this job is completed or failed.
+   * @param timeoutMs Optional timeout in milliseconds (0 = no timeout)
+   */
+  waitUntilFinished(timeoutMs?: number): Promise<unknown>;
+  /**
+   * Get all child jobs of this job (if it's a parent in a flow).
+   * @returns Array of child Job instances
+   */
+  getChildren(): Promise<Job<any>[]>;
+  /**
+   * Get the return values of all child jobs in a flow.
+   * @returns Object mapping child job IDs to their return values
+   */
+  getChildrenValues(): Promise<Record<string, any>>;
+  /**
+   * Get the number of remaining child jobs that haven't completed yet.
+   * @returns Number of remaining dependencies, or null if not a parent job
+   */
+  getDependenciesCount(): Promise<number | null>;
+  /**
+   * Get the parent job of this job (if it's a child in a flow).
+   * @returns Parent Job instance, or undefined if no parent or parent was deleted
+   */
+  getParent(): Promise<Job<any> | undefined>;
   static fromReserved<T = any>(queue: Queue<T>, reserved: ReservedJob<T>, meta?: {
     processedOn?: number;
     finishedOn?: number;
@@ -493,6 +520,9 @@ declare class Queue<T = any> {
   orderingDelayMs: number;
   name: string;
   private _consecutiveEmptyReserves;
+  private subscriber?;
+  private eventsSubscribed;
+  private waitingJobs;
   private promoterRedis?;
   private promoterRunning;
   private promoterLockId?;
@@ -529,6 +559,18 @@ declare class Queue<T = any> {
    * @returns An object mapping child job IDs to their results
    */
   getFlowResults(parentId: string): Promise<Record<string, any>>;
+  /**
+   * Gets all child job IDs for a parent job in a flow.
+   * @param parentId The ID of the parent job
+   * @returns An array of child job IDs
+   */
+  getFlowChildrenIds(parentId: string): Promise<string[]>;
+  /**
+   * Gets all child jobs for a parent job in a flow.
+   * @param parentId The ID of the parent job
+   * @returns An array of Job instances for all children
+   */
+  getFlowChildren(parentId: string): Promise<Job<any>[]>;
   private addSingle;
   private flushBatch;
   reserve(): Promise<ReservedJob<T> | null>;
@@ -765,6 +807,12 @@ declare class Queue<T = any> {
    * Attempts to mimic BullMQ's Job shape for fields commonly used by BullBoard.
    */
   getJob(id: string): Promise<Job<T>>;
+  private setupSubscriber;
+  private handleJobEvent;
+  /**
+   * Wait for a job to complete or fail, similar to BullMQ's waitUntilFinished.
+   */
+  waitUntilFinished(jobId: string, timeoutMs?: number): Promise<unknown>;
   /**
    * Fetch jobs by statuses, emulating BullMQ's Queue.getJobs API used by BullBoard.
    * Only getter functionality; ordering is best-effort.
@@ -917,7 +965,10 @@ interface DispatchStrategy {
 }
 //#endregion
 //#region src/worker.d.ts
-type BackoffStrategy = (attempt: number) => number;
+declare class UnrecoverableError extends Error {
+  constructor(message?: string);
+}
+type BackoffStrategy = (attempt: number, error: unknown) => number;
 interface WorkerEvents<T = any> extends Record<string, (...args: any[]) => void> {
   error: (error: Error) => void;
   closed: () => void;
@@ -950,10 +1001,10 @@ type WorkerOptions<T> = {
   name?: string;
   /**
    * The function that processes jobs. Must be async and handle job failures gracefully.
-   * @param job The reserved job to process
+   * @param job The Job instance to process, with access to all Job methods
    * @returns Promise that resolves when job is complete
    */
-  handler: (job: ReservedJob<T>) => Promise<unknown>;
+  handler: (job: Job<T>) => Promise<unknown>;
   /**
    * Heartbeat interval in milliseconds to keep jobs alive during processing.
    * Prevents jobs from timing out during long-running operations.
@@ -970,9 +1021,9 @@ type WorkerOptions<T> = {
   /**
    * Error handler called when job processing fails or worker encounters errors
    * @param err The error that occurred
-   * @param job The job that failed (if applicable)
+   * @param job The Job instance that failed (if applicable)
    */
-  onError?: (err: unknown, job?: ReservedJob<T>) => void;
+  onError?: (err: unknown, job?: Job<T>) => void;
   /**
    * Maximum number of retry attempts for failed jobs at the worker level.
    * This overrides the queue's default maxAttempts setting.
@@ -988,9 +1039,11 @@ type WorkerOptions<T> = {
   maxAttempts?: number;
   /**
    * Backoff strategy for retrying failed jobs. Determines delay between retries.
+    * Receives the error object to allow smarter strategies.
    *
    * @default Exponential backoff with jitter (500ms, 1s, 2s, 4s, 8s, 16s, 30s max)
-   * @example (attempt) => Math.min(10000, attempt * 1000) // Linear backoff
+    * @example (attempt, err) =>
+    *   err instanceof RateLimitError ? err.retryAfterMs : Math.min(10000, attempt * 1000)
    *
    * **When to adjust:**
    * - Rate-limited APIs: Use longer delays
@@ -1237,14 +1290,14 @@ declare class _Worker<T = any> extends TypedEventEmitter<WorkerEvents<T>> {
    * For concurrency > 1, returns the oldest job in progress
    */
   getCurrentJob(): {
-    job: ReservedJob<T>;
+    job: Job<T>;
     processingTimeMs: number;
   } | null;
   /**
    * Get information about all currently processing jobs
    */
   getCurrentJobs(): Array<{
-    job: ReservedJob<T>;
+    job: Job<T>;
     processingTimeMs: number;
   }>;
   /**
@@ -1296,5 +1349,5 @@ declare function getWorkersStatus<T = any>(workers: Worker<T>[]): {
   }>;
 };
 //#endregion
-export { AddOptions, BackoffStrategy, BullBoardGroupMQAdapter, FlowJob, FlowOptions, GroupMQBullBoardAdapterOptions, Job, Queue, QueueOptions, RepeatOptions, ReservedJob, Worker, WorkerEvents, WorkerOptions, getWorkersStatus, waitForQueueToEmpty };
+export { AddOptions, BackoffStrategy, BullBoardGroupMQAdapter, FlowJob, FlowOptions, GroupMQBullBoardAdapterOptions, Job, Queue, QueueOptions, RepeatOptions, ReservedJob, UnrecoverableError, Worker, WorkerEvents, WorkerOptions, getWorkersStatus, waitForQueueToEmpty };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -235,6 +235,7 @@ var Job = class Job {
 		this.timestamp = args.timestamp;
 		this.orderMs = args.orderMs;
 		this.status = args.status ?? "unknown";
+		this.parentId = args.parentId;
 	}
 	async getState() {
 		return this.status ?? "unknown";
@@ -276,6 +277,46 @@ var Job = class Job {
 	async update(jobData) {
 		await this.updateData(jobData);
 	}
+	/**
+	* Wait until this job is completed or failed.
+	* @param timeoutMs Optional timeout in milliseconds (0 = no timeout)
+	*/
+	async waitUntilFinished(timeoutMs = 0) {
+		return this.queue.waitUntilFinished(this.id, timeoutMs);
+	}
+	/**
+	* Get all child jobs of this job (if it's a parent in a flow).
+	* @returns Array of child Job instances
+	*/
+	async getChildren() {
+		return this.queue.getFlowChildren(this.id);
+	}
+	/**
+	* Get the return values of all child jobs in a flow.
+	* @returns Object mapping child job IDs to their return values
+	*/
+	async getChildrenValues() {
+		return this.queue.getFlowResults(this.id);
+	}
+	/**
+	* Get the number of remaining child jobs that haven't completed yet.
+	* @returns Number of remaining dependencies, or null if not a parent job
+	*/
+	async getDependenciesCount() {
+		return this.queue.getFlowDependencies(this.id);
+	}
+	/**
+	* Get the parent job of this job (if it's a child in a flow).
+	* @returns Parent Job instance, or undefined if no parent or parent was deleted
+	*/
+	async getParent() {
+		if (!this.parentId) return void 0;
+		try {
+			return await this.queue.getJob(this.parentId);
+		} catch (_e) {
+			return;
+		}
+	}
 	static fromReserved(queue, reserved, meta) {
 		return new Job({
 			queue,
@@ -315,6 +356,7 @@ var Job = class Job {
 		const failedReason = (raw.failedReason ?? raw.lastErrorMessage) || void 0;
 		const stacktrace = (raw.stacktrace ?? raw.lastErrorStack) || void 0;
 		const returnvalue = raw.returnvalue ? safeJsonParse$1(raw.returnvalue) : void 0;
+		const parentId = raw.parentId || void 0;
 		return new Job({
 			queue,
 			id,
@@ -333,7 +375,8 @@ var Job = class Job {
 			returnvalue,
 			timestamp: timestampMs || Date.now(),
 			orderMs,
-			status: knownStatus ?? coerceStatus(raw.status)
+			status: knownStatus ?? coerceStatus(raw.status),
+			parentId
 		});
 	}
 	static async fromStore(queue, id) {
@@ -352,6 +395,7 @@ var Job = class Job {
 		const failedReason = (raw.failedReason ?? raw.lastErrorMessage) || void 0;
 		const stacktrace = (raw.stacktrace ?? raw.lastErrorStack) || void 0;
 		const returnvalue = raw.returnvalue ? safeJsonParse$1(raw.returnvalue) : void 0;
+		const parentId = raw.parentId || void 0;
 		const [inProcessing, inDelayed] = await Promise.all([queue.redis.zscore(`${queue.namespace}:processing`, id), queue.redis.zscore(`${queue.namespace}:delayed`, id)]);
 		let status = raw.status;
 		if (inProcessing !== null) status = "active";
@@ -377,7 +421,8 @@ var Job = class Job {
 			returnvalue,
 			timestamp: timestampMs || Date.now(),
 			orderMs,
-			status: coerceStatus(status)
+			status: coerceStatus(status),
+			parentId
 		});
 	}
 };
@@ -469,6 +514,8 @@ function safeJsonParse(input) {
 var Queue = class {
 	constructor(opts) {
 		this._consecutiveEmptyReserves = 0;
+		this.eventsSubscribed = false;
+		this.waitingJobs = /* @__PURE__ */ new Map();
 		this.promoterRunning = false;
 		this.batchBuffer = [];
 		this.flushing = false;
@@ -623,6 +670,38 @@ var Queue = class {
 		}
 		return parsed;
 	}
+	/**
+	* Gets all child job IDs for a parent job in a flow.
+	* @param parentId The ID of the parent job
+	* @returns An array of child job IDs
+	*/
+	async getFlowChildrenIds(parentId) {
+		return this.r.smembers(`${this.ns}:flow:children:${parentId}`);
+	}
+	/**
+	* Gets all child jobs for a parent job in a flow.
+	* @param parentId The ID of the parent job
+	* @returns An array of Job instances for all children
+	*/
+	async getFlowChildren(parentId) {
+		const ids = await this.getFlowChildrenIds(parentId);
+		if (ids.length === 0) return [];
+		const pipe = this.r.multi();
+		for (const id of ids) pipe.hgetall(`${this.ns}:job:${id}`);
+		const rows = await pipe.exec();
+		const jobs = [];
+		for (let i = 0; i < ids.length; i++) {
+			const id = ids[i];
+			const raw = rows?.[i]?.[1] || {};
+			if (!raw || Object.keys(raw).length === 0) {
+				this.logger.warn(`Skipping child job ${id} - not found (likely cleaned up)`);
+				continue;
+			}
+			const job = Job.fromRawHash(this, id, raw);
+			jobs.push(job);
+		}
+		return jobs;
+	}
 	async addSingle(opts) {
 		const now = Date.now();
 		let delayUntil = 0;
@@ -1317,6 +1396,91 @@ var Queue = class {
 	async getJob(id) {
 		return Job.fromStore(this, id);
 	}
+	async setupSubscriber() {
+		if (this.eventsSubscribed && this.subscriber) return;
+		if (!this.subscriber) {
+			this.subscriber = this.r.duplicate();
+			this.subscriber.on("message", (channel, message) => {
+				if (channel === `${this.ns}:events`) this.handleJobEvent(message);
+			});
+			this.subscriber.on("error", (err) => {
+				this.logger.error("Redis error (events subscriber):", err);
+			});
+		}
+		await this.subscriber.subscribe(`${this.ns}:events`);
+		this.eventsSubscribed = true;
+	}
+	handleJobEvent(message) {
+		try {
+			const event = safeJsonParse(message);
+			if (!event || typeof event.id !== "string") return;
+			const waiters = this.waitingJobs.get(event.id);
+			if (!waiters || waiters.length === 0) return;
+			if (event.status === "completed") {
+				const parsed = typeof event.result === "string" ? safeJsonParse(event.result) ?? event.result : event.result;
+				waiters.forEach((w) => w.resolve(parsed));
+			} else if (event.status === "failed") {
+				const info = typeof event.result === "string" ? safeJsonParse(event.result) ?? {} : event.result ?? {};
+				const err = new Error(info && info.message || "Job failed");
+				if (info && typeof info === "object") {
+					if (typeof info.name === "string") err.name = info.name;
+					if (typeof info.stack === "string") err.stack = info.stack;
+				}
+				waiters.forEach((w) => w.reject(err));
+			}
+			this.waitingJobs.delete(event.id);
+		} catch (err) {
+			this.logger.error("Failed to process job event:", err);
+		}
+	}
+	/**
+	* Wait for a job to complete or fail, similar to BullMQ's waitUntilFinished.
+	*/
+	async waitUntilFinished(jobId, timeoutMs = 0) {
+		const job = await this.getJob(jobId);
+		const state = await job.getState();
+		if (state === "completed") return job.returnvalue;
+		if (state === "failed") throw new Error(job.failedReason || "Job failed");
+		await this.setupSubscriber();
+		return new Promise((resolve, reject) => {
+			let timer;
+			let waiter;
+			const cleanup = () => {
+				if (timer) clearTimeout(timer);
+				const current = this.waitingJobs.get(jobId);
+				if (!current) return;
+				const remaining = current.filter((w) => w !== waiter);
+				if (remaining.length === 0) this.waitingJobs.delete(jobId);
+				else this.waitingJobs.set(jobId, remaining);
+			};
+			const wrappedResolve = (value) => {
+				cleanup();
+				resolve(value);
+			};
+			const wrappedReject = (err) => {
+				cleanup();
+				reject(err);
+			};
+			waiter = {
+				resolve: wrappedResolve,
+				reject: wrappedReject
+			};
+			const waiters = this.waitingJobs.get(jobId) ?? [];
+			waiters.push(waiter);
+			this.waitingJobs.set(jobId, waiters);
+			if (timeoutMs > 0) timer = setTimeout(() => {
+				wrappedReject(/* @__PURE__ */ new Error(`Timed out waiting for job ${jobId} to finish`));
+			}, timeoutMs);
+			(async () => {
+				try {
+					const latest = await this.getJob(jobId);
+					const latestState = await latest.getState();
+					if (latestState === "completed") wrappedResolve(latest.returnvalue);
+					else if (latestState === "failed") wrappedReject(new Error(latest.failedReason ?? "Job failed"));
+				} catch (_err) {}
+			})();
+		});
+	}
 	/**
 	* Fetch jobs by statuses, emulating BullMQ's Queue.getJobs API used by BullBoard.
 	* Only getter functionality; ordering is best-effort.
@@ -1511,6 +1675,25 @@ var Queue = class {
 			await this.flushBatch();
 		}
 		await this.stopPromoter();
+		if (this.subscriber) {
+			try {
+				await this.subscriber.unsubscribe(`${this.ns}:events`);
+				await this.subscriber.quit();
+			} catch (_err) {
+				try {
+					this.subscriber.disconnect();
+				} catch (_e) {}
+			}
+			this.subscriber = void 0;
+			this.eventsSubscribed = false;
+		}
+		if (this.waitingJobs.size > 0) {
+			const err = /* @__PURE__ */ new Error("Queue closed");
+			this.waitingJobs.forEach((waiters) => {
+				waiters.forEach((w) => w.reject(err));
+			});
+			this.waitingJobs.clear();
+		}
 		try {
 			await this.r.quit();
 		} catch (_e) {
@@ -1938,6 +2121,12 @@ var AsyncFifoQueue = class {
 
 //#endregion
 //#region src/worker.ts
+var UnrecoverableError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "UnrecoverableError";
+	}
+};
 var TypedEventEmitter = class {
 	constructor() {
 		this.listeners = /* @__PURE__ */ new Map();
@@ -1973,7 +2162,7 @@ var TypedEventEmitter = class {
 		return this;
 	}
 };
-const defaultBackoff = (attempt) => {
+const defaultBackoff = (attempt, _error) => {
 	const base = Math.min(3e4, 2 ** (attempt - 1) * 500);
 	const jitter = Math.floor(base * .25 * Math.random());
 	return base + jitter;
@@ -2396,7 +2585,10 @@ var _Worker = class extends TypedEventEmitter {
 		const oldest = Array.from(this.jobsInProgress)[0];
 		const now = Date.now();
 		return {
-			job: oldest.job,
+			job: Job.fromReserved(this.q, oldest.job, {
+				processedOn: oldest.ts,
+				status: "active"
+			}),
 			processingTimeMs: now - oldest.ts
 		};
 	}
@@ -2406,7 +2598,10 @@ var _Worker = class extends TypedEventEmitter {
 	getCurrentJobs() {
 		const now = Date.now();
 		return Array.from(this.jobsInProgress).map((item) => ({
-			job: item.job,
+			job: Job.fromReserved(this.q, item.job, {
+				processedOn: item.ts,
+				status: "active"
+			}),
 			processingTimeMs: now - item.ts
 		}));
 	}
@@ -2436,7 +2631,7 @@ var _Worker = class extends TypedEventEmitter {
 				} catch (e) {
 					const isConnErr = this.q.isConnectionError(e);
 					if (!isConnErr || !this.stopping) this.logger.error(`Heartbeat error for job ${job.id}:`, e instanceof Error ? e.message : String(e));
-					this.onError?.(e, job);
+					this.onError?.(e, Job.fromReserved(this.q, job, { status: "active" }));
 					if (!isConnErr || !this.stopping) this.emit("error", e instanceof Error ? e : new Error(String(e)));
 				}
 			}, minInterval);
@@ -2447,7 +2642,11 @@ var _Worker = class extends TypedEventEmitter {
 			heartbeatDelayTimer = setTimeout(() => {
 				startHeartbeat();
 			}, heartbeatThreshold);
-			const handlerResult = await this.handler(job);
+			const jobInstance = Job.fromReserved(this.q, job, {
+				processedOn: jobStartWallTime,
+				status: "active"
+			});
+			const handlerResult = await this.handler(jobInstance);
 			if (heartbeatDelayTimer) clearTimeout(heartbeatDelayTimer);
 			if (hbTimer) clearInterval(hbTimer);
 			const finishedAtWall = Date.now();
@@ -2471,7 +2670,11 @@ var _Worker = class extends TypedEventEmitter {
 	* Handle job failure: emit events, retry or dead-letter
 	*/
 	async handleJobFailure(err, job, jobStartWallTime) {
-		this.onError?.(err, job);
+		const jobInstance = Job.fromReserved(this.q, job, {
+			processedOn: jobStartWallTime,
+			status: "active"
+		});
+		this.onError?.(err, jobInstance);
 		this.blockingStats.consecutiveEmptyReserves = 0;
 		this.emptyReserveBackoffMs = 0;
 		try {
@@ -2486,7 +2689,12 @@ var _Worker = class extends TypedEventEmitter {
 			status: "failed"
 		}));
 		const nextAttempt = job.attempts + 1;
-		const backoffMs = this.backoff(nextAttempt);
+		if (err instanceof UnrecoverableError) {
+			this.logger.info(`Unrecoverable error for job ${job.id}: ${err instanceof Error ? err.message : String(err)}. Skipping retries.`);
+			await this.deadLetterJob(err, job, jobStartWallTime, failedAt, nextAttempt);
+			return;
+		}
+		const backoffMs = this.backoff(nextAttempt, err);
 		if (nextAttempt >= this.maxAttempts) {
 			await this.deadLetterJob(err, job, jobStartWallTime, failedAt, nextAttempt);
 			return;
@@ -2553,5 +2761,5 @@ function sleep(ms) {
 }
 
 //#endregion
-export { BullBoardGroupMQAdapter, Job, Queue, Worker, getWorkersStatus, waitForQueueToEmpty };
+export { BullBoardGroupMQAdapter, Job, Queue, UnrecoverableError, Worker, getWorkersStatus, waitForQueueToEmpty };
 //# sourceMappingURL=index.js.map