@blokjs/trigger-worker 1.1.0 → 1.3.0

package/dist/adapters/KafkaAdapter.d.ts

@@ -9,10 +9,18 @@
  *   - **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.
+ *   - **Retries / DLQ**: Kafka has no broker-side retry or dead-letter
+ *     concept. The adapter emulates both at the application layer: on
+ *     handler failure it re-produces the payload to the SOURCE topic
+ *     with an incremented `x-blok-attempt` header (up to `config.retries`),
+ *     then routes the exhausted payload to `config.deadLetterQueue`. The
+ *     source offset always commits (the handler never re-throws), so a
+ *     single poison message can never crash-loop the consumer and block
+ *     every later job behind it.
+ *   - **No native priority / delay**: Kafka is an ordered log, not a
+ *     priority queue or a scheduler. `process` and `addJob` THROW a clear
+ *     config error when `priority` or `delay` is set rather than silently
+ *     dropping it — use a scheduler trigger for delayed work.
  *   - **Stats**: KafkaJS exposes consumer-group lag via its admin
  *     client; the lag count is reported as `waiting`. Other stats
  *     are tracked locally per consumer.
@@ -53,6 +61,11 @@ export declare class KafkaAdapter implements WorkerAdapter {
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     process(config: WorkerTriggerOpts, handler: (job: WorkerJob) => Promise<void>): Promise<void>;
+    /**
+     * Produce a single message to `topic` with optional string headers.
+     * Used for retry re-produce (to the source topic) and dead-lettering.
+     */
+    private produce;
     addJob(queue: string, data: unknown, opts?: {
         priority?: number;
         delay?: number;

package/dist/adapters/KafkaAdapter.js

@@ -9,10 +9,18 @@
  *   - **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.
+ *   - **Retries / DLQ**: Kafka has no broker-side retry or dead-letter
+ *     concept. The adapter emulates both at the application layer: on
+ *     handler failure it re-produces the payload to the SOURCE topic
+ *     with an incremented `x-blok-attempt` header (up to `config.retries`),
+ *     then routes the exhausted payload to `config.deadLetterQueue`. The
+ *     source offset always commits (the handler never re-throws), so a
+ *     single poison message can never crash-loop the consumer and block
+ *     every later job behind it.
+ *   - **No native priority / delay**: Kafka is an ordered log, not a
+ *     priority queue or a scheduler. `process` and `addJob` THROW a clear
+ *     config error when `priority` or `delay` is set rather than silently
+ *     dropping it — use a scheduler trigger for delayed work.
  *   - **Stats**: KafkaJS exposes consumer-group lag via its admin
  *     client; the lag count is reported as `waiting`. Other stats
  *     are tracked locally per consumer.
@@ -105,6 +113,15 @@ export class KafkaAdapter {
     async process(config, handler) {
         if (!this.connected)
             throw new Error("[blok][kafka] not connected. Call connect() first.");
+        // Kafka is an ordered log — no native priority or delayed delivery.
+        // Reject at startup rather than accepting config that silently does
+        // nothing (the pre-fix behavior: validated, logged, zero effect).
+        if (config.priority) {
+            throw new Error("[blok][kafka] Kafka has no native message priority — drop `priority`; messages are ordered per partition.");
+        }
+        if (config.delay) {
+            throw new Error("[blok][kafka] Kafka has no native delayed delivery — drop `delay` or use a scheduler trigger.");
+        }
         const groupId = config.consumerGroup ?? `${config.queue}-group`;
         const consumer = this.kafka.consumer({ groupId });
         await consumer.connect();
@@ -134,13 +151,34 @@ export class KafkaAdapter {
                     for (const [k, v] of Object.entries(message.headers))
                         headers[k] = v?.toString("utf8") ?? "";
                 }
+                // Retry attempt rides on the message header (Kafka has no
+                // broker-side attempt counter). A re-produced retry carries
+                // `x-blok-attempt`; the first delivery has none → attempt 0.
+                const attempts = Number.parseInt(headers["x-blok-attempt"] ?? "0", 10) || 0;
+                const key = message.key?.toString("utf8") ?? `${config.queue}:${message.offset}`;
+                // Terminal (retries exhausted → DLQ) vs. retry (re-produce to
+                // source with attempt+1). Both COMMIT the source offset — the
+                // handler never re-throws, so one poison message can't crash-loop
+                // the consumer and starve every job queued behind it.
+                const settleFailure = async (requeue) => {
+                    const willRetry = requeue && attempts < (config.retries ?? 0);
+                    if (willRetry) {
+                        await this.produce(config.queue, key, payloadString, { "x-blok-attempt": String(attempts + 1) });
+                    }
+                    else if (config.deadLetterQueue) {
+                        await this.produce(config.deadLetterQueue, key, payloadString, {
+                            "x-blok-attempt": String(attempts),
+                            "x-blok-source-topic": config.queue,
+                        });
+                    }
+                };
                 const job = {
-                    id: message.key?.toString("utf8") ?? `${config.queue}:${message.offset}`,
+                    id: key,
                     data,
                     headers,
                     queue: config.queue,
-                    priority: config.priority ?? 0,
-                    attempts: 0,
+                    priority: 0,
+                    attempts,
                     maxRetries: config.retries ?? 0,
                     createdAt: new Date(Number.parseInt(message.timestamp, 10)),
                     timeout: config.timeout,
@@ -148,9 +186,9 @@ export class KafkaAdapter {
                     complete: async () => {
                         stats.completed += 1;
                     },
-                    fail: async (_err) => {
+                    fail: async (_err, requeue) => {
                         stats.failed += 1;
-                        throw _err;
+                        await settleFailure(requeue === true);
                     },
                 };
                 stats.active += 1;
@@ -158,9 +196,19 @@ export class KafkaAdapter {
                     await handler(job);
                     stats.completed += 1;
                 }
-                catch (err) {
+                catch {
+                    // A handler that THROWS (rather than calling job.fail) must not
+                    // re-throw out of eachMessage — that suppresses the offset commit
+                    // and kafkajs redelivers the SAME message forever, blocking the
+                    // partition. Route the raw throw through the same retry/DLQ path
+                    // and let the offset commit. ponytail: this is the crash-loop fix.
                     stats.failed += 1;
-                    throw err;
+                    try {
+                        await settleFailure(attempts < (config.retries ?? 0));
+                    }
+                    catch {
+                        /* DLQ/retry produce failed — still commit; don't crash-loop */
+                    }
                 }
                 finally {
                     stats.active = Math.max(0, stats.active - 1);
@@ -168,23 +216,32 @@ export class KafkaAdapter {
             },
         });
     }
+    /**
+     * Produce a single message to `topic` with optional string headers.
+     * Used for retry re-produce (to the source topic) and dead-lettering.
+     */
+    async produce(topic, key, value, headers) {
+        if (!this.handle.producer)
+            throw new Error("[blok][kafka] producer not initialized");
+        await this.handle.producer.send({ topic, messages: [{ key, value, headers }] });
+    }
     async addJob(queue, data, opts) {
         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");
+        // Kafka is an ordered log — no native priority or delayed delivery.
+        // Reject rather than silently drop the option (the pre-fix behavior
+        // stuffed `delay` into a header no consumer ever honored).
+        if (opts?.priority) {
+            throw new Error("[blok][kafka] Kafka has no native message priority — drop `priority`; messages are ordered per partition.");
+        }
+        if (opts?.delay) {
+            throw new Error("[blok][kafka] Kafka has no native delayed delivery — drop `delay` or use a scheduler trigger.");
+        }
         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,
-                },
-            ],
-        });
+        await this.produce(queue, key, payload);
         return key;
     }
     async stopProcessing(queue) {
@@ -244,4 +301,4 @@ export class KafkaAdapter {
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"KafkaAdapter.js","sourceRoot":"","sources":["../../src/adapters/KafkaAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * KafkaAdapter — v0.7 PR 5 — Worker adapter backed by Apache Kafka via\n * `kafkajs`. Consumes from a topic (the `queue` field) with a\n * consumer-group identifier; produces via the same client.\n *\n * Kafka is fundamentally a streaming platform — not a queue — so a\n * few semantics differ from BullMQ/SQS/RabbitMQ:\n *\n *   - **Ordering**: per-partition, not per-topic. Set the partition\n *     key via the `dedupId` field on `addJob` to keep related\n *     messages on the same partition.\n *   - **Retries**: Kafka doesn't have a broker-side retry concept.\n *     The adapter re-throws on handler failure; offset commit is\n *     suppressed so the consumer re-polls the message on the next\n *     cycle. For real retry semantics, layer a dead-letter topic.\n *   - **Stats**: KafkaJS exposes consumer-group lag via its admin\n *     client; the lag count is reported as `waiting`. Other stats\n *     are tracked locally per consumer.\n *   - **Concurrency**: the `concurrency` field maps to KafkaJS's\n *     `partitionsConsumedConcurrently` — it caps how many partitions\n *     are processed in parallel, so it's bounded by the topic's\n *     partition count. A single-partition topic is effectively serial\n *     regardless of the configured value.\n *\n * Requires `kafkajs` as a peer dependency:\n *\n *     bun add kafkajs\n *\n * Environment variables (read at adapter construction):\n *   - `KAFKA_BROKERS`           — comma-separated list (default `localhost:9092`).\n *   - `KAFKA_CLIENT_ID`         — client.id (default `\"blok-worker\"`).\n *   - `KAFKA_SASL_USERNAME`     — SASL/PLAIN username (optional).\n *   - `KAFKA_SASL_PASSWORD`     — SASL/PLAIN password (optional).\n *   - `KAFKA_SSL`               — when `\"true\"`, enable TLS.\n */\n\nimport type { WorkerTriggerOpts } from \"@blokjs/helper\";\nimport { v4 as uuid } from \"uuid\";\nimport type { WorkerAdapter, WorkerJob, WorkerQueueStats } from \"../WorkerTrigger\";\n\nexport interface KafkaConfig {\n\tbrokers: string[];\n\tclientId: string;\n\tsaslUsername?: string;\n\tsaslPassword?: string;\n\tssl: boolean;\n}\n\ninterface KafkaJsHandle {\n\tproducer?: {\n\t\tconnect: () => Promise<void>;\n\t\tdisconnect: () => Promise<void>;\n\t\tsend: (args: unknown) => Promise<unknown>;\n\t};\n\tconsumers: Map<\n\t\tstring,\n\t\t{\n\t\t\tdisconnect: () => Promise<void>;\n\t\t\tstop: () => Promise<void>;\n\t\t\trun: (opts: unknown) => Promise<void>;\n\t\t}\n\t>;\n\tadmin?: {\n\t\tconnect: () => Promise<void>;\n\t\tdisconnect: () => Promise<void>;\n\t\tfetchTopicOffsets: (topic: string) => Promise<Array<{ partition: number; offset: string }>>;\n\t};\n}\n\ninterface QueueStatsCounters {\n\tcompleted: number;\n\tfailed: number;\n\tactive: number;\n}\n\nexport class KafkaAdapter implements WorkerAdapter {\n\treadonly provider = \"kafka\" as const;\n\tprivate readonly config: KafkaConfig;\n\t// biome-ignore lint/suspicious/noExplicitAny: kafkajs's exported `Kafka` constructor is loosely typed.\n\tprivate kafka: any = null;\n\tprivate handle: KafkaJsHandle = { consumers: new Map() };\n\tprivate connected = false;\n\tprivate stats: Map<string, QueueStatsCounters> = new Map();\n\n\tconstructor(config?: Partial<KafkaConfig>) {\n\t\tthis.config = {\n\t\t\tbrokers: config?.brokers ?? (process.env.KAFKA_BROKERS ?? \"localhost:9092\").split(\",\").map((s) => s.trim()),\n\t\t\tclientId: config?.clientId ?? process.env.KAFKA_CLIENT_ID ?? \"blok-worker\",\n\t\t\tsaslUsername: config?.saslUsername ?? process.env.KAFKA_SASL_USERNAME,\n\t\t\tsaslPassword: config?.saslPassword ?? process.env.KAFKA_SASL_PASSWORD,\n\t\t\tssl: config?.ssl ?? process.env.KAFKA_SSL === \"true\",\n\t\t};\n\t}\n\n\tasync connect(): Promise<void> {\n\t\tif (this.connected) return;\n\t\ttry {\n\t\t\t// biome-ignore lint/suspicious/noExplicitAny: kafkajs is a runtime-loaded peer dep.\n\t\t\tconst kafkajs: any = await import(\"kafkajs\");\n\t\t\tconst sasl =\n\t\t\t\tthis.config.saslUsername && this.config.saslPassword\n\t\t\t\t\t? { mechanism: \"plain\", username: this.config.saslUsername, password: this.config.saslPassword }\n\t\t\t\t\t: undefined;\n\t\t\tthis.kafka = new kafkajs.Kafka({\n\t\t\t\tclientId: this.config.clientId,\n\t\t\t\tbrokers: this.config.brokers,\n\t\t\t\tssl: this.config.ssl,\n\t\t\t\tsasl,\n\t\t\t});\n\t\t\tthis.handle.producer = this.kafka.producer();\n\t\t\tawait this.handle.producer?.connect();\n\t\t\tthis.handle.admin = this.kafka.admin();\n\t\t\tawait this.handle.admin?.connect();\n\t\t\tthis.connected = true;\n\t\t} catch (err) {\n\t\t\tthrow new Error(\n\t\t\t\t`[blok][kafka] connect failed: ${(err as Error).message}. Install kafkajs as a peer dependency: bun add kafkajs`,\n\t\t\t);\n\t\t}\n\t}\n\n\tasync disconnect(): Promise<void> {\n\t\tif (!this.connected) return;\n\t\tfor (const [, consumer] of this.handle.consumers) {\n\t\t\ttry {\n\t\t\t\tawait consumer.disconnect();\n\t\t\t} catch {\n\t\t\t\t/* ignore */\n\t\t\t}\n\t\t}\n\t\tthis.handle.consumers.clear();\n\t\ttry {\n\t\t\tawait this.handle.producer?.disconnect();\n\t\t} catch {\n\t\t\t/* ignore */\n\t\t}\n\t\ttry {\n\t\t\tawait this.handle.admin?.disconnect();\n\t\t} catch {\n\t\t\t/* ignore */\n\t\t}\n\t\tthis.connected = false;\n\t}\n\n\tasync process(config: WorkerTriggerOpts, handler: (job: WorkerJob) => Promise<void>): Promise<void> {\n\t\tif (!this.connected) throw new Error(\"[blok][kafka] not connected. Call connect() first.\");\n\t\tconst groupId = config.consumerGroup ?? `${config.queue}-group`;\n\t\tconst consumer = this.kafka.consumer({ groupId });\n\t\tawait consumer.connect();\n\t\tawait consumer.subscribe({ topic: config.queue, fromBeginning: config.fromBeginning === true });\n\t\tthis.handle.consumers.set(config.queue, consumer);\n\t\tthis.stats.set(config.queue, { completed: 0, failed: 0, active: 0 });\n\t\tconst stats = this.stats.get(config.queue) as QueueStatsCounters;\n\n\t\tawait consumer.run({\n\t\t\tautoCommit: config.ack !== false,\n\t\t\t// F25 — honor the documented `concurrency` knob. Kafka processes\n\t\t\t// messages serially per partition by default; `partitionsConsumedConcurrently`\n\t\t\t// is KafkaJS's native parallelism cap (bounded by partition count).\n\t\t\t// Without this the field was silently ignored — validated, accepted,\n\t\t\t// even logged at startup, but with zero runtime effect.\n\t\t\tpartitionsConsumedConcurrently: Math.max(1, config.concurrency ?? 1),\n\t\t\teachMessage: async ({\n\t\t\t\tmessage,\n\t\t\t}: {\n\t\t\t\tmessage: { key?: Buffer; value?: Buffer; offset: string; timestamp: string; headers?: Record<string, Buffer> };\n\t\t\t}) => {\n\t\t\t\tconst payloadString = message.value?.toString(\"utf8\") ?? \"\";\n\t\t\t\tlet data: unknown;\n\t\t\t\ttry {\n\t\t\t\t\tdata = payloadString.length > 0 ? JSON.parse(payloadString) : null;\n\t\t\t\t} catch {\n\t\t\t\t\tdata = payloadString;\n\t\t\t\t}\n\t\t\t\tconst headers: Record<string, string> = {};\n\t\t\t\tif (message.headers) {\n\t\t\t\t\tfor (const [k, v] of Object.entries(message.headers)) headers[k] = v?.toString(\"utf8\") ?? \"\";\n\t\t\t\t}\n\t\t\t\tconst job: WorkerJob = {\n\t\t\t\t\tid: message.key?.toString(\"utf8\") ?? `${config.queue}:${message.offset}`,\n\t\t\t\t\tdata,\n\t\t\t\t\theaders,\n\t\t\t\t\tqueue: config.queue,\n\t\t\t\t\tpriority: config.priority ?? 0,\n\t\t\t\t\tattempts: 0,\n\t\t\t\t\tmaxRetries: config.retries ?? 0,\n\t\t\t\t\tcreatedAt: new Date(Number.parseInt(message.timestamp, 10)),\n\t\t\t\t\ttimeout: config.timeout,\n\t\t\t\t\traw: message,\n\t\t\t\t\tcomplete: async () => {\n\t\t\t\t\t\tstats.completed += 1;\n\t\t\t\t\t},\n\t\t\t\t\tfail: async (_err: Error) => {\n\t\t\t\t\t\tstats.failed += 1;\n\t\t\t\t\t\tthrow _err;\n\t\t\t\t\t},\n\t\t\t\t};\n\t\t\t\tstats.active += 1;\n\t\t\t\ttry {\n\t\t\t\t\tawait handler(job);\n\t\t\t\t\tstats.completed += 1;\n\t\t\t\t} catch (err) {\n\t\t\t\t\tstats.failed += 1;\n\t\t\t\t\tthrow err;\n\t\t\t\t} finally {\n\t\t\t\t\tstats.active = Math.max(0, stats.active - 1);\n\t\t\t\t}\n\t\t\t},\n\t\t});\n\t}\n\n\tasync addJob(\n\t\tqueue: string,\n\t\tdata: unknown,\n\t\topts?: { priority?: number; delay?: number; retries?: number; timeout?: number; jobId?: string },\n\t): Promise<string> {\n\t\tif (!this.connected) throw new Error(\"[blok][kafka] not connected. Call connect() first.\");\n\t\tif (!this.handle.producer) throw new Error(\"[blok][kafka] producer not initialized\");\n\t\tconst key = opts?.jobId ?? uuid();\n\t\tconst payload = typeof data === \"string\" ? data : JSON.stringify(data);\n\t\tawait this.handle.producer.send({\n\t\t\ttopic: queue,\n\t\t\tmessages: [\n\t\t\t\t{\n\t\t\t\t\tkey,\n\t\t\t\t\tvalue: payload,\n\t\t\t\t\theaders: opts?.delay ? { \"x-blok-delay-ms\": String(opts.delay) } : undefined,\n\t\t\t\t},\n\t\t\t],\n\t\t});\n\t\treturn key;\n\t}\n\n\tasync stopProcessing(queue: string): Promise<void> {\n\t\tconst consumer = this.handle.consumers.get(queue);\n\t\tif (consumer) {\n\t\t\ttry {\n\t\t\t\tawait consumer.stop();\n\t\t\t} catch {\n\t\t\t\t/* ignore */\n\t\t\t}\n\t\t\ttry {\n\t\t\t\tawait consumer.disconnect();\n\t\t\t} catch {\n\t\t\t\t/* ignore */\n\t\t\t}\n\t\t\tthis.handle.consumers.delete(queue);\n\t\t}\n\t}\n\n\tisConnected(): boolean {\n\t\treturn this.connected;\n\t}\n\n\tasync healthCheck(): Promise<boolean> {\n\t\tif (!this.connected || !this.handle.admin) return false;\n\t\ttry {\n\t\t\tawait this.handle.admin.fetchTopicOffsets(\"__consumer_offsets\");\n\t\t\treturn true;\n\t\t} catch {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\tasync getQueueStats(queue: string): Promise<WorkerQueueStats> {\n\t\tconst counters = this.stats.get(queue) ?? { completed: 0, failed: 0, active: 0 };\n\t\tlet waiting = 0;\n\t\tif (this.handle.admin) {\n\t\t\ttry {\n\t\t\t\tconst offsets = await this.handle.admin.fetchTopicOffsets(queue);\n\t\t\t\t// Approximate: total committed offsets across partitions. Real lag\n\t\t\t\t// requires admin.fetchOffsets({ groupId }) — skipped here to keep\n\t\t\t\t// the call cheap; production deployments should use Kafka's\n\t\t\t\t// dedicated lag metrics anyway.\n\t\t\t\twaiting = offsets.reduce((sum, p) => sum + Number.parseInt(p.offset, 10), 0);\n\t\t\t} catch {\n\t\t\t\twaiting = 0;\n\t\t\t}\n\t\t}\n\t\treturn {\n\t\t\twaiting,\n\t\t\tactive: counters.active,\n\t\t\tcompleted: counters.completed,\n\t\t\tfailed: counters.failed,\n\t\t\tdelayed: 0,\n\t\t};\n\t}\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"KafkaAdapter.js","sourceRoot":"","sources":["../../src/adapters/KafkaAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * KafkaAdapter — v0.7 PR 5 — Worker adapter backed by Apache Kafka via\n * `kafkajs`. Consumes from a topic (the `queue` field) with a\n * consumer-group identifier; produces via the same client.\n *\n * Kafka is fundamentally a streaming platform — not a queue — so a\n * few semantics differ from BullMQ/SQS/RabbitMQ:\n *\n *   - **Ordering**: per-partition, not per-topic. Set the partition\n *     key via the `dedupId` field on `addJob` to keep related\n *     messages on the same partition.\n *   - **Retries / DLQ**: Kafka has no broker-side retry or dead-letter\n *     concept. The adapter emulates both at the application layer: on\n *     handler failure it re-produces the payload to the SOURCE topic\n *     with an incremented `x-blok-attempt` header (up to `config.retries`),\n *     then routes the exhausted payload to `config.deadLetterQueue`. The\n *     source offset always commits (the handler never re-throws), so a\n *     single poison message can never crash-loop the consumer and block\n *     every later job behind it.\n *   - **No native priority / delay**: Kafka is an ordered log, not a\n *     priority queue or a scheduler. `process` and `addJob` THROW a clear\n *     config error when `priority` or `delay` is set rather than silently\n *     dropping it — use a scheduler trigger for delayed work.\n *   - **Stats**: KafkaJS exposes consumer-group lag via its admin\n *     client; the lag count is reported as `waiting`. Other stats\n *     are tracked locally per consumer.\n *   - **Concurrency**: the `concurrency` field maps to KafkaJS's\n *     `partitionsConsumedConcurrently` — it caps how many partitions\n *     are processed in parallel, so it's bounded by the topic's\n *     partition count. A single-partition topic is effectively serial\n *     regardless of the configured value.\n *\n * Requires `kafkajs` as a peer dependency:\n *\n *     bun add kafkajs\n *\n * Environment variables (read at adapter construction):\n *   - `KAFKA_BROKERS`           — comma-separated list (default `localhost:9092`).\n *   - `KAFKA_CLIENT_ID`         — client.id (default `\"blok-worker\"`).\n *   - `KAFKA_SASL_USERNAME`     — SASL/PLAIN username (optional).\n *   - `KAFKA_SASL_PASSWORD`     — SASL/PLAIN password (optional).\n *   - `KAFKA_SSL`               — when `\"true\"`, enable TLS.\n */\n\nimport type { WorkerTriggerOpts } from \"@blokjs/helper\";\nimport { v4 as uuid } from \"uuid\";\nimport type { WorkerAdapter, WorkerJob, WorkerQueueStats } from \"../WorkerTrigger\";\n\nexport interface KafkaConfig {\n\tbrokers: string[];\n\tclientId: string;\n\tsaslUsername?: string;\n\tsaslPassword?: string;\n\tssl: boolean;\n}\n\ninterface KafkaJsHandle {\n\tproducer?: {\n\t\tconnect: () => Promise<void>;\n\t\tdisconnect: () => Promise<void>;\n\t\tsend: (args: unknown) => Promise<unknown>;\n\t};\n\tconsumers: Map<\n\t\tstring,\n\t\t{\n\t\t\tdisconnect: () => Promise<void>;\n\t\t\tstop: () => Promise<void>;\n\t\t\trun: (opts: unknown) => Promise<void>;\n\t\t}\n\t>;\n\tadmin?: {\n\t\tconnect: () => Promise<void>;\n\t\tdisconnect: () => Promise<void>;\n\t\tfetchTopicOffsets: (topic: string) => Promise<Array<{ partition: number; offset: string }>>;\n\t};\n}\n\ninterface QueueStatsCounters {\n\tcompleted: number;\n\tfailed: number;\n\tactive: number;\n}\n\nexport class KafkaAdapter implements WorkerAdapter {\n\treadonly provider = \"kafka\" as const;\n\tprivate readonly config: KafkaConfig;\n\t// biome-ignore lint/suspicious/noExplicitAny: kafkajs's exported `Kafka` constructor is loosely typed.\n\tprivate kafka: any = null;\n\tprivate handle: KafkaJsHandle = { consumers: new Map() };\n\tprivate connected = false;\n\tprivate stats: Map<string, QueueStatsCounters> = new Map();\n\n\tconstructor(config?: Partial<KafkaConfig>) {\n\t\tthis.config = {\n\t\t\tbrokers: config?.brokers ?? (process.env.KAFKA_BROKERS ?? \"localhost:9092\").split(\",\").map((s) => s.trim()),\n\t\t\tclientId: config?.clientId ?? process.env.KAFKA_CLIENT_ID ?? \"blok-worker\",\n\t\t\tsaslUsername: config?.saslUsername ?? process.env.KAFKA_SASL_USERNAME,\n\t\t\tsaslPassword: config?.saslPassword ?? process.env.KAFKA_SASL_PASSWORD,\n\t\t\tssl: config?.ssl ?? process.env.KAFKA_SSL === \"true\",\n\t\t};\n\t}\n\n\tasync connect(): Promise<void> {\n\t\tif (this.connected) return;\n\t\ttry {\n\t\t\t// biome-ignore lint/suspicious/noExplicitAny: kafkajs is a runtime-loaded peer dep.\n\t\t\tconst kafkajs: any = await import(\"kafkajs\");\n\t\t\tconst sasl =\n\t\t\t\tthis.config.saslUsername && this.config.saslPassword\n\t\t\t\t\t? { mechanism: \"plain\", username: this.config.saslUsername, password: this.config.saslPassword }\n\t\t\t\t\t: undefined;\n\t\t\tthis.kafka = new kafkajs.Kafka({\n\t\t\t\tclientId: this.config.clientId,\n\t\t\t\tbrokers: this.config.brokers,\n\t\t\t\tssl: this.config.ssl,\n\t\t\t\tsasl,\n\t\t\t});\n\t\t\tthis.handle.producer = this.kafka.producer();\n\t\t\tawait this.handle.producer?.connect();\n\t\t\tthis.handle.admin = this.kafka.admin();\n\t\t\tawait this.handle.admin?.connect();\n\t\t\tthis.connected = true;\n\t\t} catch (err) {\n\t\t\tthrow new Error(\n\t\t\t\t`[blok][kafka] connect failed: ${(err as Error).message}. Install kafkajs as a peer dependency: bun add kafkajs`,\n\t\t\t);\n\t\t}\n\t}\n\n\tasync disconnect(): Promise<void> {\n\t\tif (!this.connected) return;\n\t\tfor (const [, consumer] of this.handle.consumers) {\n\t\t\ttry {\n\t\t\t\tawait consumer.disconnect();\n\t\t\t} catch {\n\t\t\t\t/* ignore */\n\t\t\t}\n\t\t}\n\t\tthis.handle.consumers.clear();\n\t\ttry {\n\t\t\tawait this.handle.producer?.disconnect();\n\t\t} catch {\n\t\t\t/* ignore */\n\t\t}\n\t\ttry {\n\t\t\tawait this.handle.admin?.disconnect();\n\t\t} catch {\n\t\t\t/* ignore */\n\t\t}\n\t\tthis.connected = false;\n\t}\n\n\tasync process(config: WorkerTriggerOpts, handler: (job: WorkerJob) => Promise<void>): Promise<void> {\n\t\tif (!this.connected) throw new Error(\"[blok][kafka] not connected. Call connect() first.\");\n\t\t// Kafka is an ordered log — no native priority or delayed delivery.\n\t\t// Reject at startup rather than accepting config that silently does\n\t\t// nothing (the pre-fix behavior: validated, logged, zero effect).\n\t\tif (config.priority) {\n\t\t\tthrow new Error(\n\t\t\t\t\"[blok][kafka] Kafka has no native message priority — drop `priority`; messages are ordered per partition.\",\n\t\t\t);\n\t\t}\n\t\tif (config.delay) {\n\t\t\tthrow new Error(\"[blok][kafka] Kafka has no native delayed delivery — drop `delay` or use a scheduler trigger.\");\n\t\t}\n\t\tconst groupId = config.consumerGroup ?? `${config.queue}-group`;\n\t\tconst consumer = this.kafka.consumer({ groupId });\n\t\tawait consumer.connect();\n\t\tawait consumer.subscribe({ topic: config.queue, fromBeginning: config.fromBeginning === true });\n\t\tthis.handle.consumers.set(config.queue, consumer);\n\t\tthis.stats.set(config.queue, { completed: 0, failed: 0, active: 0 });\n\t\tconst stats = this.stats.get(config.queue) as QueueStatsCounters;\n\n\t\tawait consumer.run({\n\t\t\tautoCommit: config.ack !== false,\n\t\t\t// F25 — honor the documented `concurrency` knob. Kafka processes\n\t\t\t// messages serially per partition by default; `partitionsConsumedConcurrently`\n\t\t\t// is KafkaJS's native parallelism cap (bounded by partition count).\n\t\t\t// Without this the field was silently ignored — validated, accepted,\n\t\t\t// even logged at startup, but with zero runtime effect.\n\t\t\tpartitionsConsumedConcurrently: Math.max(1, config.concurrency ?? 1),\n\t\t\teachMessage: async ({\n\t\t\t\tmessage,\n\t\t\t}: {\n\t\t\t\tmessage: { key?: Buffer; value?: Buffer; offset: string; timestamp: string; headers?: Record<string, Buffer> };\n\t\t\t}) => {\n\t\t\t\tconst payloadString = message.value?.toString(\"utf8\") ?? \"\";\n\t\t\t\tlet data: unknown;\n\t\t\t\ttry {\n\t\t\t\t\tdata = payloadString.length > 0 ? JSON.parse(payloadString) : null;\n\t\t\t\t} catch {\n\t\t\t\t\tdata = payloadString;\n\t\t\t\t}\n\t\t\t\tconst headers: Record<string, string> = {};\n\t\t\t\tif (message.headers) {\n\t\t\t\t\tfor (const [k, v] of Object.entries(message.headers)) headers[k] = v?.toString(\"utf8\") ?? \"\";\n\t\t\t\t}\n\t\t\t\t// Retry attempt rides on the message header (Kafka has no\n\t\t\t\t// broker-side attempt counter). A re-produced retry carries\n\t\t\t\t// `x-blok-attempt`; the first delivery has none → attempt 0.\n\t\t\t\tconst attempts = Number.parseInt(headers[\"x-blok-attempt\"] ?? \"0\", 10) || 0;\n\t\t\t\tconst key = message.key?.toString(\"utf8\") ?? `${config.queue}:${message.offset}`;\n\t\t\t\t// Terminal (retries exhausted → DLQ) vs. retry (re-produce to\n\t\t\t\t// source with attempt+1). Both COMMIT the source offset — the\n\t\t\t\t// handler never re-throws, so one poison message can't crash-loop\n\t\t\t\t// the consumer and starve every job queued behind it.\n\t\t\t\tconst settleFailure = async (requeue: boolean): Promise<void> => {\n\t\t\t\t\tconst willRetry = requeue && attempts < (config.retries ?? 0);\n\t\t\t\t\tif (willRetry) {\n\t\t\t\t\t\tawait this.produce(config.queue, key, payloadString, { \"x-blok-attempt\": String(attempts + 1) });\n\t\t\t\t\t} else if (config.deadLetterQueue) {\n\t\t\t\t\t\tawait this.produce(config.deadLetterQueue, key, payloadString, {\n\t\t\t\t\t\t\t\"x-blok-attempt\": String(attempts),\n\t\t\t\t\t\t\t\"x-blok-source-topic\": config.queue,\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t\tconst job: WorkerJob = {\n\t\t\t\t\tid: key,\n\t\t\t\t\tdata,\n\t\t\t\t\theaders,\n\t\t\t\t\tqueue: config.queue,\n\t\t\t\t\tpriority: 0,\n\t\t\t\t\tattempts,\n\t\t\t\t\tmaxRetries: config.retries ?? 0,\n\t\t\t\t\tcreatedAt: new Date(Number.parseInt(message.timestamp, 10)),\n\t\t\t\t\ttimeout: config.timeout,\n\t\t\t\t\traw: message,\n\t\t\t\t\tcomplete: async () => {\n\t\t\t\t\t\tstats.completed += 1;\n\t\t\t\t\t},\n\t\t\t\t\tfail: async (_err: Error, requeue?: boolean) => {\n\t\t\t\t\t\tstats.failed += 1;\n\t\t\t\t\t\tawait settleFailure(requeue === true);\n\t\t\t\t\t},\n\t\t\t\t};\n\t\t\t\tstats.active += 1;\n\t\t\t\ttry {\n\t\t\t\t\tawait handler(job);\n\t\t\t\t\tstats.completed += 1;\n\t\t\t\t} catch {\n\t\t\t\t\t// A handler that THROWS (rather than calling job.fail) must not\n\t\t\t\t\t// re-throw out of eachMessage — that suppresses the offset commit\n\t\t\t\t\t// and kafkajs redelivers the SAME message forever, blocking the\n\t\t\t\t\t// partition. Route the raw throw through the same retry/DLQ path\n\t\t\t\t\t// and let the offset commit. ponytail: this is the crash-loop fix.\n\t\t\t\t\tstats.failed += 1;\n\t\t\t\t\ttry {\n\t\t\t\t\t\tawait settleFailure(attempts < (config.retries ?? 0));\n\t\t\t\t\t} catch {\n\t\t\t\t\t\t/* DLQ/retry produce failed — still commit; don't crash-loop */\n\t\t\t\t\t}\n\t\t\t\t} finally {\n\t\t\t\t\tstats.active = Math.max(0, stats.active - 1);\n\t\t\t\t}\n\t\t\t},\n\t\t});\n\t}\n\n\t/**\n\t * Produce a single message to `topic` with optional string headers.\n\t * Used for retry re-produce (to the source topic) and dead-lettering.\n\t */\n\tprivate async produce(topic: string, key: string, value: string, headers?: Record<string, string>): Promise<void> {\n\t\tif (!this.handle.producer) throw new Error(\"[blok][kafka] producer not initialized\");\n\t\tawait this.handle.producer.send({ topic, messages: [{ key, value, headers }] });\n\t}\n\n\tasync addJob(\n\t\tqueue: string,\n\t\tdata: unknown,\n\t\topts?: { priority?: number; delay?: number; retries?: number; timeout?: number; jobId?: string },\n\t): Promise<string> {\n\t\tif (!this.connected) throw new Error(\"[blok][kafka] not connected. Call connect() first.\");\n\t\tif (!this.handle.producer) throw new Error(\"[blok][kafka] producer not initialized\");\n\t\t// Kafka is an ordered log — no native priority or delayed delivery.\n\t\t// Reject rather than silently drop the option (the pre-fix behavior\n\t\t// stuffed `delay` into a header no consumer ever honored).\n\t\tif (opts?.priority) {\n\t\t\tthrow new Error(\n\t\t\t\t\"[blok][kafka] Kafka has no native message priority — drop `priority`; messages are ordered per partition.\",\n\t\t\t);\n\t\t}\n\t\tif (opts?.delay) {\n\t\t\tthrow new Error(\"[blok][kafka] Kafka has no native delayed delivery — drop `delay` or use a scheduler trigger.\");\n\t\t}\n\t\tconst key = opts?.jobId ?? uuid();\n\t\tconst payload = typeof data === \"string\" ? data : JSON.stringify(data);\n\t\tawait this.produce(queue, key, payload);\n\t\treturn key;\n\t}\n\n\tasync stopProcessing(queue: string): Promise<void> {\n\t\tconst consumer = this.handle.consumers.get(queue);\n\t\tif (consumer) {\n\t\t\ttry {\n\t\t\t\tawait consumer.stop();\n\t\t\t} catch {\n\t\t\t\t/* ignore */\n\t\t\t}\n\t\t\ttry {\n\t\t\t\tawait consumer.disconnect();\n\t\t\t} catch {\n\t\t\t\t/* ignore */\n\t\t\t}\n\t\t\tthis.handle.consumers.delete(queue);\n\t\t}\n\t}\n\n\tisConnected(): boolean {\n\t\treturn this.connected;\n\t}\n\n\tasync healthCheck(): Promise<boolean> {\n\t\tif (!this.connected || !this.handle.admin) return false;\n\t\ttry {\n\t\t\tawait this.handle.admin.fetchTopicOffsets(\"__consumer_offsets\");\n\t\t\treturn true;\n\t\t} catch {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\tasync getQueueStats(queue: string): Promise<WorkerQueueStats> {\n\t\tconst counters = this.stats.get(queue) ?? { completed: 0, failed: 0, active: 0 };\n\t\tlet waiting = 0;\n\t\tif (this.handle.admin) {\n\t\t\ttry {\n\t\t\t\tconst offsets = await this.handle.admin.fetchTopicOffsets(queue);\n\t\t\t\t// Approximate: total committed offsets across partitions. Real lag\n\t\t\t\t// requires admin.fetchOffsets({ groupId }) — skipped here to keep\n\t\t\t\t// the call cheap; production deployments should use Kafka's\n\t\t\t\t// dedicated lag metrics anyway.\n\t\t\t\twaiting = offsets.reduce((sum, p) => sum + Number.parseInt(p.offset, 10), 0);\n\t\t\t} catch {\n\t\t\t\twaiting = 0;\n\t\t\t}\n\t\t}\n\t\treturn {\n\t\t\twaiting,\n\t\t\tactive: counters.active,\n\t\t\tcompleted: counters.completed,\n\t\t\tfailed: counters.failed,\n\t\t\tdelayed: 0,\n\t\t};\n\t}\n}\n"]}

package/dist/adapters/NATSAdapter.d.ts

@@ -102,6 +102,17 @@ export declare class NATSWorkerAdapter implements WorkerAdapter {
      * Get queue statistics from JetStream consumer info
      */
     getQueueStats(queue: string): Promise<WorkerQueueStats>;
+    /**
+     * v0.7 — dead-letter an exhausted message. Publishes the ORIGINAL payload
+     * and headers to the `worker.${deadLetterQueue}` subject so a downstream
+     * consumer can inspect/replay it. Plain core publish (not JetStream): the
+     * DLQ is a notification subject, not part of the workqueue stream, so we
+     * avoid coupling it to stream-subject management. No-op when DLQ is unset.
+     *
+     * ponytail: core publish, not a persisted DLQ stream. Upgrade to a
+     * dedicated DLQ JetStream stream if durable dead-letter storage is needed.
+     */
+    private deadLetter;
     /**
      * Ensure a JetStream stream exists with the given subjects
      */

package/dist/adapters/NATSAdapter.js

@@ -133,12 +133,21 @@ export class NATSWorkerAdapter {
         const durableName = `blok-worker-${queue}`;
         // Ensure stream exists with worker subjects
         await this.ensureStream(streamName, [subject]);
+        // v0.7 — `ack: false` selects at-most-once delivery. JetStream PULL
+        // consumers reject AckPolicy.None ("consumer in pull mode requires ack
+        // policy"), so at-most-once is implemented as AckPolicy.Explicit +
+        // max_deliver:1 with the message ACKed on receipt (before the handler
+        // runs). The broker then treats the message as delivered+done, so a
+        // handler that throws is NOT redelivered — exactly-once delivery even
+        // on failure. The manual ack/nak/term path below is a no-op in this mode.
+        const atMostOnce = config.ack === false;
         // Create or update durable pull consumer with worker semantics
         const ackWaitNs = ((config.timeout ?? 30000) + 5000) * 1_000_000; // timeout + 5s buffer, in nanoseconds
         await this.jsm.consumers.add(streamName, {
             durable_name: durableName,
             ack_policy: nats.AckPolicy.Explicit,
-            max_deliver: (config.retries ?? 3) + 1, // +1 because first attempt counts
+            // at-most-once: deliver exactly once, never redeliver.
+            max_deliver: atMostOnce ? 1 : (config.retries ?? 3) + 1, // +1 because first attempt counts
             ack_wait: ackWaitNs,
             filter_subjects: [subject],
         });
@@ -201,19 +210,35 @@ export class NATSWorkerAdapter {
                             timeout: timeout || config.timeout || undefined,
                             raw: msg,
                             complete: async () => {
-                                msg.ack();
+                                // Already ACKed on receipt under at-most-once; a second ack errors.
+                                if (!atMostOnce)
+                                    msg.ack();
                             },
                             fail: async (error, requeue) => {
                                 if (requeue) {
-                                    // nak() tells the server to redeliver
-                                    msg.nak();
+                                    // nak() tells the server to redeliver. No-op under
+                                    // at-most-once — the message was already ACKed on receipt.
+                                    if (!atMostOnce)
+                                        msg.nak();
                                 }
                                 else {
-                                    // term() terminates delivery — no more retries
-                                    msg.term();
+                                    // Terminal failure (retries exhausted / non-requeue).
+                                    // v0.7 — dead-letter the original payload+headers to
+                                    // `worker.${deadLetterQueue}` before terminating so the
+                                    // message isn't silently dropped. No-op when DLQ is unset.
+                                    await this.deadLetter(config.deadLetterQueue, msg.data, msg.headers);
+                                    // term() terminates delivery — no more retries. Already
+                                    // ACKed under at-most-once, so term() is skipped there.
+                                    if (!atMostOnce)
+                                        msg.term();
                                 }
                             },
                         };
+                        // at-most-once — ACK before running the handler so the broker
+                        // considers the message done. max_deliver:1 already prevents
+                        // redelivery; this also releases the ack_wait timer immediately.
+                        if (atMostOnce)
+                            msg.ack();
                         // Tier 2 polish — enforce `x-delay` header on the consumer side.
                         // NATS JetStream stores `x-delay` as opaque metadata; the broker
                         // does NOT defer delivery on it. We implement consumer-side
@@ -230,7 +255,10 @@ export class NATSWorkerAdapter {
                     catch (error) {
                         console.error(`[NATSWorkerAdapter] Error processing job from ${queue}: ${error.message}`);
                         try {
-                            msg.nak();
+                            // Under at-most-once there's nothing to nak — the broker isn't
+                            // tracking delivery, so a handler throw must NOT trigger redelivery.
+                            if (!atMostOnce)
+                                msg.nak();
                         }
                         catch {
                             // Already acked/nacked
@@ -332,6 +360,28 @@ export class NATSWorkerAdapter {
             return { waiting: 0, active: 0, completed: 0, failed: 0, delayed: 0 };
         }
     }
+    /**
+     * v0.7 — dead-letter an exhausted message. Publishes the ORIGINAL payload
+     * and headers to the `worker.${deadLetterQueue}` subject so a downstream
+     * consumer can inspect/replay it. Plain core publish (not JetStream): the
+     * DLQ is a notification subject, not part of the workqueue stream, so we
+     * avoid coupling it to stream-subject management. No-op when DLQ is unset.
+     *
+     * ponytail: core publish, not a persisted DLQ stream. Upgrade to a
+     * dedicated DLQ JetStream stream if durable dead-letter storage is needed.
+     */
+    async deadLetter(deadLetterQueue, data, 
+    // biome-ignore lint/suspicious/noExplicitAny: NATS MsgHdrs type is dynamically imported
+    headers) {
+        if (!deadLetterQueue)
+            return;
+        try {
+            this.nc.publish(`worker.${deadLetterQueue}`, data, headers ? { headers } : undefined);
+        }
+        catch (error) {
+            console.error(`[NATSWorkerAdapter] Failed to dead-letter to worker.${deadLetterQueue}: ${error.message}`);
+        }
+    }
     /**
      * Ensure a JetStream stream exists with the given subjects
      */
@@ -391,4 +441,4 @@ class Semaphore {
     }
 }
 export default NATSWorkerAdapter;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"NATSAdapter.js","sourceRoot":"","sources":["../../src/adapters/NATSAdapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,EAAE,IAAI,IAAI,EAAE,MAAM,MAAM,CAAC;AAGlC;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAa,EAAE,SAAiB,EAAE,KAAa;IAClF,IAAI,CAAC,KAAK,IAAI,KAAK,IAAI,CAAC;QAAE,OAAO,CAAC,CAAC;IACnC,MAAM,UAAU,GAAG,SAAS,GAAG,KAAK,CAAC;IACrC,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,UAAU,GAAG,KAAK,CAAC,CAAC;AACxC,CAAC;AAkBD;;GAEG;AACH,MAAM,OAAO,iBAAiB;IACpB,QAAQ,GAAG,MAAe,CAAC;IAEpC,6GAA6G;IACrG,EAAE,GAAQ,IAAI,CAAC;IACvB,kFAAkF;IAC1E,EAAE,GAAQ,IAAI,CAAC;IACvB,kFAAkF;IAC1E,GAAG,GAAQ,IAAI,CAAC;IAChB,SAAS,GAAG,KAAK,CAAC;IAClB,MAAM,CAAmB;IACjC,sEAAsE;IAC9D,SAAS,GAAqB,IAAI,GAAG,EAAE,CAAC;IAChD,qEAAqE;IAC7D,gBAAgB,GAAqB,IAAI,GAAG,EAAE,CAAC;IAEvD,YAAY,MAAkC;QAC7C,IAAI,CAAC,MAAM,GAAG;YACb,OAAO,EAAE,MAAM,EAAE,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,YAAY,IAAI,gBAAgB,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC;YACrF,KAAK,EAAE,MAAM,EAAE,KAAK,IAAI,OAAO,CAAC,GAAG,CAAC,UAAU;YAC9C,IAAI,EAAE,MAAM,EAAE,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,SAAS;YAC3C,IAAI,EAAE,MAAM,EAAE,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,SAAS;YAC3C,UAAU,EAAE,MAAM,EAAE,UAAU,IAAI,OAAO,CAAC,GAAG,CAAC,gBAAgB,IAAI,aAAa;SAC/E,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,OAAO;QACZ,IAAI,IAAI,CAAC,SAAS;YAAE,OAAO;QAE3B,IAAI,CAAC;YACJ,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,CAAC;YAElC,MAAM,WAAW,GAA4B;gBAC5C,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO;aAC5B,CAAC;YAEF,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK;gBAAE,WAAW,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;YAC7D,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI;gBAAE,WAAW,CAAC,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;YAC1D,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI;gBAAE,WAAW,CAAC,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;YAE1D,IAAI,CAAC,EAAE,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;YAC1C,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC;YAC9B,IAAI,CAAC,GAAG,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,gBAAgB,EAAE,CAAC;YAE5C,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;YACtB,OAAO,CAAC,GAAG,CAAC,0CAA0C,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACzF,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YAChB,MAAM,IAAI,KAAK,CACd,8BAA+B,KAAe,CAAC,OAAO,iDAAiD,CACvG,CAAC;QACH,CAAC;IACF,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,UAAU;QACf,IAAI,CAAC,IAAI,CAAC,SAAS;YAAE,OAAO;QAE5B,IAAI,CAAC;YACJ,6BAA6B;YAC7B,KAAK,MAAM,CAAC,EAAE,IAAI,CAAC,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBAC9C,IAAI,CAAC;oBACJ,IAAI,CAAC,IAAI,EAAE,CAAC;gBACb,CAAC;gBAAC,MAAM,CAAC;oBACR,kCAAkC;gBACnC,CAAC;YACF,CAAC;YACD,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC;YAC9B,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;YAEvB,MAAM,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC;YACtB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;YACvB,OAAO,CAAC,GAAG,CAAC,4CAA4C,CAAC,CAAC;QAC3D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YAChB,OAAO,CAAC,KAAK,CAAC,yCAA0C,KAAe,CAAC,OAAO,EAAE,CAAC,CAAC;QACpF,CAAC;IACF,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,OAAO,CAAC,MAAyB,EAAE,OAA0C;QAClF,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;QACzD,CAAC;QAED,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,CAAC;QAClC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;QAC3B,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,aAAa,CAAC;QAC3D,MAAM,OAAO,GAAG,UAAU,KAAK,EAAE,CAAC;QAClC,MAAM,WAAW,GAAG,eAAe,KAAK,EAAE,CAAC;QAE3C,4CAA4C;QAC5C,MAAM,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;QAE/C,+DAA+D;QAC/D,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,IAAI,KAAK,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC,CAAC,sCAAsC;QACxG,MAAM,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,EAAE;YACxC,YAAY,EAAE,WAAW;YACzB,UAAU,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ;YACnC,WAAW,EAAE,CAAC,MAAM,CAAC,OAAO,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,kCAAkC;YAC1E,QAAQ,EAAE,SAAS;YACnB,eAAe,EAAE,CAAC,OAAO,CAAC;SAC1B,CAAC,CAAC;QAEH,sBAAsB;QACtB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;QACtE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QAEpC,kBAAkB;QAClB,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,OAAO,EAAE,CAAC;QACtC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAEvC,6BAA6B;QAC7B,CAAC,KAAK,IAAI,EAAE;YACX,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC,MAAM,CAAC,WAAW,IAAI,CAAC,CAAC,CAAC;YAEzD,IAAI,KAAK,EAAE,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;gBAC9B,MAAM,SAAS,CAAC,OAAO,EAAE,CAAC;gBAE1B,wDAAwD;gBACxD,CAAC,KAAK,IAAI,EAAE;oBACX,IAAI,CAAC;wBACJ,iBAAiB;wBACjB,IAAI,IAAa,CAAC;wBAClB,IAAI,CAAC;4BACJ,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;4BAC/B,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;wBAC/B,CAAC;wBAAC,MAAM,CAAC;4BACR,IAAI,CAAC;gCACJ,MAAM,EAAE,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;gCAC9B,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;4BACxC,CAAC;4BAAC,MAAM,CAAC;gCACR,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC;4BACjB,CAAC;wBACF,CAAC;wBAED,kBAAkB;wBAClB,MAAM,OAAO,GAA2B,EAAE,CAAC;wBAC3C,IAAI,GAAG,CAAC,OAAO,EAAE,CAAC;4BACjB,KAAK,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,IAAI,GAAG,CAAC,OAAO,EAAE,CAAC;gCACzC,OAAO,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;4BAC3D,CAAC;wBACF,CAAC;wBAED,oCAAoC;wBACpC,MAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,IAAI,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,aAAa,CAAC,IAAI,IAAI,EAAE,CAAC;wBAC/E,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,GAAG,EAAE,EAAE,CAAC,CAAC;wBACnE,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,GAAG,EAAE,EAAE,CAAC,CAAC;wBAC7D,MAAM,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,GAAG,EAAE,EAAE,CAAC,CAAC;wBAEjE,kCAAkC;wBAClC,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC;wBACtB,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,IAAI,CAAC,CAAC;wBAC3C,MAAM,UAAU,GAAG,MAAM,CAAC,OAAO,IAAI,CAAC,CAAC;wBAEvC,mBAAmB;wBACnB,MAAM,SAAS,GAAc;4BAC5B,EAAE,EAAE,KAAK;4BACT,IAAI;4BACJ,OAAO;4BACP,KAAK;4BACL,QAAQ;4BACR,QAAQ;4BACR,UAAU;4BACV,SAAS,EAAE,IAAI,IAAI,CAClB,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CACtF;4BACD,KAAK,EAAE,KAAK,IAAI,SAAS;4BACzB,OAAO,EAAE,OAAO,IAAI,MAAM,CAAC,OAAO,IAAI,SAAS;4BAC/C,GAAG,EAAE,GAAG;4BACR,QAAQ,EAAE,KAAK,IAAI,EAAE;gCACpB,GAAG,CAAC,GAAG,EAAE,CAAC;4BACX,CAAC;4BACD,IAAI,EAAE,KAAK,EAAE,KAAY,EAAE,OAAiB,EAAE,EAAE;gCAC/C,IAAI,OAAO,EAAE,CAAC;oCACb,sCAAsC;oCACtC,GAAG,CAAC,GAAG,EAAE,CAAC;gCACX,CAAC;qCAAM,CAAC;oCACP,+CAA+C;oCAC/C,GAAG,CAAC,IAAI,EAAE,CAAC;gCACZ,CAAC;4BACF,CAAC;yBACD,CAAC;wBAEF,iEAAiE;wBACjE,iEAAiE;wBACjE,4DAA4D;wBAC5D,oEAAoE;wBACpE,+DAA+D;wBAC/D,uEAAuE;wBACvE,MAAM,SAAS,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;wBACzG,MAAM,MAAM,GAAG,mBAAmB,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;wBACjE,IAAI,MAAM,GAAG,CAAC,EAAE,CAAC;4BAChB,MAAM,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC;wBACnE,CAAC;wBAED,MAAM,OAAO,CAAC,SAAS,CAAC,CAAC;oBAC1B,CAAC;oBAAC,OAAO,KAAK,EAAE,CAAC;wBAChB,OAAO,CAAC,KAAK,CAAC,iDAAiD,KAAK,KAAM,KAAe,CAAC,OAAO,EAAE,CAAC,CAAC;wBACrG,IAAI,CAAC;4BACJ,GAAG,CAAC,GAAG,EAAE,CAAC;wBACX,CAAC;wBAAC,MAAM,CAAC;4BACR,uBAAuB;wBACxB,CAAC;oBACF,CAAC;4BAAS,CAAC;wBACV,SAAS,CAAC,OAAO,EAAE,CAAC;oBACrB,CAAC;gBACF,CAAC,CAAC,EAAE,CAAC;YACN,CAAC;QACF,CAAC,CAAC,EAAE,CAAC;QAEL,OAAO,CAAC,GAAG,CACV,yCAAyC,KAAK,iBAAiB,MAAM,CAAC,WAAW,IAAI,CAAC,aAAa,MAAM,CAAC,OAAO,IAAI,CAAC,GAAG,CACzH,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,CACX,KAAa,EACb,IAAa,EACb,IAMC;QAED,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;QACzD,CAAC;QAED,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,CAAC;QAClC,MAAM,OAAO,GAAG,UAAU,KAAK,EAAE,CAAC;QAClC,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,aAAa,CAAC;QAE3D,iCAAiC;QACjC,MAAM,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;QAE/C,kCAAkC;QAClC,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC5B,MAAM,KAAK,GAAG,IAAI,EAAE,KAAK,IAAI,IAAI,EAAE,CAAC;QACpC,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;QAC5B,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC,CAAC,gBAAgB;QAChD,IAAI,IAAI,EAAE,QAAQ;YAAE,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;QAClE,IAAI,IAAI,EAAE,KAAK;YAAE,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QACzD,IAAI,IAAI,EAAE,OAAO;YAAE,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;QAE/D,qBAAqB;QACrB,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QAC/B,MAAM,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;QAEtE,OAAO,KAAK,CAAC;IACd,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,cAAc,CAAC,KAAa;QACjC,MAAM,IAAI,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAC9C,IAAI,IAAI,EAAE,CAAC;YACV,IAAI,CAAC;gBACJ,IAAI,CAAC,IAAI,EAAE,CAAC;YACb,CAAC;YAAC,MAAM,CAAC;gBACR,kBAAkB;YACnB,CAAC;YACD,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACrC,CAAC;QACD,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC7B,OAAO,CAAC,GAAG,CAAC,iDAAiD,KAAK,EAAE,CAAC,CAAC;IACvE,CAAC;IAED;;OAEG;IACH,WAAW;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACvB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,WAAW;QAChB,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,EAAE;YAAE,OAAO,KAAK,CAAC;QAC9C,IAAI,CAAC;YACJ,MAAM,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC;YAC1B,OAAO,IAAI,KAAK,SAAS,CAAC;QAC3B,CAAC;QAAC,MAAM,CAAC;YACR,OAAO,KAAK,CAAC;QACd,CAAC;IACF,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,aAAa,CAAC,KAAa;QAChC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACrB,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;QACvE,CAAC;QAED,IAAI,CAAC;YACJ,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,aAAa,CAAC;YAC3D,MAAM,WAAW,GAAG,eAAe,KAAK,EAAE,CAAC;YAE3C,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;YAEpE,OAAO;gBACN,OAAO,EAAE,IAAI,CAAC,WAAW,IAAI,CAAC;gBAC9B,MAAM,EAAE,IAAI,CAAC,eAAe,IAAI,CAAC;gBACjC,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,YAAY,IAAI,CAAC;gBAC5C,MAAM,EAAE,IAAI,CAAC,eAAe,IAAI,CAAC;gBACjC,OAAO,EAAE,CAAC,EAAE,2CAA2C;aACvD,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACR,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;QACvE,CAAC;IACF,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,YAAY,CAAC,IAAY,EAAE,QAAkB;QAC1D,IAAI,CAAC;YACJ,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAE/C,mCAAmC;YACnC,MAAM,gBAAgB,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,EAAE,CAAC;YACpD,MAAM,WAAW,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,gBAAgB,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;YAErE,IAAI,WAAW,CAAC,MAAM,KAAK,gBAAgB,CAAC,MAAM,EAAE,CAAC;gBACpD,MAAM,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE;oBACnC,GAAG,IAAI,CAAC,MAAM;oBACd,QAAQ,EAAE,WAAW;iBACrB,CAAC,CAAC;YACJ,CAAC;QACF,CAAC;QAAC,MAAM,CAAC;YACR,kCAAkC;YAClC,MAAM,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC;gBAC1B,IAAI;gBACJ,QAAQ;gBACR,mFAAmF;gBACnF,SAAS,EAAE,WAAkB;gBAC7B,WAAW,EAAE,CAAC,EAAE,yCAAyC;gBACzD,+EAA+E;gBAC/E,OAAO,EAAE,MAAa;aACtB,CAAC,CAAC;QACJ,CAAC;IACF,CAAC;CACD;AAED;;GAEG;AACH,MAAM,SAAS;IACN,OAAO,CAAS;IAChB,OAAO,GAAsB,EAAE,CAAC;IAExC,YAAY,OAAe;QAC1B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACxB,CAAC;IAED,KAAK,CAAC,OAAO;QACZ,IAAI,IAAI,CAAC,OAAO,GAAG,CAAC,EAAE,CAAC;YACtB,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,OAAO;QACR,CAAC;QACD,OAAO,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;YACpC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC5B,CAAC,CAAC,CAAC;IACJ,CAAC;IAED,OAAO;QACN,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QAClC,IAAI,IAAI,EAAE,CAAC;YACV,IAAI,EAAE,CAAC;QACR,CAAC;aAAM,CAAC;YACP,IAAI,CAAC,OAAO,EAAE,CAAC;QAChB,CAAC;IACF,CAAC;CACD;AAED,eAAe,iBAAiB,CAAC","sourcesContent":["/**\n * NATSAdapter - NATS JetStream worker adapter for WorkerTrigger\n *\n * Uses NATS JetStream for persistent background job processing with:\n * - Pull-based consumers with configurable concurrency\n * - Server-side retry config (max_deliver)\n * - Ack wait for job timeouts\n * - Priority via message headers\n * - Delayed job scheduling\n * - Queue statistics via consumer info\n *\n * Requires: npm install nats\n *\n * Environment variables:\n * - NATS_SERVERS: Comma-separated NATS server URLs (default: localhost:4222)\n * - NATS_TOKEN: Authentication token (optional)\n * - NATS_USER: Username for auth (optional)\n * - NATS_PASS: Password for auth (optional)\n * - NATS_STREAM_NAME: JetStream stream name (default: blok-worker)\n */\n\nimport type { WorkerTriggerOpts } from \"@blokjs/helper\";\nimport { v4 as uuid } from \"uuid\";\nimport type { WorkerAdapter, WorkerJob, WorkerQueueStats } from \"../WorkerTrigger\";\n\n/**\n * Tier 2 polish — compute the consumer-side hold time for a NATS message\n * with an `x-delay` header. NATS JetStream stores `x-delay` as opaque\n * metadata; the broker does NOT defer delivery on it. The consumer is\n * responsible for honouring the delay between the message's first-publish\n * timestamp and `createdMs + delay`.\n *\n * Returns the milliseconds to wait. Clamps to >= 0; returns 0 when the\n * delay has already elapsed (the message was queued for longer than the\n * delay) or when no delay was set.\n *\n * Exported for unit testability — the consumer message handler in\n * `NATSWorkerAdapter.process()` mocks the NATS client extensively, so\n * isolating the math here keeps the surface easy to verify.\n */\nexport function computeXDelayHoldMs(delay: number, createdMs: number, nowMs: number): number {\n\tif (!delay || delay <= 0) return 0;\n\tconst dispatchAt = createdMs + delay;\n\treturn Math.max(0, dispatchAt - nowMs);\n}\n\n/**\n * NATS worker adapter configuration\n */\nexport interface NATSWorkerConfig {\n\t/** NATS server URLs */\n\tservers: string[];\n\t/** Authentication token */\n\ttoken?: string;\n\t/** Username */\n\tuser?: string;\n\t/** Password */\n\tpass?: string;\n\t/** JetStream stream name (default: \"blok-worker\") */\n\tstreamName?: string;\n}\n\n/**\n * NATSWorkerAdapter - NATS JetStream implementation of WorkerAdapter\n */\nexport class NATSWorkerAdapter implements WorkerAdapter {\n\treadonly provider = \"nats\" as const;\n\n\t// biome-ignore lint/suspicious/noExplicitAny: NATS types are dynamically imported (optional peer dependency)\n\tprivate nc: any = null;\n\t// biome-ignore lint/suspicious/noExplicitAny: NATS types are dynamically imported\n\tprivate js: any = null;\n\t// biome-ignore lint/suspicious/noExplicitAny: NATS types are dynamically imported\n\tprivate jsm: any = null;\n\tprivate connected = false;\n\tprivate config: NATSWorkerConfig;\n\t// biome-ignore lint/suspicious/noExplicitAny: NATS consumer instances\n\tprivate consumers: Map<string, any> = new Map();\n\t// biome-ignore lint/suspicious/noExplicitAny: NATS consume iterators\n\tprivate consumeIterators: Map<string, any> = new Map();\n\n\tconstructor(config?: Partial<NATSWorkerConfig>) {\n\t\tthis.config = {\n\t\t\tservers: config?.servers || (process.env.NATS_SERVERS || \"localhost:4222\").split(\",\"),\n\t\t\ttoken: config?.token || process.env.NATS_TOKEN,\n\t\t\tuser: config?.user || process.env.NATS_USER,\n\t\t\tpass: config?.pass || process.env.NATS_PASS,\n\t\t\tstreamName: config?.streamName || process.env.NATS_STREAM_NAME || \"blok-worker\",\n\t\t};\n\t}\n\n\t/**\n\t * Connect to NATS and initialize JetStream\n\t */\n\tasync connect(): Promise<void> {\n\t\tif (this.connected) return;\n\n\t\ttry {\n\t\t\tconst nats = await import(\"nats\");\n\n\t\t\tconst connectOpts: Record<string, unknown> = {\n\t\t\t\tservers: this.config.servers,\n\t\t\t};\n\n\t\t\tif (this.config.token) connectOpts.token = this.config.token;\n\t\t\tif (this.config.user) connectOpts.user = this.config.user;\n\t\t\tif (this.config.pass) connectOpts.pass = this.config.pass;\n\n\t\t\tthis.nc = await nats.connect(connectOpts);\n\t\t\tthis.js = this.nc.jetstream();\n\t\t\tthis.jsm = await this.nc.jetstreamManager();\n\n\t\t\tthis.connected = true;\n\t\t\tconsole.log(`[NATSWorkerAdapter] Connected to NATS: ${this.config.servers.join(\", \")}`);\n\t\t} catch (error) {\n\t\t\tthrow new Error(\n\t\t\t\t`Failed to connect to NATS: ${(error as Error).message}. Make sure nats is installed: npm install nats`,\n\t\t\t);\n\t\t}\n\t}\n\n\t/**\n\t * Disconnect from NATS\n\t */\n\tasync disconnect(): Promise<void> {\n\t\tif (!this.connected) return;\n\n\t\ttry {\n\t\t\t// Stop all consume iterators\n\t\t\tfor (const [, iter] of this.consumeIterators) {\n\t\t\t\ttry {\n\t\t\t\t\titer.stop();\n\t\t\t\t} catch {\n\t\t\t\t\t// Iterator may already be stopped\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.consumeIterators.clear();\n\t\t\tthis.consumers.clear();\n\n\t\t\tawait this.nc.drain();\n\t\t\tthis.connected = false;\n\t\t\tconsole.log(\"[NATSWorkerAdapter] Disconnected from NATS\");\n\t\t} catch (error) {\n\t\t\tconsole.error(`[NATSWorkerAdapter] Disconnect error: ${(error as Error).message}`);\n\t\t}\n\t}\n\n\t/**\n\t * Start processing jobs from a queue\n\t */\n\tasync process(config: WorkerTriggerOpts, handler: (job: WorkerJob) => Promise<void>): Promise<void> {\n\t\tif (!this.connected) {\n\t\t\tthrow new Error(\"Not connected. Call connect() first.\");\n\t\t}\n\n\t\tconst nats = await import(\"nats\");\n\t\tconst queue = config.queue;\n\t\tconst streamName = this.config.streamName || \"blok-worker\";\n\t\tconst subject = `worker.${queue}`;\n\t\tconst durableName = `blok-worker-${queue}`;\n\n\t\t// Ensure stream exists with worker subjects\n\t\tawait this.ensureStream(streamName, [subject]);\n\n\t\t// Create or update durable pull consumer with worker semantics\n\t\tconst ackWaitNs = ((config.timeout ?? 30000) + 5000) * 1_000_000; // timeout + 5s buffer, in nanoseconds\n\t\tawait this.jsm.consumers.add(streamName, {\n\t\t\tdurable_name: durableName,\n\t\t\tack_policy: nats.AckPolicy.Explicit,\n\t\t\tmax_deliver: (config.retries ?? 3) + 1, // +1 because first attempt counts\n\t\t\tack_wait: ackWaitNs,\n\t\t\tfilter_subjects: [subject],\n\t\t});\n\n\t\t// Get consumer handle\n\t\tconst consumer = await this.js.consumers.get(streamName, durableName);\n\t\tthis.consumers.set(queue, consumer);\n\n\t\t// Start consuming\n\t\tconst iter = await consumer.consume();\n\t\tthis.consumeIterators.set(queue, iter);\n\n\t\t// Process jobs in background\n\t\t(async () => {\n\t\t\tconst semaphore = new Semaphore(config.concurrency ?? 1);\n\n\t\t\tfor await (const msg of iter) {\n\t\t\t\tawait semaphore.acquire();\n\n\t\t\t\t// Process each job concurrently up to concurrency limit\n\t\t\t\t(async () => {\n\t\t\t\t\ttry {\n\t\t\t\t\t\t// Parse job data\n\t\t\t\t\t\tlet data: unknown;\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tconst codec = nats.JSONCodec();\n\t\t\t\t\t\t\tdata = codec.decode(msg.data);\n\t\t\t\t\t\t} catch {\n\t\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\t\tconst sc = nats.StringCodec();\n\t\t\t\t\t\t\t\tdata = JSON.parse(sc.decode(msg.data));\n\t\t\t\t\t\t\t} catch {\n\t\t\t\t\t\t\t\tdata = msg.data;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Extract headers\n\t\t\t\t\t\tconst headers: Record<string, string> = {};\n\t\t\t\t\t\tif (msg.headers) {\n\t\t\t\t\t\t\tfor (const [key, values] of msg.headers) {\n\t\t\t\t\t\t\t\theaders[key] = Array.isArray(values) ? values[0] : values;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Extract job metadata from headers\n\t\t\t\t\t\tconst jobId = headers[\"x-job-id\"] || msg.headers?.get(\"Nats-Msg-Id\") || uuid();\n\t\t\t\t\t\tconst priority = Number.parseInt(headers[\"x-priority\"] || \"0\", 10);\n\t\t\t\t\t\tconst delay = Number.parseInt(headers[\"x-delay\"] || \"0\", 10);\n\t\t\t\t\t\tconst timeout = Number.parseInt(headers[\"x-timeout\"] || \"0\", 10);\n\n\t\t\t\t\t\t// Get redelivery count (attempts)\n\t\t\t\t\t\tconst info = msg.info;\n\t\t\t\t\t\tconst attempts = info.redeliveryCount ?? 0;\n\t\t\t\t\t\tconst maxRetries = config.retries ?? 3;\n\n\t\t\t\t\t\t// Create WorkerJob\n\t\t\t\t\t\tconst workerJob: WorkerJob = {\n\t\t\t\t\t\t\tid: jobId,\n\t\t\t\t\t\t\tdata,\n\t\t\t\t\t\t\theaders,\n\t\t\t\t\t\t\tqueue,\n\t\t\t\t\t\t\tpriority,\n\t\t\t\t\t\t\tattempts,\n\t\t\t\t\t\t\tmaxRetries,\n\t\t\t\t\t\t\tcreatedAt: new Date(\n\t\t\t\t\t\t\t\tinfo.timestampNanos ? Math.floor(Number(info.timestampNanos) / 1_000_000) : Date.now(),\n\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\tdelay: delay || undefined,\n\t\t\t\t\t\t\ttimeout: timeout || config.timeout || undefined,\n\t\t\t\t\t\t\traw: msg,\n\t\t\t\t\t\t\tcomplete: async () => {\n\t\t\t\t\t\t\t\tmsg.ack();\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\tfail: async (error: Error, requeue?: boolean) => {\n\t\t\t\t\t\t\t\tif (requeue) {\n\t\t\t\t\t\t\t\t\t// nak() tells the server to redeliver\n\t\t\t\t\t\t\t\t\tmsg.nak();\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\t// term() terminates delivery — no more retries\n\t\t\t\t\t\t\t\t\tmsg.term();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t};\n\n\t\t\t\t\t\t// Tier 2 polish — enforce `x-delay` header on the consumer side.\n\t\t\t\t\t\t// NATS JetStream stores `x-delay` as opaque metadata; the broker\n\t\t\t\t\t\t// does NOT defer delivery on it. We implement consumer-side\n\t\t\t\t\t\t// holding here. createdMs is the message's first-publish timestamp;\n\t\t\t\t\t\t// hold until createdMs + delay. Single-process semantics — for\n\t\t\t\t\t\t// long deferrals, prefer trigger-level `delay` (DeferredRunScheduler).\n\t\t\t\t\t\tconst createdMs = info.timestampNanos ? Math.floor(Number(info.timestampNanos) / 1_000_000) : Date.now();\n\t\t\t\t\t\tconst waitMs = computeXDelayHoldMs(delay, createdMs, Date.now());\n\t\t\t\t\t\tif (waitMs > 0) {\n\t\t\t\t\t\t\tawait new Promise<void>((resolve) => setTimeout(resolve, waitMs));\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tawait handler(workerJob);\n\t\t\t\t\t} catch (error) {\n\t\t\t\t\t\tconsole.error(`[NATSWorkerAdapter] Error processing job from ${queue}: ${(error as Error).message}`);\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tmsg.nak();\n\t\t\t\t\t\t} catch {\n\t\t\t\t\t\t\t// Already acked/nacked\n\t\t\t\t\t\t}\n\t\t\t\t\t} finally {\n\t\t\t\t\t\tsemaphore.release();\n\t\t\t\t\t}\n\t\t\t\t})();\n\t\t\t}\n\t\t})();\n\n\t\tconsole.log(\n\t\t\t`[NATSWorkerAdapter] Processing queue: ${queue} (concurrency=${config.concurrency ?? 1}, retries=${config.retries ?? 3})`,\n\t\t);\n\t}\n\n\t/**\n\t * Add a job to a worker queue\n\t */\n\tasync addJob(\n\t\tqueue: string,\n\t\tdata: unknown,\n\t\topts?: {\n\t\t\tpriority?: number;\n\t\t\tdelay?: number;\n\t\t\tretries?: number;\n\t\t\ttimeout?: number;\n\t\t\tjobId?: string;\n\t\t},\n\t): Promise<string> {\n\t\tif (!this.connected) {\n\t\t\tthrow new Error(\"Not connected. Call connect() first.\");\n\t\t}\n\n\t\tconst nats = await import(\"nats\");\n\t\tconst subject = `worker.${queue}`;\n\t\tconst streamName = this.config.streamName || \"blok-worker\";\n\n\t\t// Ensure stream has this subject\n\t\tawait this.ensureStream(streamName, [subject]);\n\n\t\t// Build headers with job metadata\n\t\tconst hdrs = nats.headers();\n\t\tconst jobId = opts?.jobId || uuid();\n\t\thdrs.set(\"x-job-id\", jobId);\n\t\thdrs.set(\"Nats-Msg-Id\", jobId); // Deduplication\n\t\tif (opts?.priority) hdrs.set(\"x-priority\", String(opts.priority));\n\t\tif (opts?.delay) hdrs.set(\"x-delay\", String(opts.delay));\n\t\tif (opts?.timeout) hdrs.set(\"x-timeout\", String(opts.timeout));\n\n\t\t// Encode and publish\n\t\tconst codec = nats.JSONCodec();\n\t\tawait this.js.publish(subject, codec.encode(data), { headers: hdrs });\n\n\t\treturn jobId;\n\t}\n\n\t/**\n\t * Stop processing a specific queue\n\t */\n\tasync stopProcessing(queue: string): Promise<void> {\n\t\tconst iter = this.consumeIterators.get(queue);\n\t\tif (iter) {\n\t\t\ttry {\n\t\t\t\titer.stop();\n\t\t\t} catch {\n\t\t\t\t// Already stopped\n\t\t\t}\n\t\t\tthis.consumeIterators.delete(queue);\n\t\t}\n\t\tthis.consumers.delete(queue);\n\t\tconsole.log(`[NATSWorkerAdapter] Stopped processing queue: ${queue}`);\n\t}\n\n\t/**\n\t * Check if connected\n\t */\n\tisConnected(): boolean {\n\t\treturn this.connected;\n\t}\n\n\t/**\n\t * Health check\n\t */\n\tasync healthCheck(): Promise<boolean> {\n\t\tif (!this.connected || !this.nc) return false;\n\t\ttry {\n\t\t\tconst info = this.nc.info;\n\t\t\treturn info !== undefined;\n\t\t} catch {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\t/**\n\t * Get queue statistics from JetStream consumer info\n\t */\n\tasync getQueueStats(queue: string): Promise<WorkerQueueStats> {\n\t\tif (!this.connected) {\n\t\t\treturn { waiting: 0, active: 0, completed: 0, failed: 0, delayed: 0 };\n\t\t}\n\n\t\ttry {\n\t\t\tconst streamName = this.config.streamName || \"blok-worker\";\n\t\t\tconst durableName = `blok-worker-${queue}`;\n\n\t\t\tconst info = await this.jsm.consumers.info(streamName, durableName);\n\n\t\t\treturn {\n\t\t\t\twaiting: info.num_pending ?? 0,\n\t\t\t\tactive: info.num_ack_pending ?? 0,\n\t\t\t\tcompleted: info.delivered?.consumer_seq ?? 0,\n\t\t\t\tfailed: info.num_redelivered ?? 0,\n\t\t\t\tdelayed: 0, // NATS doesn't have a native delayed count\n\t\t\t};\n\t\t} catch {\n\t\t\treturn { waiting: 0, active: 0, completed: 0, failed: 0, delayed: 0 };\n\t\t}\n\t}\n\n\t/**\n\t * Ensure a JetStream stream exists with the given subjects\n\t */\n\tprivate async ensureStream(name: string, subjects: string[]): Promise<void> {\n\t\ttry {\n\t\t\tconst info = await this.jsm.streams.info(name);\n\n\t\t\t// Merge new subjects with existing\n\t\t\tconst existingSubjects = info.config.subjects || [];\n\t\t\tconst allSubjects = [...new Set([...existingSubjects, ...subjects])];\n\n\t\t\tif (allSubjects.length !== existingSubjects.length) {\n\t\t\t\tawait this.jsm.streams.update(name, {\n\t\t\t\t\t...info.config,\n\t\t\t\t\tsubjects: allSubjects,\n\t\t\t\t});\n\t\t\t}\n\t\t} catch {\n\t\t\t// Stream doesn't exist, create it\n\t\t\tawait this.jsm.streams.add({\n\t\t\t\tname,\n\t\t\t\tsubjects,\n\t\t\t\t// biome-ignore lint/suspicious/noExplicitAny: nats JetStream retention policy enum\n\t\t\t\tretention: \"workqueue\" as any,\n\t\t\t\tmax_deliver: 4, // default: 3 retries + 1 initial attempt\n\t\t\t\t// biome-ignore lint/suspicious/noExplicitAny: nats JetStream storage type enum\n\t\t\t\tstorage: \"file\" as any,\n\t\t\t});\n\t\t}\n\t}\n}\n\n/**\n * Simple semaphore for concurrency control\n */\nclass Semaphore {\n\tprivate permits: number;\n\tprivate waiting: Array<() => void> = [];\n\n\tconstructor(permits: number) {\n\t\tthis.permits = permits;\n\t}\n\n\tasync acquire(): Promise<void> {\n\t\tif (this.permits > 0) {\n\t\t\tthis.permits--;\n\t\t\treturn;\n\t\t}\n\t\treturn new Promise<void>((resolve) => {\n\t\t\tthis.waiting.push(resolve);\n\t\t});\n\t}\n\n\trelease(): void {\n\t\tconst next = this.waiting.shift();\n\t\tif (next) {\n\t\t\tnext();\n\t\t} else {\n\t\t\tthis.permits++;\n\t\t}\n\t}\n}\n\nexport default NATSWorkerAdapter;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"NATSAdapter.js","sourceRoot":"","sources":["../../src/adapters/NATSAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * NATSAdapter - NATS JetStream worker adapter for WorkerTrigger\n *\n * Uses NATS JetStream for persistent background job processing with:\n * - Pull-based consumers with configurable concurrency\n * - Server-side retry config (max_deliver)\n * - Ack wait for job timeouts\n * - Priority via message headers\n * - Delayed job scheduling\n * - Queue statistics via consumer info\n *\n * Requires: npm install nats\n *\n * Environment variables:\n * - NATS_SERVERS: Comma-separated NATS server URLs (default: localhost:4222)\n * - NATS_TOKEN: Authentication token (optional)\n * - NATS_USER: Username for auth (optional)\n * - NATS_PASS: Password for auth (optional)\n * - NATS_STREAM_NAME: JetStream stream name (default: blok-worker)\n */\n\nimport type { WorkerTriggerOpts } from \"@blokjs/helper\";\nimport { v4 as uuid } from \"uuid\";\nimport type { WorkerAdapter, WorkerJob, WorkerQueueStats } from \"../WorkerTrigger\";\n\n/**\n * Tier 2 polish — compute the consumer-side hold time for a NATS message\n * with an `x-delay` header. NATS JetStream stores `x-delay` as opaque\n * metadata; the broker does NOT defer delivery on it. The consumer is\n * responsible for honouring the delay between the message's first-publish\n * timestamp and `createdMs + delay`.\n *\n * Returns the milliseconds to wait. Clamps to >= 0; returns 0 when the\n * delay has already elapsed (the message was queued for longer than the\n * delay) or when no delay was set.\n *\n * Exported for unit testability — the consumer message handler in\n * `NATSWorkerAdapter.process()` mocks the NATS client extensively, so\n * isolating the math here keeps the surface easy to verify.\n */\nexport function computeXDelayHoldMs(delay: number, createdMs: number, nowMs: number): number {\n\tif (!delay || delay <= 0) return 0;\n\tconst dispatchAt = createdMs + delay;\n\treturn Math.max(0, dispatchAt - nowMs);\n}\n\n/**\n * NATS worker adapter configuration\n */\nexport interface NATSWorkerConfig {\n\t/** NATS server URLs */\n\tservers: string[];\n\t/** Authentication token */\n\ttoken?: string;\n\t/** Username */\n\tuser?: string;\n\t/** Password */\n\tpass?: string;\n\t/** JetStream stream name (default: \"blok-worker\") */\n\tstreamName?: string;\n}\n\n/**\n * NATSWorkerAdapter - NATS JetStream implementation of WorkerAdapter\n */\nexport class NATSWorkerAdapter implements WorkerAdapter {\n\treadonly provider = \"nats\" as const;\n\n\t// biome-ignore lint/suspicious/noExplicitAny: NATS types are dynamically imported (optional peer dependency)\n\tprivate nc: any = null;\n\t// biome-ignore lint/suspicious/noExplicitAny: NATS types are dynamically imported\n\tprivate js: any = null;\n\t// biome-ignore lint/suspicious/noExplicitAny: NATS types are dynamically imported\n\tprivate jsm: any = null;\n\tprivate connected = false;\n\tprivate config: NATSWorkerConfig;\n\t// biome-ignore lint/suspicious/noExplicitAny: NATS consumer instances\n\tprivate consumers: Map<string, any> = new Map();\n\t// biome-ignore lint/suspicious/noExplicitAny: NATS consume iterators\n\tprivate consumeIterators: Map<string, any> = new Map();\n\n\tconstructor(config?: Partial<NATSWorkerConfig>) {\n\t\tthis.config = {\n\t\t\tservers: config?.servers || (process.env.NATS_SERVERS || \"localhost:4222\").split(\",\"),\n\t\t\ttoken: config?.token || process.env.NATS_TOKEN,\n\t\t\tuser: config?.user || process.env.NATS_USER,\n\t\t\tpass: config?.pass || process.env.NATS_PASS,\n\t\t\tstreamName: config?.streamName || process.env.NATS_STREAM_NAME || \"blok-worker\",\n\t\t};\n\t}\n\n\t/**\n\t * Connect to NATS and initialize JetStream\n\t */\n\tasync connect(): Promise<void> {\n\t\tif (this.connected) return;\n\n\t\ttry {\n\t\t\tconst nats = await import(\"nats\");\n\n\t\t\tconst connectOpts: Record<string, unknown> = {\n\t\t\t\tservers: this.config.servers,\n\t\t\t};\n\n\t\t\tif (this.config.token) connectOpts.token = this.config.token;\n\t\t\tif (this.config.user) connectOpts.user = this.config.user;\n\t\t\tif (this.config.pass) connectOpts.pass = this.config.pass;\n\n\t\t\tthis.nc = await nats.connect(connectOpts);\n\t\t\tthis.js = this.nc.jetstream();\n\t\t\tthis.jsm = await this.nc.jetstreamManager();\n\n\t\t\tthis.connected = true;\n\t\t\tconsole.log(`[NATSWorkerAdapter] Connected to NATS: ${this.config.servers.join(\", \")}`);\n\t\t} catch (error) {\n\t\t\tthrow new Error(\n\t\t\t\t`Failed to connect to NATS: ${(error as Error).message}. Make sure nats is installed: npm install nats`,\n\t\t\t);\n\t\t}\n\t}\n\n\t/**\n\t * Disconnect from NATS\n\t */\n\tasync disconnect(): Promise<void> {\n\t\tif (!this.connected) return;\n\n\t\ttry {\n\t\t\t// Stop all consume iterators\n\t\t\tfor (const [, iter] of this.consumeIterators) {\n\t\t\t\ttry {\n\t\t\t\t\titer.stop();\n\t\t\t\t} catch {\n\t\t\t\t\t// Iterator may already be stopped\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.consumeIterators.clear();\n\t\t\tthis.consumers.clear();\n\n\t\t\tawait this.nc.drain();\n\t\t\tthis.connected = false;\n\t\t\tconsole.log(\"[NATSWorkerAdapter] Disconnected from NATS\");\n\t\t} catch (error) {\n\t\t\tconsole.error(`[NATSWorkerAdapter] Disconnect error: ${(error as Error).message}`);\n\t\t}\n\t}\n\n\t/**\n\t * Start processing jobs from a queue\n\t */\n\tasync process(config: WorkerTriggerOpts, handler: (job: WorkerJob) => Promise<void>): Promise<void> {\n\t\tif (!this.connected) {\n\t\t\tthrow new Error(\"Not connected. Call connect() first.\");\n\t\t}\n\n\t\tconst nats = await import(\"nats\");\n\t\tconst queue = config.queue;\n\t\tconst streamName = this.config.streamName || \"blok-worker\";\n\t\tconst subject = `worker.${queue}`;\n\t\tconst durableName = `blok-worker-${queue}`;\n\n\t\t// Ensure stream exists with worker subjects\n\t\tawait this.ensureStream(streamName, [subject]);\n\n\t\t// v0.7 — `ack: false` selects at-most-once delivery. JetStream PULL\n\t\t// consumers reject AckPolicy.None (\"consumer in pull mode requires ack\n\t\t// policy\"), so at-most-once is implemented as AckPolicy.Explicit +\n\t\t// max_deliver:1 with the message ACKed on receipt (before the handler\n\t\t// runs). The broker then treats the message as delivered+done, so a\n\t\t// handler that throws is NOT redelivered — exactly-once delivery even\n\t\t// on failure. The manual ack/nak/term path below is a no-op in this mode.\n\t\tconst atMostOnce = config.ack === false;\n\n\t\t// Create or update durable pull consumer with worker semantics\n\t\tconst ackWaitNs = ((config.timeout ?? 30000) + 5000) * 1_000_000; // timeout + 5s buffer, in nanoseconds\n\t\tawait this.jsm.consumers.add(streamName, {\n\t\t\tdurable_name: durableName,\n\t\t\tack_policy: nats.AckPolicy.Explicit,\n\t\t\t// at-most-once: deliver exactly once, never redeliver.\n\t\t\tmax_deliver: atMostOnce ? 1 : (config.retries ?? 3) + 1, // +1 because first attempt counts\n\t\t\tack_wait: ackWaitNs,\n\t\t\tfilter_subjects: [subject],\n\t\t});\n\n\t\t// Get consumer handle\n\t\tconst consumer = await this.js.consumers.get(streamName, durableName);\n\t\tthis.consumers.set(queue, consumer);\n\n\t\t// Start consuming\n\t\tconst iter = await consumer.consume();\n\t\tthis.consumeIterators.set(queue, iter);\n\n\t\t// Process jobs in background\n\t\t(async () => {\n\t\t\tconst semaphore = new Semaphore(config.concurrency ?? 1);\n\n\t\t\tfor await (const msg of iter) {\n\t\t\t\tawait semaphore.acquire();\n\n\t\t\t\t// Process each job concurrently up to concurrency limit\n\t\t\t\t(async () => {\n\t\t\t\t\ttry {\n\t\t\t\t\t\t// Parse job data\n\t\t\t\t\t\tlet data: unknown;\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tconst codec = nats.JSONCodec();\n\t\t\t\t\t\t\tdata = codec.decode(msg.data);\n\t\t\t\t\t\t} catch {\n\t\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\t\tconst sc = nats.StringCodec();\n\t\t\t\t\t\t\t\tdata = JSON.parse(sc.decode(msg.data));\n\t\t\t\t\t\t\t} catch {\n\t\t\t\t\t\t\t\tdata = msg.data;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Extract headers\n\t\t\t\t\t\tconst headers: Record<string, string> = {};\n\t\t\t\t\t\tif (msg.headers) {\n\t\t\t\t\t\t\tfor (const [key, values] of msg.headers) {\n\t\t\t\t\t\t\t\theaders[key] = Array.isArray(values) ? values[0] : values;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Extract job metadata from headers\n\t\t\t\t\t\tconst jobId = headers[\"x-job-id\"] || msg.headers?.get(\"Nats-Msg-Id\") || uuid();\n\t\t\t\t\t\tconst priority = Number.parseInt(headers[\"x-priority\"] || \"0\", 10);\n\t\t\t\t\t\tconst delay = Number.parseInt(headers[\"x-delay\"] || \"0\", 10);\n\t\t\t\t\t\tconst timeout = Number.parseInt(headers[\"x-timeout\"] || \"0\", 10);\n\n\t\t\t\t\t\t// Get redelivery count (attempts)\n\t\t\t\t\t\tconst info = msg.info;\n\t\t\t\t\t\tconst attempts = info.redeliveryCount ?? 0;\n\t\t\t\t\t\tconst maxRetries = config.retries ?? 3;\n\n\t\t\t\t\t\t// Create WorkerJob\n\t\t\t\t\t\tconst workerJob: WorkerJob = {\n\t\t\t\t\t\t\tid: jobId,\n\t\t\t\t\t\t\tdata,\n\t\t\t\t\t\t\theaders,\n\t\t\t\t\t\t\tqueue,\n\t\t\t\t\t\t\tpriority,\n\t\t\t\t\t\t\tattempts,\n\t\t\t\t\t\t\tmaxRetries,\n\t\t\t\t\t\t\tcreatedAt: new Date(\n\t\t\t\t\t\t\t\tinfo.timestampNanos ? Math.floor(Number(info.timestampNanos) / 1_000_000) : Date.now(),\n\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\tdelay: delay || undefined,\n\t\t\t\t\t\t\ttimeout: timeout || config.timeout || undefined,\n\t\t\t\t\t\t\traw: msg,\n\t\t\t\t\t\t\tcomplete: async () => {\n\t\t\t\t\t\t\t\t// Already ACKed on receipt under at-most-once; a second ack errors.\n\t\t\t\t\t\t\t\tif (!atMostOnce) msg.ack();\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\tfail: async (error: Error, requeue?: boolean) => {\n\t\t\t\t\t\t\t\tif (requeue) {\n\t\t\t\t\t\t\t\t\t// nak() tells the server to redeliver. No-op under\n\t\t\t\t\t\t\t\t\t// at-most-once — the message was already ACKed on receipt.\n\t\t\t\t\t\t\t\t\tif (!atMostOnce) msg.nak();\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\t// Terminal failure (retries exhausted / non-requeue).\n\t\t\t\t\t\t\t\t\t// v0.7 — dead-letter the original payload+headers to\n\t\t\t\t\t\t\t\t\t// `worker.${deadLetterQueue}` before terminating so the\n\t\t\t\t\t\t\t\t\t// message isn't silently dropped. No-op when DLQ is unset.\n\t\t\t\t\t\t\t\t\tawait this.deadLetter(config.deadLetterQueue, msg.data, msg.headers);\n\t\t\t\t\t\t\t\t\t// term() terminates delivery — no more retries. Already\n\t\t\t\t\t\t\t\t\t// ACKed under at-most-once, so term() is skipped there.\n\t\t\t\t\t\t\t\t\tif (!atMostOnce) msg.term();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t};\n\n\t\t\t\t\t\t// at-most-once — ACK before running the handler so the broker\n\t\t\t\t\t\t// considers the message done. max_deliver:1 already prevents\n\t\t\t\t\t\t// redelivery; this also releases the ack_wait timer immediately.\n\t\t\t\t\t\tif (atMostOnce) msg.ack();\n\n\t\t\t\t\t\t// Tier 2 polish — enforce `x-delay` header on the consumer side.\n\t\t\t\t\t\t// NATS JetStream stores `x-delay` as opaque metadata; the broker\n\t\t\t\t\t\t// does NOT defer delivery on it. We implement consumer-side\n\t\t\t\t\t\t// holding here. createdMs is the message's first-publish timestamp;\n\t\t\t\t\t\t// hold until createdMs + delay. Single-process semantics — for\n\t\t\t\t\t\t// long deferrals, prefer trigger-level `delay` (DeferredRunScheduler).\n\t\t\t\t\t\tconst createdMs = info.timestampNanos ? Math.floor(Number(info.timestampNanos) / 1_000_000) : Date.now();\n\t\t\t\t\t\tconst waitMs = computeXDelayHoldMs(delay, createdMs, Date.now());\n\t\t\t\t\t\tif (waitMs > 0) {\n\t\t\t\t\t\t\tawait new Promise<void>((resolve) => setTimeout(resolve, waitMs));\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tawait handler(workerJob);\n\t\t\t\t\t} catch (error) {\n\t\t\t\t\t\tconsole.error(`[NATSWorkerAdapter] Error processing job from ${queue}: ${(error as Error).message}`);\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\t// Under at-most-once there's nothing to nak — the broker isn't\n\t\t\t\t\t\t\t// tracking delivery, so a handler throw must NOT trigger redelivery.\n\t\t\t\t\t\t\tif (!atMostOnce) msg.nak();\n\t\t\t\t\t\t} catch {\n\t\t\t\t\t\t\t// Already acked/nacked\n\t\t\t\t\t\t}\n\t\t\t\t\t} finally {\n\t\t\t\t\t\tsemaphore.release();\n\t\t\t\t\t}\n\t\t\t\t})();\n\t\t\t}\n\t\t})();\n\n\t\tconsole.log(\n\t\t\t`[NATSWorkerAdapter] Processing queue: ${queue} (concurrency=${config.concurrency ?? 1}, retries=${config.retries ?? 3})`,\n\t\t);\n\t}\n\n\t/**\n\t * Add a job to a worker queue\n\t */\n\tasync addJob(\n\t\tqueue: string,\n\t\tdata: unknown,\n\t\topts?: {\n\t\t\tpriority?: number;\n\t\t\tdelay?: number;\n\t\t\tretries?: number;\n\t\t\ttimeout?: number;\n\t\t\tjobId?: string;\n\t\t},\n\t): Promise<string> {\n\t\tif (!this.connected) {\n\t\t\tthrow new Error(\"Not connected. Call connect() first.\");\n\t\t}\n\n\t\tconst nats = await import(\"nats\");\n\t\tconst subject = `worker.${queue}`;\n\t\tconst streamName = this.config.streamName || \"blok-worker\";\n\n\t\t// Ensure stream has this subject\n\t\tawait this.ensureStream(streamName, [subject]);\n\n\t\t// Build headers with job metadata\n\t\tconst hdrs = nats.headers();\n\t\tconst jobId = opts?.jobId || uuid();\n\t\thdrs.set(\"x-job-id\", jobId);\n\t\thdrs.set(\"Nats-Msg-Id\", jobId); // Deduplication\n\t\tif (opts?.priority) hdrs.set(\"x-priority\", String(opts.priority));\n\t\tif (opts?.delay) hdrs.set(\"x-delay\", String(opts.delay));\n\t\tif (opts?.timeout) hdrs.set(\"x-timeout\", String(opts.timeout));\n\n\t\t// Encode and publish\n\t\tconst codec = nats.JSONCodec();\n\t\tawait this.js.publish(subject, codec.encode(data), { headers: hdrs });\n\n\t\treturn jobId;\n\t}\n\n\t/**\n\t * Stop processing a specific queue\n\t */\n\tasync stopProcessing(queue: string): Promise<void> {\n\t\tconst iter = this.consumeIterators.get(queue);\n\t\tif (iter) {\n\t\t\ttry {\n\t\t\t\titer.stop();\n\t\t\t} catch {\n\t\t\t\t// Already stopped\n\t\t\t}\n\t\t\tthis.consumeIterators.delete(queue);\n\t\t}\n\t\tthis.consumers.delete(queue);\n\t\tconsole.log(`[NATSWorkerAdapter] Stopped processing queue: ${queue}`);\n\t}\n\n\t/**\n\t * Check if connected\n\t */\n\tisConnected(): boolean {\n\t\treturn this.connected;\n\t}\n\n\t/**\n\t * Health check\n\t */\n\tasync healthCheck(): Promise<boolean> {\n\t\tif (!this.connected || !this.nc) return false;\n\t\ttry {\n\t\t\tconst info = this.nc.info;\n\t\t\treturn info !== undefined;\n\t\t} catch {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\t/**\n\t * Get queue statistics from JetStream consumer info\n\t */\n\tasync getQueueStats(queue: string): Promise<WorkerQueueStats> {\n\t\tif (!this.connected) {\n\t\t\treturn { waiting: 0, active: 0, completed: 0, failed: 0, delayed: 0 };\n\t\t}\n\n\t\ttry {\n\t\t\tconst streamName = this.config.streamName || \"blok-worker\";\n\t\t\tconst durableName = `blok-worker-${queue}`;\n\n\t\t\tconst info = await this.jsm.consumers.info(streamName, durableName);\n\n\t\t\treturn {\n\t\t\t\twaiting: info.num_pending ?? 0,\n\t\t\t\tactive: info.num_ack_pending ?? 0,\n\t\t\t\tcompleted: info.delivered?.consumer_seq ?? 0,\n\t\t\t\tfailed: info.num_redelivered ?? 0,\n\t\t\t\tdelayed: 0, // NATS doesn't have a native delayed count\n\t\t\t};\n\t\t} catch {\n\t\t\treturn { waiting: 0, active: 0, completed: 0, failed: 0, delayed: 0 };\n\t\t}\n\t}\n\n\t/**\n\t * v0.7 — dead-letter an exhausted message. Publishes the ORIGINAL payload\n\t * and headers to the `worker.${deadLetterQueue}` subject so a downstream\n\t * consumer can inspect/replay it. Plain core publish (not JetStream): the\n\t * DLQ is a notification subject, not part of the workqueue stream, so we\n\t * avoid coupling it to stream-subject management. No-op when DLQ is unset.\n\t *\n\t * ponytail: core publish, not a persisted DLQ stream. Upgrade to a\n\t * dedicated DLQ JetStream stream if durable dead-letter storage is needed.\n\t */\n\tprivate async deadLetter(\n\t\tdeadLetterQueue: string | undefined,\n\t\tdata: Uint8Array,\n\t\t// biome-ignore lint/suspicious/noExplicitAny: NATS MsgHdrs type is dynamically imported\n\t\theaders: any,\n\t): Promise<void> {\n\t\tif (!deadLetterQueue) return;\n\t\ttry {\n\t\t\tthis.nc.publish(`worker.${deadLetterQueue}`, data, headers ? { headers } : undefined);\n\t\t} catch (error) {\n\t\t\tconsole.error(\n\t\t\t\t`[NATSWorkerAdapter] Failed to dead-letter to worker.${deadLetterQueue}: ${(error as Error).message}`,\n\t\t\t);\n\t\t}\n\t}\n\n\t/**\n\t * Ensure a JetStream stream exists with the given subjects\n\t */\n\tprivate async ensureStream(name: string, subjects: string[]): Promise<void> {\n\t\ttry {\n\t\t\tconst info = await this.jsm.streams.info(name);\n\n\t\t\t// Merge new subjects with existing\n\t\t\tconst existingSubjects = info.config.subjects || [];\n\t\t\tconst allSubjects = [...new Set([...existingSubjects, ...subjects])];\n\n\t\t\tif (allSubjects.length !== existingSubjects.length) {\n\t\t\t\tawait this.jsm.streams.update(name, {\n\t\t\t\t\t...info.config,\n\t\t\t\t\tsubjects: allSubjects,\n\t\t\t\t});\n\t\t\t}\n\t\t} catch {\n\t\t\t// Stream doesn't exist, create it\n\t\t\tawait this.jsm.streams.add({\n\t\t\t\tname,\n\t\t\t\tsubjects,\n\t\t\t\t// biome-ignore lint/suspicious/noExplicitAny: nats JetStream retention policy enum\n\t\t\t\tretention: \"workqueue\" as any,\n\t\t\t\tmax_deliver: 4, // default: 3 retries + 1 initial attempt\n\t\t\t\t// biome-ignore lint/suspicious/noExplicitAny: nats JetStream storage type enum\n\t\t\t\tstorage: \"file\" as any,\n\t\t\t});\n\t\t}\n\t}\n}\n\n/**\n * Simple semaphore for concurrency control\n */\nclass Semaphore {\n\tprivate permits: number;\n\tprivate waiting: Array<() => void> = [];\n\n\tconstructor(permits: number) {\n\t\tthis.permits = permits;\n\t}\n\n\tasync acquire(): Promise<void> {\n\t\tif (this.permits > 0) {\n\t\t\tthis.permits--;\n\t\t\treturn;\n\t\t}\n\t\treturn new Promise<void>((resolve) => {\n\t\t\tthis.waiting.push(resolve);\n\t\t});\n\t}\n\n\trelease(): void {\n\t\tconst next = this.waiting.shift();\n\t\tif (next) {\n\t\t\tnext();\n\t\t} else {\n\t\t\tthis.permits++;\n\t\t}\n\t}\n}\n\nexport default NATSWorkerAdapter;\n"]}