@blokjs/trigger-worker 1.0.0 → 1.2.0

package/dist/adapters/RedisStreamsAdapter.js

@@ -6,15 +6,36 @@
  * Semantics:
  *   - **Consumer groups**: required. `consumerGroup` defaults to
  *     `"${queue}-group"`. The group is auto-created (`MKSTREAM` on the
- *     stream too) on first `process()` call.
+ *     stream too) on first `process()` call, at the `startFrom` cursor
+ *     (`"latest"` → `$` default, `"earliest"` → `0`, or `fromBeginning`).
  *   - **Consumer name**: per-process uuid, so multiple instances of
  *     the same worker process don't share pending entries.
- *   - **Retries**: pending entries are XACK'd on success / left
- *     unacked on failure (visible in `XPENDING`). A redrive loop
- *     reads pending entries older than `timeout` and re-delivers
- *     to the current consumer.
- *   - **Auto-claim**: skipped in v1 — operators should run XAUTOCLAIM
- *     periodically out of band.
+ *   - **ACK / retries**: ACK happens exactly once via `job.complete()`
+ *     (success) — the consumer loop does NOT double-ACK. A terminal
+ *     `job.fail(err, false)` XADDs the payload to `deadLetterQueue`
+ *     (when configured) then XACKs the source so it isn't redelivered.
+ *     A requeue `job.fail(err, true)` leaves the entry pending (visible
+ *     in `XPENDING`) for redrive.
+ *   - **ack:false**: the consumer reads with NOACK, so Redis never
+ *     adds entries to the group's PEL — at-most-once, no leaked pending.
+ *   - **Redrive**: an in-process periodic XAUTOCLAIM loop reclaims stale
+ *     pending entries (idle > `config.timeout`) — left by a crashed
+ *     consumer or a requeue `fail(err, true)` — and re-runs them through
+ *     the handler. Redis bumps each entry's delivery count on every
+ *     claim; once it exceeds `retries + 1` the entry is dead-lettered
+ *     (when `deadLetterQueue` is set) and XACKed. The redrive loop only
+ *     runs when `config.timeout` is set (it IS the idle threshold — with
+ *     no timeout a slow-but-alive handler is indistinguishable from a
+ *     dead one) and NOT under `ack:false` (nothing lands in the PEL).
+ *   - **No native delay / priority**: Redis Streams has neither. `addJob`
+ *     THROWS on `opts.delay` / `opts.priority` rather than silently
+ *     dropping them — use a scheduler trigger for delayed work.
+ *   - **Concurrency**: each of the `concurrency` consumer loops owns a
+ *     DEDICATED ioredis connection (`client.duplicate()`) so their
+ *     blocking XREADGROUP calls run in parallel instead of serializing on
+ *     one shared socket — ioredis requires a separate client per blocking
+ *     command. The shared `this.client` handles non-blocking ops
+ *     (XADD / XACK / XGROUP / XAUTOCLAIM).
  *
  * Requires `ioredis` as a peer dependency:
  *
@@ -68,8 +89,11 @@ export class RedisStreamsAdapter {
     async disconnect() {
         if (!this.connected)
             return;
-        for (const runner of this.runners.values())
+        for (const runner of this.runners.values()) {
             runner.stop = true;
+            if (runner.redrive)
+                clearInterval(runner.redrive);
+        }
         // Wait for in-flight loops to drain.
         const drainDeadline = Date.now() + 2000;
         while (Date.now() < drainDeadline) {
@@ -80,6 +104,17 @@ export class RedisStreamsAdapter {
                 break;
             await new Promise((r) => setTimeout(r, 50));
         }
+        // Close each loop's dedicated blocking connection.
+        for (const runner of this.runners.values()) {
+            for (const conn of runner.conns) {
+                try {
+                    await conn.quit();
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+        }
         this.runners.clear();
         try {
             await this.client?.quit();
@@ -95,35 +130,69 @@ export class RedisStreamsAdapter {
             throw new Error("[blok][redis] not connected. Call connect() first.");
         const stream = config.queue;
         const group = config.consumerGroup ?? `${stream}-group`;
-        // Create group + stream if missing. XGROUP CREATE with MKSTREAM
-        // errors with "BUSYGROUP" if the group already exists — swallow it.
+        // Create group + stream if missing, at the requested start cursor.
+        // XGROUP CREATE with MKSTREAM errors with "BUSYGROUP" if the group
+        // already exists — swallow it (the cursor is fixed at creation).
+        const startId = this.resolveStartId(config);
         try {
-            await this.client.xgroup("CREATE", stream, group, "$", "MKSTREAM");
+            await this.client.xgroup("CREATE", stream, group, startId, "MKSTREAM");
         }
         catch (err) {
             if (!/BUSYGROUP/i.test(err.message))
                 throw err;
         }
-        const runner = { stop: false, loops: 0 };
+        const runner = { stop: false, loops: 0, conns: [] };
         this.runners.set(stream, runner);
         this.stats.set(stream, { completed: 0, failed: 0, active: 0 });
         const stats = this.stats.get(stream);
         const concurrency = Math.max(1, config.concurrency ?? 1);
         for (let i = 0; i < concurrency; i += 1) {
-            void this.runConsumerLoop(stream, group, config, handler, runner, stats);
+            // Each blocking XREADGROUP loop needs its OWN connection — ioredis
+            // serializes commands on a single socket, so N loops sharing one
+            // client would take turns on the BLOCK, giving zero real parallelism.
+            const conn = this.client.duplicate();
+            runner.conns.push(conn);
+            void this.runConsumerLoop(conn, stream, group, config, handler, runner, stats);
+        }
+        // Redrive: reclaim entries left pending by a crashed consumer or a
+        // requeue `fail(err, true)`. Gated on `config.timeout` (the idle
+        // threshold) and off under NOACK (nothing lands in the PEL).
+        const noAck = config.ack === false;
+        if (config.timeout && config.timeout > 0 && !noAck) {
+            const minIdle = config.timeout;
+            runner.redrive = setInterval(() => {
+                void this.redriveOnce(stream, group, config, handler, runner, stats, minIdle);
+            }, minIdle);
         }
     }
-    async runConsumerLoop(stream, group, config, handler, runner, stats) {
-        if (!this.client)
-            return;
+    async runConsumerLoop(conn, stream, group, config, handler, runner, stats) {
+        // ack:false → at-most-once. NOACK tells Redis to deliver WITHOUT
+        // adding the entry to the group's pending-entries list, so a handler
+        // throw never leaves a leaked pending entry to redrive. NOACK sits
+        // after the consumer name, before STREAMS.
+        const noAck = config.ack === false;
         runner.loops += 1;
         try {
             while (!runner.stop) {
                 let entries = null;
                 try {
-                    entries = await this.client.xreadgroup("GROUP", group, this.consumerName, "COUNT", String(this.config.count), "BLOCK", String(this.config.blockMs), "STREAMS", stream, ">");
+                    const readArgs = [
+                        "GROUP",
+                        group,
+                        this.consumerName,
+                        "COUNT",
+                        String(this.config.count),
+                        "BLOCK",
+                        String(this.config.blockMs),
+                    ];
+                    if (noAck)
+                        readArgs.push("NOACK");
+                    readArgs.push("STREAMS", stream, ">");
+                    // Blocking read on this loop's OWN connection so `concurrency`
+                    // loops don't serialize on a single shared socket.
+                    entries = await conn.xreadgroup(...readArgs);
                 }
-                catch (err) {
+                catch {
                     await new Promise((r) => setTimeout(r, 1000));
                     continue;
                 }
@@ -133,48 +202,7 @@ export class RedisStreamsAdapter {
                     for (const [id, fields] of msgs) {
                         if (runner.stop)
                             break;
-                        stats.active += 1;
-                        try {
-                            const payload = this.fieldsToObject(fields);
-                            const dataString = typeof payload.data === "string" ? payload.data : "";
-                            let data;
-                            try {
-                                data = dataString.length > 0 ? JSON.parse(dataString) : null;
-                            }
-                            catch {
-                                data = dataString;
-                            }
-                            const job = {
-                                id,
-                                data,
-                                headers: {},
-                                queue: stream,
-                                priority: config.priority ?? 0,
-                                attempts: 0,
-                                maxRetries: config.retries ?? 0,
-                                createdAt: new Date(Number.parseInt(id.split("-")[0] ?? String(Date.now()), 10)),
-                                timeout: config.timeout,
-                                raw: { id, fields },
-                                complete: async () => {
-                                    await this.client?.xack(stream, group, id);
-                                    stats.completed += 1;
-                                },
-                                fail: async (_err) => {
-                                    stats.failed += 1;
-                                },
-                            };
-                            await handler(job);
-                            if (config.ack !== false)
-                                await this.client?.xack(stream, group, id);
-                            stats.completed += 1;
-                        }
-                        catch {
-                            stats.failed += 1;
-                            // Pending entry left unacked — picked up by XAUTOCLAIM.
-                        }
-                        finally {
-                            stats.active = Math.max(0, stats.active - 1);
-                        }
+                        await this.processMessage(id, fields, stream, group, config, handler, stats, noAck);
                     }
                 }
             }
@@ -183,6 +211,165 @@ export class RedisStreamsAdapter {
             runner.loops -= 1;
         }
     }
+    /**
+     * Run one delivered/reclaimed entry through the handler, building the
+     * `WorkerJob` with the ACK-once guard. Shared by the main consumer loop
+     * and the redrive loop so both paths ACK / DLQ / count identically.
+     *
+     * `attempts` seeds `job.attempts` (0 on first delivery, the redrive
+     * delivery-count on reclaim) so `WorkerTrigger.handleJob` routes to the DLQ
+     * once retries are exhausted instead of requeueing forever.
+     */
+    async processMessage(id, fields, stream, group, config, handler, stats, noAck, attempts = 0) {
+        stats.active += 1;
+        try {
+            const payload = this.fieldsToObject(fields);
+            const dataString = typeof payload.data === "string" ? payload.data : "";
+            let data;
+            try {
+                data = dataString.length > 0 ? JSON.parse(dataString) : null;
+            }
+            catch {
+                data = dataString;
+            }
+            // ACK exactly once. complete() and fail() both route through this
+            // guard so a handler that calls job.complete() AND returns (or fails
+            // after completing) never double-ACKs or double-counts. Under NOACK
+            // there's nothing in the PEL to ACK, but the guard still keeps the
+            // counters honest.
+            let acked = false;
+            const ackOnce = async () => {
+                if (acked)
+                    return;
+                acked = true;
+                if (!noAck)
+                    await this.client?.xack(stream, group, id);
+            };
+            const dlq = async () => {
+                if (config.deadLetterQueue) {
+                    const raw = this.fieldsToObject(fields);
+                    await this.client?.xadd(config.deadLetterQueue, "*", "data", raw.data ?? "", "jobId", raw.jobId ?? id);
+                }
+                await ackOnce();
+            };
+            const job = {
+                id,
+                data,
+                headers: {},
+                queue: stream,
+                priority: config.priority ?? 0,
+                attempts,
+                maxRetries: config.retries ?? 0,
+                createdAt: new Date(Number.parseInt(id.split("-")[0] ?? String(Date.now()), 10)),
+                timeout: config.timeout,
+                raw: { id, fields },
+                complete: async () => {
+                    if (acked)
+                        return;
+                    await ackOnce();
+                    stats.completed += 1;
+                },
+                fail: async (_err, requeue) => {
+                    if (acked)
+                        return;
+                    stats.failed += 1;
+                    if (requeue) {
+                        // Leave the entry pending (in the PEL) — the redrive loop
+                        // reclaims it once it's idle > timeout. No-op under NOACK.
+                        return;
+                    }
+                    // Terminal failure: dead-letter then ACK the source. No-op DLQ
+                    // when unset.
+                    await dlq();
+                },
+            };
+            await handler(job);
+            // handler (WorkerTrigger.handleJob) owns ACK via complete()/fail().
+        }
+        catch {
+            stats.failed += 1;
+            // Handler threw without settling — leave the entry pending; the
+            // redrive loop reclaims and retries it.
+        }
+        finally {
+            stats.active = Math.max(0, stats.active - 1);
+        }
+    }
+    /**
+     * One redrive pass: XAUTOCLAIM entries idle longer than `minIdle` (a
+     * crashed consumer or a requeue `fail`) back to this consumer, then re-run
+     * each. Redis bumps each entry's delivery count on every claim; once it
+     * exceeds `retries + 1` the entry is dead-lettered and ACKed rather than
+     * reclaimed again forever.
+     */
+    async redriveOnce(stream, group, config, handler, runner, stats, minIdle) {
+        if (runner.stop || !this.client)
+            return;
+        try {
+            // XAUTOCLAIM key group consumer min-idle-time start [COUNT n].
+            const [, claimed] = await this.client.xautoclaim(stream, group, this.consumerName, minIdle, "0", "COUNT", this.config.count);
+            if (!claimed || claimed.length === 0)
+                return;
+            // Delivery counts for exactly the claimed ids. Bracket XPENDING by
+            // the min/max claimed id (XAUTOCLAIM returns them id-ascending) so
+            // the window can't miss any (XPENDING extended row:
+            // [id, consumer, idleMs, deliveryCount]).
+            const minId = claimed[0][0];
+            const maxId = claimed[claimed.length - 1][0];
+            const pending = (await this.client.xpending(stream, group, minId, maxId, claimed.length));
+            const deliveries = new Map();
+            for (const p of pending)
+                deliveries.set(p[0], Number(p[3] ?? 1));
+            const maxDeliveries = (config.retries ?? 0) + 1;
+            for (const [id, fields] of claimed) {
+                if (runner.stop)
+                    break;
+                const count = deliveries.get(id) ?? 1;
+                if (count > maxDeliveries) {
+                    // Exhausted: dead-letter (when configured) then ACK so it stops
+                    // being reclaimed. Mirrors processMessage's terminal path.
+                    if (config.deadLetterQueue) {
+                        const raw = this.fieldsToObject(fields);
+                        await this.client.xadd(config.deadLetterQueue, "*", "data", raw.data ?? "", "jobId", raw.jobId ?? id);
+                    }
+                    await this.client.xack(stream, group, id);
+                    stats.failed += 1;
+                    continue;
+                }
+                // attempts = deliveries so far minus this one, so handleJob's
+                // `attempts < maxRetries` budget is honored across redrives.
+                await this.processMessage(id, fields, stream, group, config, handler, stats, false, Math.max(0, count - 1));
+            }
+        }
+        catch {
+            // A transient claim failure (e.g. NOGROUP mid-teardown) — next tick retries.
+        }
+    }
+    /**
+     * Map the trigger's start position to the id passed to XGROUP CREATE.
+     *   - `"latest"` (default) → `$`  : only entries added after creation.
+     *   - `"earliest"` / `fromBeginning:true` → `0` : the whole retained stream.
+     *   - `{ seq }` / `{ timestamp }` → that explicit cursor id.
+     * `startFrom` rides on the PubSub schema, not WorkerTriggerOpts, so it's
+     * read defensively off `config` for callers that thread it through.
+     */
+    resolveStartId(config) {
+        if (config.fromBeginning)
+            return "0";
+        const startFrom = config.startFrom;
+        if (startFrom === "earliest")
+            return "0";
+        if (startFrom === "latest" || startFrom === undefined)
+            return "$";
+        if (typeof startFrom === "object" && startFrom !== null) {
+            const s = startFrom;
+            if (typeof s.seq === "number")
+                return `${s.seq}-0`;
+            if (typeof s.timestamp === "number")
+                return `${s.timestamp}-0`;
+        }
+        return "$";
+    }
     fieldsToObject(fields) {
         const out = {};
         for (let i = 0; i < fields.length; i += 2) {
@@ -193,17 +380,35 @@ export class RedisStreamsAdapter {
     async addJob(queue, data, opts) {
         if (!this.connected || !this.client)
             throw new Error("[blok][redis] not connected. Call connect() first.");
+        // Redis Streams has NO native delayed delivery or priority. Reject at
+        // enqueue rather than silently dropping the option — surfacing the
+        // misconfiguration is the lazy-correct choice (a scheduler trigger owns
+        // delayed work; XADD is strictly FIFO by id).
+        if (opts?.delay) {
+            throw new Error("[blok][redis] Redis Streams has no native delayed delivery — drop `delay` or use a scheduler trigger.");
+        }
+        if (opts?.priority) {
+            throw new Error("[blok][redis] Redis Streams has no native priority — drop `priority`; entries are FIFO by id.");
+        }
         const payload = typeof data === "string" ? data : JSON.stringify(data);
-        const args = [];
+        // XADD key [NOMKSTREAM] <* | id> field value … — NOMKSTREAM (when a
+        // jobId is supplied, meaning the caller expects the stream to already
+        // exist) MUST precede the `*` id, and the assembled args must actually
+        // be passed to xadd (the prior build threw them away).
+        const args = [queue];
         if (opts?.jobId)
             args.push("NOMKSTREAM");
-        const id = await this.client.xadd(queue, "*", "data", payload, "jobId", opts?.jobId ?? "");
+        args.push("*", "data", payload, "jobId", opts?.jobId ?? "");
+        const id = await this.client.xadd(...args);
         return id;
     }
     async stopProcessing(queue) {
         const runner = this.runners.get(queue);
-        if (runner)
+        if (runner) {
             runner.stop = true;
+            if (runner.redrive)
+                clearInterval(runner.redrive);
+        }
     }
     isConnected() {
         return this.connected;
@@ -237,4 +442,4 @@ export class RedisStreamsAdapter {
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RedisStreamsAdapter.js","sourceRoot":"","sources":["../../src/adapters/RedisStreamsAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * RedisStreamsAdapter — v0.7 PR 5 — Worker adapter backed by Redis\n * Streams via `ioredis`. Consumes from a stream (the `queue` field)\n * with a consumer group (`consumerGroup`); produces via `XADD`.\n *\n * Semantics:\n *   - **Consumer groups**: required. `consumerGroup` defaults to\n *     `\"${queue}-group\"`. The group is auto-created (`MKSTREAM` on the\n *     stream too) on first `process()` call.\n *   - **Consumer name**: per-process uuid, so multiple instances of\n *     the same worker process don't share pending entries.\n *   - **Retries**: pending entries are XACK'd on success / left\n *     unacked on failure (visible in `XPENDING`). A redrive loop\n *     reads pending entries older than `timeout` and re-delivers\n *     to the current consumer.\n *   - **Auto-claim**: skipped in v1 — operators should run XAUTOCLAIM\n *     periodically out of band.\n *\n * Requires `ioredis` as a peer dependency:\n *\n *     bun add ioredis\n *\n * Environment variables:\n *   - `REDIS_HOST` (default `localhost`)\n *   - `REDIS_PORT` (default `6379`)\n *   - `REDIS_PASSWORD`\n *   - `REDIS_DB`\n */\n\nimport type { WorkerTriggerOpts } from \"@blokjs/helper\";\nimport { v4 as uuid } from \"uuid\";\nimport type { WorkerAdapter, WorkerJob, WorkerQueueStats } from \"../WorkerTrigger\";\n\nexport interface RedisStreamsConfig {\n\thost: string;\n\tport: number;\n\tpassword?: string;\n\tdb?: number;\n\tblockMs: number;\n\tcount: number;\n}\n\ninterface RedisClient {\n\txadd(stream: string, ...args: string[]): Promise<string>;\n\txreadgroup(...args: string[]): Promise<Array<[string, Array<[string, string[]]>]> | null>;\n\txgroup(...args: string[]): Promise<string>;\n\txack(stream: string, group: string, ...ids: string[]): Promise<number>;\n\txlen(stream: string): Promise<number>;\n\txpending(stream: string, group: string): Promise<unknown>;\n\tping(): Promise<string>;\n\tquit(): Promise<string>;\n}\n\ninterface QueueRunner {\n\tstop: boolean;\n\tloops: number;\n}\n\ninterface QueueStatsCounters {\n\tcompleted: number;\n\tfailed: number;\n\tactive: number;\n}\n\nexport class RedisStreamsAdapter implements WorkerAdapter {\n\treadonly provider = \"redis\" as const;\n\tprivate readonly config: RedisStreamsConfig;\n\tprivate client: RedisClient | null = null;\n\tprivate runners: Map<string, QueueRunner> = new Map();\n\tprivate connected = false;\n\tprivate stats: Map<string, QueueStatsCounters> = new Map();\n\tprivate consumerName = `blok-${uuid().slice(0, 8)}`;\n\n\tconstructor(config?: Partial<RedisStreamsConfig>) {\n\t\tthis.config = {\n\t\t\thost: config?.host ?? process.env.REDIS_HOST ?? \"localhost\",\n\t\t\tport: config?.port ?? Number.parseInt(process.env.REDIS_PORT ?? \"6379\", 10),\n\t\t\tpassword: config?.password ?? process.env.REDIS_PASSWORD,\n\t\t\tdb: config?.db ?? Number.parseInt(process.env.REDIS_DB ?? \"0\", 10),\n\t\t\tblockMs: config?.blockMs ?? 5000,\n\t\t\tcount: config?.count ?? 10,\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: ioredis is a runtime peer dep.\n\t\t\tconst ioredis: any = await import(\"ioredis\");\n\t\t\tconst IORedis = ioredis.default ?? ioredis.Redis ?? ioredis;\n\t\t\tthis.client = new IORedis({\n\t\t\t\thost: this.config.host,\n\t\t\t\tport: this.config.port,\n\t\t\t\tpassword: this.config.password,\n\t\t\t\tdb: this.config.db,\n\t\t\t}) as RedisClient;\n\t\t\tawait this.client.ping();\n\t\t\tthis.connected = true;\n\t\t} catch (err) {\n\t\t\tthrow new Error(\n\t\t\t\t`[blok][redis] connect failed: ${(err as Error).message}. Install ioredis as a peer dependency: bun add ioredis`,\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 runner of this.runners.values()) runner.stop = true;\n\t\t// Wait for in-flight loops to drain.\n\t\tconst drainDeadline = Date.now() + 2000;\n\t\twhile (Date.now() < drainDeadline) {\n\t\t\tlet active = 0;\n\t\t\tfor (const r of this.runners.values()) active += r.loops;\n\t\t\tif (active === 0) break;\n\t\t\tawait new Promise((r) => setTimeout(r, 50));\n\t\t}\n\t\tthis.runners.clear();\n\t\ttry {\n\t\t\tawait this.client?.quit();\n\t\t} catch {\n\t\t\t/* ignore */\n\t\t}\n\t\tthis.client = null;\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 || !this.client) throw new Error(\"[blok][redis] not connected. Call connect() first.\");\n\t\tconst stream = config.queue;\n\t\tconst group = config.consumerGroup ?? `${stream}-group`;\n\t\t// Create group + stream if missing. XGROUP CREATE with MKSTREAM\n\t\t// errors with \"BUSYGROUP\" if the group already exists — swallow it.\n\t\ttry {\n\t\t\tawait this.client.xgroup(\"CREATE\", stream, group, \"$\", \"MKSTREAM\");\n\t\t} catch (err) {\n\t\t\tif (!/BUSYGROUP/i.test((err as Error).message)) throw err;\n\t\t}\n\n\t\tconst runner: QueueRunner = { stop: false, loops: 0 };\n\t\tthis.runners.set(stream, runner);\n\t\tthis.stats.set(stream, { completed: 0, failed: 0, active: 0 });\n\t\tconst stats = this.stats.get(stream) as QueueStatsCounters;\n\n\t\tconst concurrency = Math.max(1, config.concurrency ?? 1);\n\t\tfor (let i = 0; i < concurrency; i += 1) {\n\t\t\tvoid this.runConsumerLoop(stream, group, config, handler, runner, stats);\n\t\t}\n\t}\n\n\tprivate async runConsumerLoop(\n\t\tstream: string,\n\t\tgroup: string,\n\t\tconfig: WorkerTriggerOpts,\n\t\thandler: (job: WorkerJob) => Promise<void>,\n\t\trunner: QueueRunner,\n\t\tstats: QueueStatsCounters,\n\t): Promise<void> {\n\t\tif (!this.client) return;\n\t\trunner.loops += 1;\n\t\ttry {\n\t\t\twhile (!runner.stop) {\n\t\t\t\tlet entries: Array<[string, Array<[string, string[]]>]> | null = null;\n\t\t\t\ttry {\n\t\t\t\t\tentries = await this.client.xreadgroup(\n\t\t\t\t\t\t\"GROUP\",\n\t\t\t\t\t\tgroup,\n\t\t\t\t\t\tthis.consumerName,\n\t\t\t\t\t\t\"COUNT\",\n\t\t\t\t\t\tString(this.config.count),\n\t\t\t\t\t\t\"BLOCK\",\n\t\t\t\t\t\tString(this.config.blockMs),\n\t\t\t\t\t\t\"STREAMS\",\n\t\t\t\t\t\tstream,\n\t\t\t\t\t\t\">\",\n\t\t\t\t\t);\n\t\t\t\t} catch (err) {\n\t\t\t\t\tawait new Promise((r) => setTimeout(r, 1000));\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tif (!entries) continue;\n\t\t\t\tfor (const [, msgs] of entries) {\n\t\t\t\t\tfor (const [id, fields] of msgs) {\n\t\t\t\t\t\tif (runner.stop) break;\n\t\t\t\t\t\tstats.active += 1;\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tconst payload = this.fieldsToObject(fields);\n\t\t\t\t\t\t\tconst dataString = typeof payload.data === \"string\" ? payload.data : \"\";\n\t\t\t\t\t\t\tlet data: unknown;\n\t\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\t\tdata = dataString.length > 0 ? JSON.parse(dataString) : null;\n\t\t\t\t\t\t\t} catch {\n\t\t\t\t\t\t\t\tdata = dataString;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tconst job: WorkerJob = {\n\t\t\t\t\t\t\t\tid,\n\t\t\t\t\t\t\t\tdata,\n\t\t\t\t\t\t\t\theaders: {},\n\t\t\t\t\t\t\t\tqueue: stream,\n\t\t\t\t\t\t\t\tpriority: config.priority ?? 0,\n\t\t\t\t\t\t\t\tattempts: 0,\n\t\t\t\t\t\t\t\tmaxRetries: config.retries ?? 0,\n\t\t\t\t\t\t\t\tcreatedAt: new Date(Number.parseInt(id.split(\"-\")[0] ?? String(Date.now()), 10)),\n\t\t\t\t\t\t\t\ttimeout: config.timeout,\n\t\t\t\t\t\t\t\traw: { id, fields },\n\t\t\t\t\t\t\t\tcomplete: async () => {\n\t\t\t\t\t\t\t\t\tawait this.client?.xack(stream, group, id);\n\t\t\t\t\t\t\t\t\tstats.completed += 1;\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\tfail: async (_err: Error) => {\n\t\t\t\t\t\t\t\t\tstats.failed += 1;\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\tawait handler(job);\n\t\t\t\t\t\t\tif (config.ack !== false) await this.client?.xack(stream, group, id);\n\t\t\t\t\t\t\tstats.completed += 1;\n\t\t\t\t\t\t} catch {\n\t\t\t\t\t\t\tstats.failed += 1;\n\t\t\t\t\t\t\t// Pending entry left unacked — picked up by XAUTOCLAIM.\n\t\t\t\t\t\t} finally {\n\t\t\t\t\t\t\tstats.active = Math.max(0, stats.active - 1);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t} finally {\n\t\t\trunner.loops -= 1;\n\t\t}\n\t}\n\n\tprivate fieldsToObject(fields: string[]): Record<string, string> {\n\t\tconst out: Record<string, string> = {};\n\t\tfor (let i = 0; i < fields.length; i += 2) {\n\t\t\tout[fields[i]] = fields[i + 1];\n\t\t}\n\t\treturn out;\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 || !this.client) throw new Error(\"[blok][redis] not connected. Call connect() first.\");\n\t\tconst payload = typeof data === \"string\" ? data : JSON.stringify(data);\n\t\tconst args: string[] = [];\n\t\tif (opts?.jobId) args.push(\"NOMKSTREAM\");\n\t\tconst id = await this.client.xadd(queue, \"*\", \"data\", payload, \"jobId\", opts?.jobId ?? \"\");\n\t\treturn id;\n\t}\n\n\tasync stopProcessing(queue: string): Promise<void> {\n\t\tconst runner = this.runners.get(queue);\n\t\tif (runner) runner.stop = true;\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.client) return false;\n\t\ttry {\n\t\t\tconst pong = await this.client.ping();\n\t\t\treturn pong === \"PONG\";\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\ttry {\n\t\t\twaiting = (await this.client?.xlen(queue)) ?? 0;\n\t\t} catch {\n\t\t\t/* ignore */\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":"RedisStreamsAdapter.js","sourceRoot":"","sources":["../../src/adapters/RedisStreamsAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * RedisStreamsAdapter — v0.7 PR 5 — Worker adapter backed by Redis\n * Streams via `ioredis`. Consumes from a stream (the `queue` field)\n * with a consumer group (`consumerGroup`); produces via `XADD`.\n *\n * Semantics:\n *   - **Consumer groups**: required. `consumerGroup` defaults to\n *     `\"${queue}-group\"`. The group is auto-created (`MKSTREAM` on the\n *     stream too) on first `process()` call, at the `startFrom` cursor\n *     (`\"latest\"` → `$` default, `\"earliest\"` → `0`, or `fromBeginning`).\n *   - **Consumer name**: per-process uuid, so multiple instances of\n *     the same worker process don't share pending entries.\n *   - **ACK / retries**: ACK happens exactly once via `job.complete()`\n *     (success) — the consumer loop does NOT double-ACK. A terminal\n *     `job.fail(err, false)` XADDs the payload to `deadLetterQueue`\n *     (when configured) then XACKs the source so it isn't redelivered.\n *     A requeue `job.fail(err, true)` leaves the entry pending (visible\n *     in `XPENDING`) for redrive.\n *   - **ack:false**: the consumer reads with NOACK, so Redis never\n *     adds entries to the group's PEL — at-most-once, no leaked pending.\n *   - **Redrive**: an in-process periodic XAUTOCLAIM loop reclaims stale\n *     pending entries (idle > `config.timeout`) — left by a crashed\n *     consumer or a requeue `fail(err, true)` — and re-runs them through\n *     the handler. Redis bumps each entry's delivery count on every\n *     claim; once it exceeds `retries + 1` the entry is dead-lettered\n *     (when `deadLetterQueue` is set) and XACKed. The redrive loop only\n *     runs when `config.timeout` is set (it IS the idle threshold — with\n *     no timeout a slow-but-alive handler is indistinguishable from a\n *     dead one) and NOT under `ack:false` (nothing lands in the PEL).\n *   - **No native delay / priority**: Redis Streams has neither. `addJob`\n *     THROWS on `opts.delay` / `opts.priority` rather than silently\n *     dropping them — use a scheduler trigger for delayed work.\n *   - **Concurrency**: each of the `concurrency` consumer loops owns a\n *     DEDICATED ioredis connection (`client.duplicate()`) so their\n *     blocking XREADGROUP calls run in parallel instead of serializing on\n *     one shared socket — ioredis requires a separate client per blocking\n *     command. The shared `this.client` handles non-blocking ops\n *     (XADD / XACK / XGROUP / XAUTOCLAIM).\n *\n * Requires `ioredis` as a peer dependency:\n *\n *     bun add ioredis\n *\n * Environment variables:\n *   - `REDIS_HOST` (default `localhost`)\n *   - `REDIS_PORT` (default `6379`)\n *   - `REDIS_PASSWORD`\n *   - `REDIS_DB`\n */\n\nimport type { WorkerTriggerOpts } from \"@blokjs/helper\";\nimport { v4 as uuid } from \"uuid\";\nimport type { WorkerAdapter, WorkerJob, WorkerQueueStats } from \"../WorkerTrigger\";\n\nexport interface RedisStreamsConfig {\n\thost: string;\n\tport: number;\n\tpassword?: string;\n\tdb?: number;\n\tblockMs: number;\n\tcount: number;\n}\n\n/** One reclaimed/pending entry as `[id, fields, deliveryCount]`. */\ntype StreamMessage = [string, string[]];\n\ninterface RedisClient {\n\txadd(stream: string, ...args: string[]): Promise<string>;\n\txreadgroup(...args: string[]): Promise<Array<[string, Array<StreamMessage>]> | null>;\n\txgroup(...args: string[]): Promise<string>;\n\txack(stream: string, group: string, ...ids: string[]): Promise<number>;\n\txlen(stream: string): Promise<number>;\n\txpending(stream: string, group: string, ...args: (string | number)[]): Promise<unknown>;\n\t// XAUTOCLAIM key group consumer min-idle-time start [COUNT n] →\n\t// [cursor, entries[[id, fields]], deletedIds[]].\n\txautoclaim(...args: (string | number)[]): Promise<[string, Array<StreamMessage>, string[]]>;\n\tping(): Promise<string>;\n\tquit(): Promise<string>;\n\t// Dedicated connection for a blocking consumer loop — ioredis requires a\n\t// separate client per concurrent blocking command.\n\tduplicate(): RedisClient;\n}\n\ninterface QueueRunner {\n\tstop: boolean;\n\tloops: number;\n\t/** Per-loop dedicated connections + the redrive timer, torn down on stop. */\n\tconns: RedisClient[];\n\tredrive?: ReturnType<typeof setInterval>;\n}\n\ninterface QueueStatsCounters {\n\tcompleted: number;\n\tfailed: number;\n\tactive: number;\n}\n\nexport class RedisStreamsAdapter implements WorkerAdapter {\n\treadonly provider = \"redis\" as const;\n\tprivate readonly config: RedisStreamsConfig;\n\tprivate client: RedisClient | null = null;\n\tprivate runners: Map<string, QueueRunner> = new Map();\n\tprivate connected = false;\n\tprivate stats: Map<string, QueueStatsCounters> = new Map();\n\tprivate consumerName = `blok-${uuid().slice(0, 8)}`;\n\n\tconstructor(config?: Partial<RedisStreamsConfig>) {\n\t\tthis.config = {\n\t\t\thost: config?.host ?? process.env.REDIS_HOST ?? \"localhost\",\n\t\t\tport: config?.port ?? Number.parseInt(process.env.REDIS_PORT ?? \"6379\", 10),\n\t\t\tpassword: config?.password ?? process.env.REDIS_PASSWORD,\n\t\t\tdb: config?.db ?? Number.parseInt(process.env.REDIS_DB ?? \"0\", 10),\n\t\t\tblockMs: config?.blockMs ?? 5000,\n\t\t\tcount: config?.count ?? 10,\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: ioredis is a runtime peer dep.\n\t\t\tconst ioredis: any = await import(\"ioredis\");\n\t\t\tconst IORedis = ioredis.default ?? ioredis.Redis ?? ioredis;\n\t\t\tthis.client = new IORedis({\n\t\t\t\thost: this.config.host,\n\t\t\t\tport: this.config.port,\n\t\t\t\tpassword: this.config.password,\n\t\t\t\tdb: this.config.db,\n\t\t\t}) as RedisClient;\n\t\t\tawait this.client.ping();\n\t\t\tthis.connected = true;\n\t\t} catch (err) {\n\t\t\tthrow new Error(\n\t\t\t\t`[blok][redis] connect failed: ${(err as Error).message}. Install ioredis as a peer dependency: bun add ioredis`,\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 runner of this.runners.values()) {\n\t\t\trunner.stop = true;\n\t\t\tif (runner.redrive) clearInterval(runner.redrive);\n\t\t}\n\t\t// Wait for in-flight loops to drain.\n\t\tconst drainDeadline = Date.now() + 2000;\n\t\twhile (Date.now() < drainDeadline) {\n\t\t\tlet active = 0;\n\t\t\tfor (const r of this.runners.values()) active += r.loops;\n\t\t\tif (active === 0) break;\n\t\t\tawait new Promise((r) => setTimeout(r, 50));\n\t\t}\n\t\t// Close each loop's dedicated blocking connection.\n\t\tfor (const runner of this.runners.values()) {\n\t\t\tfor (const conn of runner.conns) {\n\t\t\t\ttry {\n\t\t\t\t\tawait conn.quit();\n\t\t\t\t} catch {\n\t\t\t\t\t/* ignore */\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis.runners.clear();\n\t\ttry {\n\t\t\tawait this.client?.quit();\n\t\t} catch {\n\t\t\t/* ignore */\n\t\t}\n\t\tthis.client = null;\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 || !this.client) throw new Error(\"[blok][redis] not connected. Call connect() first.\");\n\t\tconst stream = config.queue;\n\t\tconst group = config.consumerGroup ?? `${stream}-group`;\n\t\t// Create group + stream if missing, at the requested start cursor.\n\t\t// XGROUP CREATE with MKSTREAM errors with \"BUSYGROUP\" if the group\n\t\t// already exists — swallow it (the cursor is fixed at creation).\n\t\tconst startId = this.resolveStartId(config);\n\t\ttry {\n\t\t\tawait this.client.xgroup(\"CREATE\", stream, group, startId, \"MKSTREAM\");\n\t\t} catch (err) {\n\t\t\tif (!/BUSYGROUP/i.test((err as Error).message)) throw err;\n\t\t}\n\n\t\tconst runner: QueueRunner = { stop: false, loops: 0, conns: [] };\n\t\tthis.runners.set(stream, runner);\n\t\tthis.stats.set(stream, { completed: 0, failed: 0, active: 0 });\n\t\tconst stats = this.stats.get(stream) as QueueStatsCounters;\n\n\t\tconst concurrency = Math.max(1, config.concurrency ?? 1);\n\t\tfor (let i = 0; i < concurrency; i += 1) {\n\t\t\t// Each blocking XREADGROUP loop needs its OWN connection — ioredis\n\t\t\t// serializes commands on a single socket, so N loops sharing one\n\t\t\t// client would take turns on the BLOCK, giving zero real parallelism.\n\t\t\tconst conn = this.client.duplicate();\n\t\t\trunner.conns.push(conn);\n\t\t\tvoid this.runConsumerLoop(conn, stream, group, config, handler, runner, stats);\n\t\t}\n\n\t\t// Redrive: reclaim entries left pending by a crashed consumer or a\n\t\t// requeue `fail(err, true)`. Gated on `config.timeout` (the idle\n\t\t// threshold) and off under NOACK (nothing lands in the PEL).\n\t\tconst noAck = config.ack === false;\n\t\tif (config.timeout && config.timeout > 0 && !noAck) {\n\t\t\tconst minIdle = config.timeout;\n\t\t\trunner.redrive = setInterval(() => {\n\t\t\t\tvoid this.redriveOnce(stream, group, config, handler, runner, stats, minIdle);\n\t\t\t}, minIdle);\n\t\t}\n\t}\n\n\tprivate async runConsumerLoop(\n\t\tconn: RedisClient,\n\t\tstream: string,\n\t\tgroup: string,\n\t\tconfig: WorkerTriggerOpts,\n\t\thandler: (job: WorkerJob) => Promise<void>,\n\t\trunner: QueueRunner,\n\t\tstats: QueueStatsCounters,\n\t): Promise<void> {\n\t\t// ack:false → at-most-once. NOACK tells Redis to deliver WITHOUT\n\t\t// adding the entry to the group's pending-entries list, so a handler\n\t\t// throw never leaves a leaked pending entry to redrive. NOACK sits\n\t\t// after the consumer name, before STREAMS.\n\t\tconst noAck = config.ack === false;\n\t\trunner.loops += 1;\n\t\ttry {\n\t\t\twhile (!runner.stop) {\n\t\t\t\tlet entries: Array<[string, Array<StreamMessage>]> | null = null;\n\t\t\t\ttry {\n\t\t\t\t\tconst readArgs = [\n\t\t\t\t\t\t\"GROUP\",\n\t\t\t\t\t\tgroup,\n\t\t\t\t\t\tthis.consumerName,\n\t\t\t\t\t\t\"COUNT\",\n\t\t\t\t\t\tString(this.config.count),\n\t\t\t\t\t\t\"BLOCK\",\n\t\t\t\t\t\tString(this.config.blockMs),\n\t\t\t\t\t];\n\t\t\t\t\tif (noAck) readArgs.push(\"NOACK\");\n\t\t\t\t\treadArgs.push(\"STREAMS\", stream, \">\");\n\t\t\t\t\t// Blocking read on this loop's OWN connection so `concurrency`\n\t\t\t\t\t// loops don't serialize on a single shared socket.\n\t\t\t\t\tentries = await conn.xreadgroup(...readArgs);\n\t\t\t\t} catch {\n\t\t\t\t\tawait new Promise((r) => setTimeout(r, 1000));\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tif (!entries) continue;\n\t\t\t\tfor (const [, msgs] of entries) {\n\t\t\t\t\tfor (const [id, fields] of msgs) {\n\t\t\t\t\t\tif (runner.stop) break;\n\t\t\t\t\t\tawait this.processMessage(id, fields, stream, group, config, handler, stats, noAck);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t} finally {\n\t\t\trunner.loops -= 1;\n\t\t}\n\t}\n\n\t/**\n\t * Run one delivered/reclaimed entry through the handler, building the\n\t * `WorkerJob` with the ACK-once guard. Shared by the main consumer loop\n\t * and the redrive loop so both paths ACK / DLQ / count identically.\n\t *\n\t * `attempts` seeds `job.attempts` (0 on first delivery, the redrive\n\t * delivery-count on reclaim) so `WorkerTrigger.handleJob` routes to the DLQ\n\t * once retries are exhausted instead of requeueing forever.\n\t */\n\tprivate async processMessage(\n\t\tid: string,\n\t\tfields: string[],\n\t\tstream: string,\n\t\tgroup: string,\n\t\tconfig: WorkerTriggerOpts,\n\t\thandler: (job: WorkerJob) => Promise<void>,\n\t\tstats: QueueStatsCounters,\n\t\tnoAck: boolean,\n\t\tattempts = 0,\n\t): Promise<void> {\n\t\tstats.active += 1;\n\t\ttry {\n\t\t\tconst payload = this.fieldsToObject(fields);\n\t\t\tconst dataString = typeof payload.data === \"string\" ? payload.data : \"\";\n\t\t\tlet data: unknown;\n\t\t\ttry {\n\t\t\t\tdata = dataString.length > 0 ? JSON.parse(dataString) : null;\n\t\t\t} catch {\n\t\t\t\tdata = dataString;\n\t\t\t}\n\t\t\t// ACK exactly once. complete() and fail() both route through this\n\t\t\t// guard so a handler that calls job.complete() AND returns (or fails\n\t\t\t// after completing) never double-ACKs or double-counts. Under NOACK\n\t\t\t// there's nothing in the PEL to ACK, but the guard still keeps the\n\t\t\t// counters honest.\n\t\t\tlet acked = false;\n\t\t\tconst ackOnce = async (): Promise<void> => {\n\t\t\t\tif (acked) return;\n\t\t\t\tacked = true;\n\t\t\t\tif (!noAck) await this.client?.xack(stream, group, id);\n\t\t\t};\n\t\t\tconst dlq = async (): Promise<void> => {\n\t\t\t\tif (config.deadLetterQueue) {\n\t\t\t\t\tconst raw = this.fieldsToObject(fields);\n\t\t\t\t\tawait this.client?.xadd(config.deadLetterQueue, \"*\", \"data\", raw.data ?? \"\", \"jobId\", raw.jobId ?? id);\n\t\t\t\t}\n\t\t\t\tawait ackOnce();\n\t\t\t};\n\t\t\tconst job: WorkerJob = {\n\t\t\t\tid,\n\t\t\t\tdata,\n\t\t\t\theaders: {},\n\t\t\t\tqueue: stream,\n\t\t\t\tpriority: config.priority ?? 0,\n\t\t\t\tattempts,\n\t\t\t\tmaxRetries: config.retries ?? 0,\n\t\t\t\tcreatedAt: new Date(Number.parseInt(id.split(\"-\")[0] ?? String(Date.now()), 10)),\n\t\t\t\ttimeout: config.timeout,\n\t\t\t\traw: { id, fields },\n\t\t\t\tcomplete: async () => {\n\t\t\t\t\tif (acked) return;\n\t\t\t\t\tawait ackOnce();\n\t\t\t\t\tstats.completed += 1;\n\t\t\t\t},\n\t\t\t\tfail: async (_err: Error, requeue?: boolean) => {\n\t\t\t\t\tif (acked) return;\n\t\t\t\t\tstats.failed += 1;\n\t\t\t\t\tif (requeue) {\n\t\t\t\t\t\t// Leave the entry pending (in the PEL) — the redrive loop\n\t\t\t\t\t\t// reclaims it once it's idle > timeout. No-op under NOACK.\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\t// Terminal failure: dead-letter then ACK the source. No-op DLQ\n\t\t\t\t\t// when unset.\n\t\t\t\t\tawait dlq();\n\t\t\t\t},\n\t\t\t};\n\t\t\tawait handler(job);\n\t\t\t// handler (WorkerTrigger.handleJob) owns ACK via complete()/fail().\n\t\t} catch {\n\t\t\tstats.failed += 1;\n\t\t\t// Handler threw without settling — leave the entry pending; the\n\t\t\t// redrive loop reclaims and retries it.\n\t\t} finally {\n\t\t\tstats.active = Math.max(0, stats.active - 1);\n\t\t}\n\t}\n\n\t/**\n\t * One redrive pass: XAUTOCLAIM entries idle longer than `minIdle` (a\n\t * crashed consumer or a requeue `fail`) back to this consumer, then re-run\n\t * each. Redis bumps each entry's delivery count on every claim; once it\n\t * exceeds `retries + 1` the entry is dead-lettered and ACKed rather than\n\t * reclaimed again forever.\n\t */\n\tprivate async redriveOnce(\n\t\tstream: string,\n\t\tgroup: string,\n\t\tconfig: WorkerTriggerOpts,\n\t\thandler: (job: WorkerJob) => Promise<void>,\n\t\trunner: QueueRunner,\n\t\tstats: QueueStatsCounters,\n\t\tminIdle: number,\n\t): Promise<void> {\n\t\tif (runner.stop || !this.client) return;\n\t\ttry {\n\t\t\t// XAUTOCLAIM key group consumer min-idle-time start [COUNT n].\n\t\t\tconst [, claimed] = await this.client.xautoclaim(\n\t\t\t\tstream,\n\t\t\t\tgroup,\n\t\t\t\tthis.consumerName,\n\t\t\t\tminIdle,\n\t\t\t\t\"0\",\n\t\t\t\t\"COUNT\",\n\t\t\t\tthis.config.count,\n\t\t\t);\n\t\t\tif (!claimed || claimed.length === 0) return;\n\t\t\t// Delivery counts for exactly the claimed ids. Bracket XPENDING by\n\t\t\t// the min/max claimed id (XAUTOCLAIM returns them id-ascending) so\n\t\t\t// the window can't miss any (XPENDING extended row:\n\t\t\t// [id, consumer, idleMs, deliveryCount]).\n\t\t\tconst minId = claimed[0][0];\n\t\t\tconst maxId = claimed[claimed.length - 1][0];\n\t\t\tconst pending = (await this.client.xpending(stream, group, minId, maxId, claimed.length)) as Array<\n\t\t\t\t[string, string, number, number]\n\t\t\t>;\n\t\t\tconst deliveries = new Map<string, number>();\n\t\t\tfor (const p of pending) deliveries.set(p[0], Number(p[3] ?? 1));\n\t\t\tconst maxDeliveries = (config.retries ?? 0) + 1;\n\t\t\tfor (const [id, fields] of claimed) {\n\t\t\t\tif (runner.stop) break;\n\t\t\t\tconst count = deliveries.get(id) ?? 1;\n\t\t\t\tif (count > maxDeliveries) {\n\t\t\t\t\t// Exhausted: dead-letter (when configured) then ACK so it stops\n\t\t\t\t\t// being reclaimed. Mirrors processMessage's terminal path.\n\t\t\t\t\tif (config.deadLetterQueue) {\n\t\t\t\t\t\tconst raw = this.fieldsToObject(fields);\n\t\t\t\t\t\tawait this.client.xadd(config.deadLetterQueue, \"*\", \"data\", raw.data ?? \"\", \"jobId\", raw.jobId ?? id);\n\t\t\t\t\t}\n\t\t\t\t\tawait this.client.xack(stream, group, id);\n\t\t\t\t\tstats.failed += 1;\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\t// attempts = deliveries so far minus this one, so handleJob's\n\t\t\t\t// `attempts < maxRetries` budget is honored across redrives.\n\t\t\t\tawait this.processMessage(id, fields, stream, group, config, handler, stats, false, Math.max(0, count - 1));\n\t\t\t}\n\t\t} catch {\n\t\t\t// A transient claim failure (e.g. NOGROUP mid-teardown) — next tick retries.\n\t\t}\n\t}\n\n\t/**\n\t * Map the trigger's start position to the id passed to XGROUP CREATE.\n\t *   - `\"latest\"` (default) → `$`  : only entries added after creation.\n\t *   - `\"earliest\"` / `fromBeginning:true` → `0` : the whole retained stream.\n\t *   - `{ seq }` / `{ timestamp }` → that explicit cursor id.\n\t * `startFrom` rides on the PubSub schema, not WorkerTriggerOpts, so it's\n\t * read defensively off `config` for callers that thread it through.\n\t */\n\tprivate resolveStartId(config: WorkerTriggerOpts): string {\n\t\tif (config.fromBeginning) return \"0\";\n\t\tconst startFrom = (config as { startFrom?: unknown }).startFrom;\n\t\tif (startFrom === \"earliest\") return \"0\";\n\t\tif (startFrom === \"latest\" || startFrom === undefined) return \"$\";\n\t\tif (typeof startFrom === \"object\" && startFrom !== null) {\n\t\t\tconst s = startFrom as { seq?: number; timestamp?: number };\n\t\t\tif (typeof s.seq === \"number\") return `${s.seq}-0`;\n\t\t\tif (typeof s.timestamp === \"number\") return `${s.timestamp}-0`;\n\t\t}\n\t\treturn \"$\";\n\t}\n\n\tprivate fieldsToObject(fields: string[]): Record<string, string> {\n\t\tconst out: Record<string, string> = {};\n\t\tfor (let i = 0; i < fields.length; i += 2) {\n\t\t\tout[fields[i]] = fields[i + 1];\n\t\t}\n\t\treturn out;\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 || !this.client) throw new Error(\"[blok][redis] not connected. Call connect() first.\");\n\t\t// Redis Streams has NO native delayed delivery or priority. Reject at\n\t\t// enqueue rather than silently dropping the option — surfacing the\n\t\t// misconfiguration is the lazy-correct choice (a scheduler trigger owns\n\t\t// delayed work; XADD is strictly FIFO by id).\n\t\tif (opts?.delay) {\n\t\t\tthrow new Error(\n\t\t\t\t\"[blok][redis] Redis Streams has no native delayed delivery — drop `delay` or use a scheduler trigger.\",\n\t\t\t);\n\t\t}\n\t\tif (opts?.priority) {\n\t\t\tthrow new Error(\"[blok][redis] Redis Streams has no native priority — drop `priority`; entries are FIFO by id.\");\n\t\t}\n\t\tconst payload = typeof data === \"string\" ? data : JSON.stringify(data);\n\t\t// XADD key [NOMKSTREAM] <* | id> field value … — NOMKSTREAM (when a\n\t\t// jobId is supplied, meaning the caller expects the stream to already\n\t\t// exist) MUST precede the `*` id, and the assembled args must actually\n\t\t// be passed to xadd (the prior build threw them away).\n\t\tconst args: string[] = [queue];\n\t\tif (opts?.jobId) args.push(\"NOMKSTREAM\");\n\t\targs.push(\"*\", \"data\", payload, \"jobId\", opts?.jobId ?? \"\");\n\t\tconst id = await this.client.xadd(...(args as [string, ...string[]]));\n\t\treturn id;\n\t}\n\n\tasync stopProcessing(queue: string): Promise<void> {\n\t\tconst runner = this.runners.get(queue);\n\t\tif (runner) {\n\t\t\trunner.stop = true;\n\t\t\tif (runner.redrive) clearInterval(runner.redrive);\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.client) return false;\n\t\ttry {\n\t\t\tconst pong = await this.client.ping();\n\t\t\treturn pong === \"PONG\";\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\ttry {\n\t\t\twaiting = (await this.client?.xlen(queue)) ?? 0;\n\t\t} catch {\n\t\t\t/* ignore */\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"]}