@blokjs/trigger-worker 0.2.1 → 0.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@blokjs/trigger-worker",
-	"version": "0.2.1",
+	"version": "0.6.1",
 	"description": "Worker-based trigger for Blok workflows - supports background job processing with concurrency, retries, and scheduling",
 	"type": "module",
 	"main": "dist/index.js",
@@ -14,28 +14,50 @@
 	"author": "Deskree Technologies Inc.",
 	"license": "Apache-2.0",
 	"dependencies": {
-		"@blokjs/helper": "^0.2.0",
-		"@blokjs/runner": "^0.2.0",
-		"@blokjs/shared": "^0.2.0",
+		"@blokjs/helper": "^0.6.1",
+		"@blokjs/runner": "^0.6.1",
+		"@blokjs/shared": "^0.6.1",
 		"@opentelemetry/api": "^1.9.0",
 		"uuid": "^11.1.0"
 	},
 	"devDependencies": {
+		"@types/amqplib": "^0.10.8",
 		"@types/node": "^22.15.21",
 		"@types/uuid": "^11.0.0",
+		"pg-boss": "^10.0.0",
 		"typescript": "^5.8.3",
 		"vitest": "^4.0.18"
 	},
 	"peerDependencies": {
+		"@aws-sdk/client-sqs": "^3.0.0",
+		"amqplib": "^0.10.0",
 		"bullmq": "^5.67.2",
-		"ioredis": "^5.9.2"
+		"ioredis": "^5.9.2",
+		"kafkajs": "^2.2.0",
+		"nats": "",
+		"pg-boss": ""
 	},
 	"peerDependenciesMeta": {
+		"@aws-sdk/client-sqs": {
+			"optional": true
+		},
+		"amqplib": {
+			"optional": true
+		},
 		"bullmq": {
 			"optional": true
 		},
 		"ioredis": {
 			"optional": true
+		},
+		"kafkajs": {
+			"optional": true
+		},
+		"nats": {
+			"optional": true
+		},
+		"pg-boss": {
+			"optional": true
 		}
 	},
 	"private": false,

package/src/WorkerTrigger.test.ts

@@ -8,6 +8,7 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import type { WorkerAdapter, WorkerJob, WorkerQueueStats } from "./WorkerTrigger";
 import { InMemoryAdapter } from "./adapters/InMemoryAdapter";
+import { computeXDelayHoldMs } from "./adapters/NATSAdapter";
 
 // ============================================================================
 // WorkerJob Interface Tests
@@ -407,23 +408,22 @@ describe("BullMQAdapter", () => {
 	});
 
 	it("should use default values when env vars not set", () => {
-		const originalHost = process.env.REDIS_HOST;
-		const originalPort = process.env.REDIS_PORT;
-
-		delete process.env.REDIS_HOST;
-		delete process.env.REDIS_PORT;
+		// Pure: don't mutate process.env (races with other parallel workers
+		// when running via `nx run-many -t test` and pollutes other tests).
+		// Simulate "env unset" by reading from an explicit snapshot rather
+		// than the live process.env.
+		const fakeEnv: Record<string, string | undefined> = {
+			REDIS_HOST: undefined,
+			REDIS_PORT: undefined,
+		};
 
 		const config = {
-			host: process.env.REDIS_HOST || "localhost",
-			port: Number.parseInt(process.env.REDIS_PORT || "6379", 10),
+			host: fakeEnv.REDIS_HOST || "localhost",
+			port: Number.parseInt(fakeEnv.REDIS_PORT || "6379", 10),
 		};
 
 		expect(config.host).toBe("localhost");
 		expect(config.port).toBe(6379);
-
-		// Restore
-		process.env.REDIS_HOST = originalHost;
-		process.env.REDIS_PORT = originalPort;
 	});
 });
 
@@ -482,7 +482,7 @@ describe("Exponential Backoff", () => {
 		const maxDelay = 30000;
 
 		const delays = [0, 1, 2, 3, 4, 5].map((attempt) => {
-			const exponential = Math.min(base * Math.pow(2, attempt), maxDelay);
+			const exponential = Math.min(base * 2 ** attempt, maxDelay);
 			return exponential;
 		});
 
@@ -498,13 +498,43 @@ describe("Exponential Backoff", () => {
 		const base = 1000;
 		const maxDelay = 30000;
 
-		const delay = Math.min(base * Math.pow(2, 10), maxDelay);
+		const delay = Math.min(base * 2 ** 10, maxDelay);
 		expect(delay).toBe(30000);
 	});
 
 	it("should support custom base delay", () => {
 		const base = 500;
-		const exponential = base * Math.pow(2, 2);
+		const exponential = base * 2 ** 2;
 		expect(exponential).toBe(2000);
 	});
 });
+
+// ============================================================================
+// NATSAdapter — computeXDelayHoldMs (Tier 2 polish: x-delay enforcement)
+// ============================================================================
+
+describe("NATSAdapter — computeXDelayHoldMs", () => {
+	it("returns 0 when no delay was set", () => {
+		expect(computeXDelayHoldMs(0, 1_000_000, 1_000_000)).toBe(0);
+		expect(computeXDelayHoldMs(-50, 1_000_000, 1_000_000)).toBe(0);
+	});
+
+	it("returns the full delay when the message just arrived", () => {
+		// createdMs == nowMs (just published), delay 5s → wait 5s.
+		expect(computeXDelayHoldMs(5000, 2_000_000, 2_000_000)).toBe(5000);
+	});
+
+	it("returns the remaining delay when partially elapsed", () => {
+		// Published 2s ago, delay 5s → wait 3s remaining.
+		expect(computeXDelayHoldMs(5000, 1_000_000, 1_002_000)).toBe(3000);
+	});
+
+	it("returns 0 when the delay has already elapsed", () => {
+		// Published 10s ago, delay 5s → fire immediately.
+		expect(computeXDelayHoldMs(5000, 1_000_000, 1_010_000)).toBe(0);
+	});
+
+	it("clamps to 0 when nowMs is far in the future", () => {
+		expect(computeXDelayHoldMs(5000, 1_000_000, 9_999_999)).toBe(0);
+	});
+});

package/src/WorkerTrigger.ts

@@ -19,14 +19,23 @@
  *    - Ack on success, retry or DLQ on failure
  */
 
-import type { HelperResponse, WorkerTriggerOpts } from "@blokjs/helper";
+import { type HelperResponse, type WorkerTriggerOpts, tryParseDuration } from "@blokjs/helper";
 import {
+	type BlokService,
+	ConcurrencyLimitError,
+	ConcurrencyMetrics,
+	DebounceCoordinator,
 	DefaultLogger,
+	DeferredDispatchSignal,
 	type GlobalOptions,
-	type BlokService,
+	Janitor,
 	NodeMap,
+	QueueExpiredError,
+	RunTracker,
 	TriggerBase,
 	type TriggerResponse,
+	createConcurrencyBackend,
+	createDebounceBackend,
 } from "@blokjs/runner";
 import type { Context, RequestContext } from "@blokjs/shared";
 import { type Span, SpanStatusCode, metrics, trace } from "@opentelemetry/api";
@@ -165,11 +174,31 @@ export abstract class WorkerTrigger extends TriggerBase {
 		process.env.PROJECT_VERSION || "0.0.1",
 	);
 	protected readonly logger = new DefaultLogger();
-	protected abstract adapter: WorkerAdapter;
+	/**
+	 * v0.7 PR 5 — the "default" adapter, used when a workflow's
+	 * `trigger.worker.provider` field is omitted AND the
+	 * `BLOK_WORKER_ADAPTER` env var is unset. Subclasses MAY set this
+	 * for back-compat with the pre-v0.7 single-adapter pattern
+	 * (`class WorkerServer extends WorkerTrigger { protected adapter = new NATSWorkerAdapter() }`).
+	 *
+	 * When unset AND no per-workflow provider is specified, the factory
+	 * falls back to `in-memory`. The factory pool (`adapters/factory.ts`)
+	 * tracks one connected adapter per provider so multiple workflows
+	 * with the same provider share a single broker connection.
+	 */
+	protected adapter?: WorkerAdapter;
 
 	/** Active queues being processed */
 	protected activeQueues: Set<string> = new Set();
 
+	/**
+	 * v0.7 PR 5 — adapter pool, keyed by provider name. Populated lazily
+	 * inside `listen()` as workflows are matched to providers. Each
+	 * adapter is connected once and reused across workflows that share
+	 * its provider. Drained in `stop()`.
+	 */
+	protected adapterPool: Map<string, WorkerAdapter> = new Map();
+
 	// Subclasses provide these
 	protected abstract nodes: Record<string, BlokService<unknown>>;
 	protected abstract workflows: Record<string, HelperResponse>;
@@ -205,19 +234,84 @@ export abstract class WorkerTrigger extends TriggerBase {
 		const startTime = this.startCounter();
 
 		try {
-			// Connect to job backend
-			await this.adapter.connect();
-			this.logger.log(`Connected to ${this.adapter.provider} worker system`);
-
-			// Register health dependency
-			this.registerHealthDependency(`worker-${this.adapter.provider}`, async () => {
-				const healthy = await this.adapter.healthCheck();
-				return {
-					status: healthy ? ("healthy" as const) : ("unhealthy" as const),
-					lastChecked: Date.now(),
-					message: healthy ? "Connected" : "Connection lost",
-				};
-			});
+			// Tier 2 #6 follow-up · install the cross-process concurrency
+			// backend (NATS KV) when the operator opted in via
+			// `BLOK_CONCURRENCY_BACKEND=nats-kv`. Default null preserves the
+			// existing in-process behavior.
+			//
+			// PR 3 D1 — record install attempts via OTel counter.
+			try {
+				const backend = createConcurrencyBackend();
+				if (backend) {
+					await backend.connect();
+					RunTracker.getInstance().setConcurrencyBackend(backend);
+					ConcurrencyMetrics.getInstance().recordBackendInstall({
+						backend: backend.name,
+						status: "success",
+					});
+					this.logger.log(`[concurrency] backend installed: ${backend.name}`);
+				}
+			} catch (err) {
+				ConcurrencyMetrics.getInstance().recordBackendInstall({
+					backend: "unknown",
+					status: "failure",
+				});
+				this.logger.error(
+					`[concurrency] backend install failed: ${err instanceof Error ? err.message : String(err)}; falling back to in-process behavior`,
+				);
+			}
+
+			// Tier C #1 · install the cross-process debounce backend
+			// (NATS KV / Redis) when the operator opted in via
+			// `BLOK_DEBOUNCE_BACKEND`. Default unset = the existing
+			// in-process behavior is preserved. On connect failure, log +
+			// fall back to in-memory coordination.
+			try {
+				const debounceBackend = createDebounceBackend();
+				if (debounceBackend) {
+					const leaseRaw = process.env.BLOK_DEBOUNCE_OWNER_LEASE_MS;
+					if (leaseRaw && /^\d+$/.test(leaseRaw)) {
+						DebounceCoordinator.getInstance().setOwnerLeaseMs(Number(leaseRaw));
+					}
+					await debounceBackend.connect();
+					DebounceCoordinator.getInstance().setBackend(debounceBackend);
+					this.logger.log(`[debounce] backend installed: ${debounceBackend.name}`);
+				}
+			} catch (err) {
+				this.logger.error(
+					`[debounce] backend install failed: ${err instanceof Error ? err.message : String(err)}; falling back to in-memory coordination`,
+				);
+			}
+
+			// Tier 2 quick-wins follow-up · install crash handlers + recover
+			// orphaned runs from a previous (dead) process. Idempotent + opt-out
+			// via `BLOK_CRASH_AUTOFLIP_DISABLED=1`.
+			try {
+				WorkerTrigger.installCrashHandlers(this.logger);
+				const orphaned = WorkerTrigger.recoverOrphanedRuns(undefined, this.logger);
+				if (orphaned > 0) {
+					this.logger.log(`[crash-autoflip] flipped ${orphaned} orphaned run(s) to crashed on boot`);
+				}
+			} catch (err) {
+				this.logger.error(`[crash-autoflip] setup failed: ${err instanceof Error ? err.message : String(err)}`);
+			}
+
+			// Tier 2 follow-up · start the periodic storage janitor.
+			// Idempotent (singleton); opt-out via `BLOK_JANITOR_DISABLED=1`.
+			try {
+				Janitor.getInstance(RunTracker.getInstance().getStore(), this.logger).start();
+			} catch (err) {
+				this.logger.error(`[janitor] setup failed: ${err instanceof Error ? err.message : String(err)}`);
+			}
+
+			// Tier 2 follow-up · install graceful shutdown handlers
+			// (SIGTERM / SIGINT). Idempotent; opt-out via
+			// `BLOK_GRACEFUL_SHUTDOWN_DISABLED=1`.
+			try {
+				WorkerTrigger.installShutdownHandlers(this, this.logger);
+			} catch (err) {
+				this.logger.error(`[shutdown] setup failed: ${err instanceof Error ? err.message : String(err)}`);
+			}
 
 			// Find all workflows with worker triggers
 			const workerWorkflows = this.getWorkerWorkflows();
@@ -227,16 +321,19 @@ export abstract class WorkerTrigger extends TriggerBase {
 				return this.endCounter(startTime);
 			}
 
-			// Start processing each queue
+			// Start processing each queue, dispatching to the right adapter
+			// based on the workflow's `provider` field (with back-compat
+			// fallback to `this.adapter` when subclasses still set it).
 			for (const workflow of workerWorkflows) {
 				const config = workflow.config.trigger?.worker as WorkerTriggerOpts;
+				const adapter = await this.resolveAdapterForWorkflow(config);
 				this.logger.log(
-					`Starting worker for queue: ${config.queue} (concurrency=${config.concurrency}, retries=${config.retries})`,
+					`Starting worker for queue: ${config.queue} via ${adapter.provider} (concurrency=${config.concurrency}, retries=${config.retries})`,
 				);
 
 				this.activeQueues.add(config.queue);
 
-				await this.adapter.process(config, async (job) => {
+				await adapter.process(config, async (job) => {
 					await this.handleJob(job, workflow, config);
 				});
 			}
@@ -259,12 +356,28 @@ export abstract class WorkerTrigger extends TriggerBase {
 	 * Stop all workers and disconnect
 	 */
 	async stop(): Promise<void> {
+		// Stop each queue on its owning adapter — adapters are tracked
+		// in the pool so multi-provider workers all drain cleanly.
 		for (const queue of this.activeQueues) {
-			await this.adapter.stopProcessing(queue);
+			for (const adapter of this.adapterPool.values()) {
+				try {
+					await adapter.stopProcessing(queue);
+				} catch {
+					/* swallow — adapter may not own this queue */
+				}
+			}
 			this.logger.log(`Stopped processing queue: ${queue}`);
 		}
 		this.activeQueues.clear();
-		await this.adapter.disconnect();
+		// Disconnect every adapter we ever connected.
+		for (const adapter of this.adapterPool.values()) {
+			try {
+				await adapter.disconnect();
+			} catch (err) {
+				this.logger.error(`[blok][worker] disconnect failed: ${(err as Error).message}`);
+			}
+		}
+		this.adapterPool.clear();
 		this.destroyMonitoring();
 		this.logger.log("Worker trigger stopped");
 	}
@@ -291,14 +404,33 @@ export abstract class WorkerTrigger extends TriggerBase {
 			jobId?: string;
 		},
 	): Promise<string> {
-		return this.adapter.addJob(queue, data, opts);
+		// Back-compat: when a subclass set `this.adapter`, use it.
+		// Otherwise dispatch via the first pool adapter — typically the
+		// only one when a process owns one trigger workflow.
+		const adapter =
+			this.adapter ??
+			(this.adapterPool.size > 0 ? (this.adapterPool.values().next().value as WorkerAdapter) : undefined);
+		if (!adapter) {
+			throw new Error(
+				"[blok][worker] dispatch() called before any adapter is connected. Call listen() first, or set this.adapter on the subclass.",
+			);
+		}
+		return adapter.addJob(queue, data, opts);
 	}
 
 	/**
 	 * Get statistics for a queue
 	 */
 	async getQueueStats(queue: string): Promise<WorkerQueueStats> {
-		return this.adapter.getQueueStats(queue);
+		const adapter =
+			this.adapter ??
+			(this.adapterPool.size > 0 ? (this.adapterPool.values().next().value as WorkerAdapter) : undefined);
+		if (!adapter) {
+			throw new Error(
+				"[blok][worker] getQueueStats() called before any adapter is connected. Call listen() first, or set this.adapter on the subclass.",
+			);
+		}
+		return adapter.getQueueStats(queue);
 	}
 
 	/**
@@ -308,6 +440,60 @@ export abstract class WorkerTrigger extends TriggerBase {
 		return Array.from(this.activeQueues);
 	}
 
+	/**
+	 * v0.7 PR 5 — pick the adapter for a workflow's `provider` field.
+	 *
+	 * Resolution order:
+	 *   1. Subclass-set `this.adapter` (back-compat: pre-v0.7 pattern
+	 *      where one process binds to one adapter at construction time).
+	 *   2. Per-workflow `provider` field, looked up via the factory.
+	 *   3. `BLOK_WORKER_ADAPTER` env var.
+	 *   4. `in-memory` fallback.
+	 *
+	 * Adapters are connected on first use and pooled per provider so
+	 * multiple workflows sharing a provider share one broker
+	 * connection. Health-dependency registration also happens here so
+	 * each provider is tracked individually in `/health`.
+	 */
+	protected async resolveAdapterForWorkflow(config: WorkerTriggerOpts): Promise<WorkerAdapter> {
+		// Subclass override wins for back-compat.
+		if (this.adapter) {
+			if (!this.adapter.isConnected()) {
+				await this.adapter.connect();
+				this.logger.log(`Connected to ${this.adapter.provider} worker system (subclass adapter)`);
+				this.registerAdapterHealth(this.adapter);
+			}
+			// Pool-track so stop() can drain it.
+			this.adapterPool.set(this.adapter.provider, this.adapter);
+			return this.adapter;
+		}
+
+		// Lazy-import the factory so the worker package doesn't pull in
+		// every adapter on import — only the ones actually exercised.
+		const { resolveProvider, createWorkerAdapter } = await import("./adapters/factory");
+		const provider = resolveProvider(config.provider);
+		let adapter = this.adapterPool.get(provider);
+		if (!adapter) {
+			adapter = createWorkerAdapter(provider);
+			await adapter.connect();
+			this.logger.log(`Connected to ${adapter.provider} worker system`);
+			this.registerAdapterHealth(adapter);
+			this.adapterPool.set(provider, adapter);
+		}
+		return adapter;
+	}
+
+	private registerAdapterHealth(adapter: WorkerAdapter): void {
+		this.registerHealthDependency(`worker-${adapter.provider}`, async () => {
+			const healthy = await adapter.healthCheck();
+			return {
+				status: healthy ? ("healthy" as const) : ("unhealthy" as const),
+				lastChecked: Date.now(),
+				message: healthy ? "Connected" : "Connection lost",
+			};
+		});
+	}
+
 	/**
 	 * Get all workflows that have worker triggers
 	 */
@@ -373,7 +559,7 @@ export abstract class WorkerTrigger extends TriggerBase {
 
 				// Store worker metadata in context
 				if (!ctx.vars) ctx.vars = {};
-				ctx.vars["_worker_job"] = {
+				ctx.vars._worker_job = {
 					id: job.id,
 					queue: job.queue,
 					attempts: String(job.attempts),
@@ -388,6 +574,15 @@ export abstract class WorkerTrigger extends TriggerBase {
 					`Processing job ${jobId} from ${config.queue} (attempt ${job.attempts + 1}/${job.maxRetries + 1})`,
 				);
 
+				// v0.6 · apply the merged middleware chain (process-global →
+				// workflow-level → trigger-level) on the same ctx the main
+				// workflow will see. State mutations from middleware
+				// (e.g. ctx.state.identity) carry forward. Middleware that
+				// throws (via `@blokjs/throw`) propagates to the outer
+				// catch and is routed through the worker's retry / DLQ
+				// logic exactly like a main-workflow error.
+				await this.applyMiddlewareChain(ctx, this.nodeMap);
+
 				// Execute workflow with timeout if configured
 				let response: TriggerResponse;
 				if (config.timeout && config.timeout > 0) {
@@ -420,6 +615,74 @@ export abstract class WorkerTrigger extends TriggerBase {
 				await job.complete();
 			} catch (error) {
 				const errorMessage = (error as Error).message;
+
+				// Tier 2 #5 + #7 — deferred dispatch (delay/TTL/debounce).
+				// The run was deferred to a future timer; ACK without retry.
+				// The in-process scheduler owns the eventual dispatch, NOT
+				// the broker — re-queueing here would create a duplicate.
+				if (error instanceof DeferredDispatchSignal) {
+					span.setAttribute("success", false);
+					span.setAttribute("deferred", true);
+					span.setAttribute("deferred_status", error.info.status);
+					span.setStatus({ code: SpanStatusCode.OK, message: `deferred:${error.info.status}` });
+
+					this.logger.log(
+						`[scheduling] job ${jobId} runId=${error.info.runId} status=${error.info.status} ` +
+							`scheduledAt=${error.info.scheduledAt} pingCount=${error.info.pingCount} → ACK (no requeue)`,
+					);
+
+					await job.complete();
+					return;
+				}
+
+				// PR 1-5 polish — queue-mode TTL elapsed. The run is already
+				// flipped to `expired` (see TriggerBase queue branch); ACK
+				// without retry so the broker doesn't redeliver — the run
+				// will never succeed (timer won't re-fire). Distinct from
+				// the throttled NACK below.
+				if (error instanceof QueueExpiredError) {
+					span.setAttribute("success", false);
+					span.setAttribute("queue_expired", true);
+					span.setStatus({ code: SpanStatusCode.OK, message: "queue_expired" });
+
+					this.logger.log(
+						`[concurrency] job ${jobId} runId=${error.info.runId} key='${error.info.concurrencyKey}' ` +
+							`queueExpiredAt=${error.info.queueExpiredAt} → ACK (no requeue, run expired)`,
+					);
+
+					await job.complete();
+					return;
+				}
+
+				// Tier 2 #6 — concurrency gate denial. Distinct from a normal
+				// failure: NACK with redelivery so the broker re-queues the
+				// job with its existing back-off semantics. Doesn't count
+				// against the workflow's retry budget (different invariant).
+				// We always pass `willRetry: true` regardless of `job.attempts`
+				// because throttling is a transient resource state, not a
+				// permanent failure.
+				if (error instanceof ConcurrencyLimitError) {
+					span.setAttribute("success", false);
+					span.setAttribute("will_retry", true);
+					span.setAttribute("throttled", true);
+					span.setStatus({ code: SpanStatusCode.OK, message: "concurrency_limit_reached" });
+
+					this.logger.log(
+						`[concurrency] job ${jobId} key='${error.info.concurrencyKey}' ` +
+							`limit=${error.info.concurrencyLimit} inFlight=${error.info.currentInFlight} → NACK + redelivery`,
+					);
+
+					workerRetries.add(1, {
+						env: process.env.NODE_ENV,
+						queue: config.queue,
+						workflow_name: this.configuration?.name || "unknown",
+						reason: "throttled",
+					});
+
+					await job.fail(error as Error, true);
+					return;
+				}
+
 				const shouldRetry = job.attempts < job.maxRetries;
 
 				// Set span error
@@ -429,8 +692,17 @@ export abstract class WorkerTrigger extends TriggerBase {
 				span.setStatus({ code: SpanStatusCode.ERROR, message: errorMessage });
 
 				if (shouldRetry) {
-					// Retry with exponential backoff
-					const backoffMs = this.calculateBackoff(job.attempts, config.delay);
+					// Retry with exponential backoff. `config.delay` widened to
+					// `string | number | undefined` in Tier 2 #5 (duration strings).
+					// `calculateBackoff` only handles numbers; normalize via
+					// tryParseDuration. Fail-open to undefined → default backoff.
+					const delayMs =
+						typeof config.delay === "number"
+							? config.delay
+							: typeof config.delay === "string"
+								? (tryParseDuration(config.delay) ?? undefined)
+								: undefined;
+					const backoffMs = this.calculateBackoff(job.attempts, delayMs);
 					workerRetries.add(1, {
 						env: process.env.NODE_ENV,
 						queue: config.queue,
@@ -492,7 +764,7 @@ export abstract class WorkerTrigger extends TriggerBase {
 	protected calculateBackoff(attempt: number, baseDelay?: number): number {
 		const base = baseDelay ?? 1000;
 		const maxDelay = 30000; // 30 seconds max
-		const exponential = Math.min(base * Math.pow(2, attempt), maxDelay);
+		const exponential = Math.min(base * 2 ** attempt, maxDelay);
 		const jitter = Math.random() * exponential * 0.1; // 10% jitter
 		return Math.floor(exponential + jitter);
 	}

package/src/adapters/InMemoryAdapter.ts

@@ -122,8 +122,14 @@ export class InMemoryAdapter implements WorkerAdapter {
 			throw new Error("Not connected. Call connect() first.");
 		}
 
-		if (!this.jobs.has(queue)) {
-			this.jobs.set(queue, []);
+		// Get-or-init the per-queue job list. Same pattern as `stats`
+		// below — the previous code used `set-if-absent` then `.get()!`,
+		// but that non-null assertion is what biome flags. Pulling the
+		// reference once and seeding when missing keeps the type exact.
+		let jobs = this.jobs.get(queue);
+		if (!jobs) {
+			jobs = [];
+			this.jobs.set(queue, jobs);
 		}
 		if (!this.stats.has(queue)) {
 			this.stats.set(queue, { completed: 0, failed: 0 });
@@ -146,8 +152,6 @@ export class InMemoryAdapter implements WorkerAdapter {
 			job.scheduledAt = new Date(Date.now() + job.delay);
 		}
 
-		const jobs = this.jobs.get(queue)!;
-
 		// Insert sorted by priority (higher first)
 		const insertIdx = jobs.findIndex((j) => j.status === "waiting" && j.priority < job.priority);
 		if (insertIdx >= 0) {
@@ -245,7 +249,7 @@ export class InMemoryAdapter implements WorkerAdapter {
 
 				if (requeue && internalJob.attempts < internalJob.maxRetries) {
 					// Requeue with backoff
-					const backoff = Math.min(1000 * Math.pow(2, internalJob.attempts), 30000);
+					const backoff = Math.min(1000 * 2 ** internalJob.attempts, 30000);
 					internalJob.status = "delayed";
 					internalJob.scheduledAt = new Date(Date.now() + backoff);
 				} else {