@blokjs/trigger-worker 0.4.0 → 0.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@blokjs/trigger-worker",
-	"version": "0.4.0",
+	"version": "0.6.2",
 	"description": "Worker-based trigger for Blok workflows - supports background job processing with concurrency, retries, and scheduling",
 	"type": "module",
 	"main": "dist/index.js",
@@ -14,32 +14,50 @@
 	"author": "Deskree Technologies Inc.",
 	"license": "Apache-2.0",
 	"dependencies": {
-		"@blokjs/helper": "^0.4.0",
-		"@blokjs/runner": "^0.4.0",
-		"@blokjs/shared": "^0.4.0",
+		"@blokjs/helper": "^0.6.2",
+		"@blokjs/runner": "^0.6.2",
+		"@blokjs/shared": "^0.6.2",
 		"@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",
-		"nats": ""
+		"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.ts

@@ -24,6 +24,7 @@ import {
 	type BlokService,
 	ConcurrencyLimitError,
 	ConcurrencyMetrics,
+	DebounceCoordinator,
 	DefaultLogger,
 	DeferredDispatchSignal,
 	type GlobalOptions,
@@ -34,6 +35,7 @@ import {
 	TriggerBase,
 	type TriggerResponse,
 	createConcurrencyBackend,
+	createDebounceBackend,
 } from "@blokjs/runner";
 import type { Context, RequestContext } from "@blokjs/shared";
 import { type Span, SpanStatusCode, metrics, trace } from "@opentelemetry/api";
@@ -172,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>;
@@ -239,6 +261,28 @@ export abstract class WorkerTrigger extends TriggerBase {
 				);
 			}
 
+			// 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`.
@@ -269,20 +313,6 @@ export abstract class WorkerTrigger extends TriggerBase {
 				this.logger.error(`[shutdown] setup failed: ${err instanceof Error ? err.message : String(err)}`);
 			}
 
-			// 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",
-				};
-			});
-
 			// Find all workflows with worker triggers
 			const workerWorkflows = this.getWorkerWorkflows();
 
@@ -291,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);
 				});
 			}
@@ -323,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");
 	}
@@ -355,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);
 	}
 
 	/**
@@ -372,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
 	 */
@@ -452,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) {

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 {

package/src/adapters/KafkaAdapter.ts

@@ -0,0 +1,277 @@
+/**
+ * KafkaAdapter — v0.7 PR 5 — Worker adapter backed by Apache Kafka via
+ * `kafkajs`. Consumes from a topic (the `queue` field) with a
+ * consumer-group identifier; produces via the same client.
+ *
+ * Kafka is fundamentally a streaming platform — not a queue — so a
+ * few semantics differ from BullMQ/SQS/RabbitMQ:
+ *
+ *   - **Ordering**: per-partition, not per-topic. Set the partition
+ *     key via the `dedupId` field on `addJob` to keep related
+ *     messages on the same partition.
+ *   - **Retries**: Kafka doesn't have a broker-side retry concept.
+ *     The adapter re-throws on handler failure; offset commit is
+ *     suppressed so the consumer re-polls the message on the next
+ *     cycle. For real retry semantics, layer a dead-letter topic.
+ *   - **Stats**: KafkaJS exposes consumer-group lag via its admin
+ *     client; the lag count is reported as `waiting`. Other stats
+ *     are tracked locally per consumer.
+ *
+ * Requires `kafkajs` as a peer dependency:
+ *
+ *     bun add kafkajs
+ *
+ * Environment variables (read at adapter construction):
+ *   - `KAFKA_BROKERS`           — comma-separated list (default `localhost:9092`).
+ *   - `KAFKA_CLIENT_ID`         — client.id (default `"blok-worker"`).
+ *   - `KAFKA_SASL_USERNAME`     — SASL/PLAIN username (optional).
+ *   - `KAFKA_SASL_PASSWORD`     — SASL/PLAIN password (optional).
+ *   - `KAFKA_SSL`               — when `"true"`, enable TLS.
+ */
+
+import type { WorkerTriggerOpts } from "@blokjs/helper";
+import { v4 as uuid } from "uuid";
+import type { WorkerAdapter, WorkerJob, WorkerQueueStats } from "../WorkerTrigger";
+
+export interface KafkaConfig {
+	brokers: string[];
+	clientId: string;
+	saslUsername?: string;
+	saslPassword?: string;
+	ssl: boolean;
+}
+
+interface KafkaJsHandle {
+	producer?: {
+		connect: () => Promise<void>;
+		disconnect: () => Promise<void>;
+		send: (args: unknown) => Promise<unknown>;
+	};
+	consumers: Map<
+		string,
+		{
+			disconnect: () => Promise<void>;
+			stop: () => Promise<void>;
+			run: (opts: unknown) => Promise<void>;
+		}
+	>;
+	admin?: {
+		connect: () => Promise<void>;
+		disconnect: () => Promise<void>;
+		fetchTopicOffsets: (topic: string) => Promise<Array<{ partition: number; offset: string }>>;
+	};
+}
+
+interface QueueStatsCounters {
+	completed: number;
+	failed: number;
+	active: number;
+}
+
+export class KafkaAdapter implements WorkerAdapter {
+	readonly provider = "kafka" as const;
+	private readonly config: KafkaConfig;
+	// biome-ignore lint/suspicious/noExplicitAny: kafkajs's exported `Kafka` constructor is loosely typed.
+	private kafka: any = null;
+	private handle: KafkaJsHandle = { consumers: new Map() };
+	private connected = false;
+	private stats: Map<string, QueueStatsCounters> = new Map();
+
+	constructor(config?: Partial<KafkaConfig>) {
+		this.config = {
+			brokers: config?.brokers ?? (process.env.KAFKA_BROKERS ?? "localhost:9092").split(",").map((s) => s.trim()),
+			clientId: config?.clientId ?? process.env.KAFKA_CLIENT_ID ?? "blok-worker",
+			saslUsername: config?.saslUsername ?? process.env.KAFKA_SASL_USERNAME,
+			saslPassword: config?.saslPassword ?? process.env.KAFKA_SASL_PASSWORD,
+			ssl: config?.ssl ?? process.env.KAFKA_SSL === "true",
+		};
+	}
+
+	async connect(): Promise<void> {
+		if (this.connected) return;
+		try {
+			// biome-ignore lint/suspicious/noExplicitAny: kafkajs is a runtime-loaded peer dep.
+			const kafkajs: any = await import("kafkajs");
+			const sasl =
+				this.config.saslUsername && this.config.saslPassword
+					? { mechanism: "plain", username: this.config.saslUsername, password: this.config.saslPassword }
+					: undefined;
+			this.kafka = new kafkajs.Kafka({
+				clientId: this.config.clientId,
+				brokers: this.config.brokers,
+				ssl: this.config.ssl,
+				sasl,
+			});
+			this.handle.producer = this.kafka.producer();
+			await this.handle.producer?.connect();
+			this.handle.admin = this.kafka.admin();
+			await this.handle.admin?.connect();
+			this.connected = true;
+		} catch (err) {
+			throw new Error(
+				`[blok][kafka] connect failed: ${(err as Error).message}. Install kafkajs as a peer dependency: bun add kafkajs`,
+			);
+		}
+	}
+
+	async disconnect(): Promise<void> {
+		if (!this.connected) return;
+		for (const [, consumer] of this.handle.consumers) {
+			try {
+				await consumer.disconnect();
+			} catch {
+				/* ignore */
+			}
+		}
+		this.handle.consumers.clear();
+		try {
+			await this.handle.producer?.disconnect();
+		} catch {
+			/* ignore */
+		}
+		try {
+			await this.handle.admin?.disconnect();
+		} catch {
+			/* ignore */
+		}
+		this.connected = false;
+	}
+
+	async process(config: WorkerTriggerOpts, handler: (job: WorkerJob) => Promise<void>): Promise<void> {
+		if (!this.connected) throw new Error("[blok][kafka] not connected. Call connect() first.");
+		const groupId = config.consumerGroup ?? `${config.queue}-group`;
+		const consumer = this.kafka.consumer({ groupId });
+		await consumer.connect();
+		await consumer.subscribe({ topic: config.queue, fromBeginning: config.fromBeginning === true });
+		this.handle.consumers.set(config.queue, consumer);
+		this.stats.set(config.queue, { completed: 0, failed: 0, active: 0 });
+		const stats = this.stats.get(config.queue) as QueueStatsCounters;
+
+		await consumer.run({
+			autoCommit: config.ack !== false,
+			eachMessage: async ({
+				message,
+			}: {
+				message: { key?: Buffer; value?: Buffer; offset: string; timestamp: string; headers?: Record<string, Buffer> };
+			}) => {
+				const payloadString = message.value?.toString("utf8") ?? "";
+				let data: unknown;
+				try {
+					data = payloadString.length > 0 ? JSON.parse(payloadString) : null;
+				} catch {
+					data = payloadString;
+				}
+				const headers: Record<string, string> = {};
+				if (message.headers) {
+					for (const [k, v] of Object.entries(message.headers)) headers[k] = v?.toString("utf8") ?? "";
+				}
+				const job: WorkerJob = {
+					id: message.key?.toString("utf8") ?? `${config.queue}:${message.offset}`,
+					data,
+					headers,
+					queue: config.queue,
+					priority: config.priority ?? 0,
+					attempts: 0,
+					maxRetries: config.retries ?? 0,
+					createdAt: new Date(Number.parseInt(message.timestamp, 10)),
+					timeout: config.timeout,
+					raw: message,
+					complete: async () => {
+						stats.completed += 1;
+					},
+					fail: async (_err: Error) => {
+						stats.failed += 1;
+						throw _err;
+					},
+				};
+				stats.active += 1;
+				try {
+					await handler(job);
+					stats.completed += 1;
+				} catch (err) {
+					stats.failed += 1;
+					throw err;
+				} finally {
+					stats.active = Math.max(0, stats.active - 1);
+				}
+			},
+		});
+	}
+
+	async addJob(
+		queue: string,
+		data: unknown,
+		opts?: { priority?: number; delay?: number; retries?: number; timeout?: number; jobId?: string },
+	): Promise<string> {
+		if (!this.connected) throw new Error("[blok][kafka] not connected. Call connect() first.");
+		if (!this.handle.producer) throw new Error("[blok][kafka] producer not initialized");
+		const key = opts?.jobId ?? uuid();
+		const payload = typeof data === "string" ? data : JSON.stringify(data);
+		await this.handle.producer.send({
+			topic: queue,
+			messages: [
+				{
+					key,
+					value: payload,
+					headers: opts?.delay ? { "x-blok-delay-ms": String(opts.delay) } : undefined,
+				},
+			],
+		});
+		return key;
+	}
+
+	async stopProcessing(queue: string): Promise<void> {
+		const consumer = this.handle.consumers.get(queue);
+		if (consumer) {
+			try {
+				await consumer.stop();
+			} catch {
+				/* ignore */
+			}
+			try {
+				await consumer.disconnect();
+			} catch {
+				/* ignore */
+			}
+			this.handle.consumers.delete(queue);
+		}
+	}
+
+	isConnected(): boolean {
+		return this.connected;
+	}
+
+	async healthCheck(): Promise<boolean> {
+		if (!this.connected || !this.handle.admin) return false;
+		try {
+			await this.handle.admin.fetchTopicOffsets("__consumer_offsets");
+			return true;
+		} catch {
+			return false;
+		}
+	}
+
+	async getQueueStats(queue: string): Promise<WorkerQueueStats> {
+		const counters = this.stats.get(queue) ?? { completed: 0, failed: 0, active: 0 };
+		let waiting = 0;
+		if (this.handle.admin) {
+			try {
+				const offsets = await this.handle.admin.fetchTopicOffsets(queue);
+				// Approximate: total committed offsets across partitions. Real lag
+				// requires admin.fetchOffsets({ groupId }) — skipped here to keep
+				// the call cheap; production deployments should use Kafka's
+				// dedicated lag metrics anyway.
+				waiting = offsets.reduce((sum, p) => sum + Number.parseInt(p.offset, 10), 0);
+			} catch {
+				waiting = 0;
+			}
+		}
+		return {
+			waiting,
+			active: counters.active,
+			completed: counters.completed,
+			failed: counters.failed,
+			delayed: 0,
+		};
+	}
+}

package/src/adapters/NATSAdapter.ts

@@ -232,7 +232,9 @@ export class NATSWorkerAdapter implements WorkerAdapter {
 							priority,
 							attempts,
 							maxRetries,
-							createdAt: new Date(info.timestampNanos ? Number(info.timestampNanos / BigInt(1_000_000)) : Date.now()),
+							createdAt: new Date(
+								info.timestampNanos ? Math.floor(Number(info.timestampNanos) / 1_000_000) : Date.now(),
+							),
 							delay: delay || undefined,
 							timeout: timeout || config.timeout || undefined,
 							raw: msg,
@@ -256,7 +258,7 @@ export class NATSWorkerAdapter implements WorkerAdapter {
 						// holding here. createdMs is the message's first-publish timestamp;
 						// hold until createdMs + delay. Single-process semantics — for
 						// long deferrals, prefer trigger-level `delay` (DeferredRunScheduler).
-						const createdMs = info.timestampNanos ? Number(info.timestampNanos / BigInt(1_000_000)) : Date.now();
+						const createdMs = info.timestampNanos ? Math.floor(Number(info.timestampNanos) / 1_000_000) : Date.now();
 						const waitMs = computeXDelayHoldMs(delay, createdMs, Date.now());
 						if (waitMs > 0) {
 							await new Promise<void>((resolve) => setTimeout(resolve, waitMs));