@pipeline-builder/api-core 4.1.2 → 4.1.4

package/lib/services/durable-event-bus.d.ts

@@ -1,37 +1,16 @@
-/**
- * Durable, at-least-once event backbone (Redis Streams).
- *
- * The platform's cross-service signalling today is point-to-point HTTP plus
- * polling reconcilers plus an IN-PROCESS best-effort emitter ({@link entityEvents}).
- * There is no durable bus, so a signal produced on one pod is either delivered
- * synchronously over HTTP (coupling + retry-storm risk) or lost if the consumer
- * is momentarily down (the reconcilers exist to paper over exactly that).
- *
- * This is that missing bus, as a reusable primitive:
- *  - **publish(topic, payload)** → `XADD` onto a bounded (`MAXLEN ~`) per-topic
- *    stream. Durable across restarts, shared by all replicas.
- *  - **subscribe({topic, group, consumer, handler})** → a `XREADGROUP` consumer.
- *    Consumer GROUPS give at-least-once: each group gets every message once, a
- *    message stays pending until the handler `XACK`s it, and `XAUTOCLAIM`
- *    reclaims messages stranded by a crashed consumer. Multiple groups on one
- *    topic = independent fan-out (e.g. quota-sync AND audit both react).
- *
- * FAIL-SAFE + OPT-IN, exactly like the audit spool: {@link createEnvRedisDurableEventBus}
- * returns `null` when Redis isn't configured, so a service without it simply
- * doesn't use the bus (keeps today's behavior). A publish failure is dropped-with-
- * -metric, never thrown; a handler throw leaves the message un-acked for redelivery.
- *
- * Migrating a specific reconciler (e.g. billing→quota entitlement sync) onto this
- * is deliberately follow-on work — this lands the backbone + an additive entity-
- * event bridge; the reconcilers stay as the belt-and-suspenders backstop until a
- * flow is fully cut over.
- */
-import type { EntityEventSubscriber } from './entity-events.js';
-/** A delivered event: its stream id, topic, and decoded payload. */
+/** A delivered event: its stream id, topic, publish time, and decoded payload. */
 export interface EventEnvelope<T = unknown> {
     /** Redis Stream entry id (`<ms>-<seq>`) — also the idempotency handle. */
     id: string;
     topic: string;
+    /**
+     * When the event was published (the Redis server time embedded in the stream
+     * id). A redelivery keeps its ORIGINAL publish time, so a consumer applying
+     * last-writer-wins state (e.g. an entitlement sync) can order events by it
+     * instead of by delivery time and refuse to let a stale retry overwrite a
+     * newer state.
+     */
+    publishedAt: Date;
     payload: T;
 }
 export interface SubscribeOptions<T = unknown> {
@@ -49,6 +28,11 @@ export interface SubscribeOptions<T = unknown> {
     blockMs?: number;
     /** A pending message idle this long (ms) is reclaimed from a dead consumer (default 60000). */
     minIdleMs?: number;
+    /**
+     * Deliveries after which an un-acked message is dead-lettered to
+     * `evt:<topic>:dlq` and acked instead of being redelivered again (default 10).
+     */
+    maxDeliveries?: number;
 }
 export interface EventSubscription {
     /** Stop the consumer loop. Resolves once the in-flight read returns. */
@@ -71,7 +55,15 @@ export interface RedisStreamClient {
     xreadgroup(...args: (string | number)[]): Promise<unknown>;
     xack(key: string, group: string, ...ids: string[]): Promise<number>;
     xautoclaim(...args: (string | number)[]): Promise<unknown>;
+    xpending(key: string, group: string, ...args: (string | number)[]): Promise<unknown>;
+    xrange(key: string, start: string, end: string, ...args: (string | number)[]): Promise<unknown>;
+    /** A new connection with the same options — each subscriber reads on its own. */
+    duplicate(): RedisStreamClient;
+    quit?(): Promise<unknown>;
+    on?(event: 'error', cb: (err: unknown) => void): unknown;
 }
+/** Dead-letter stream for a topic. */
+export declare function deadLetterStreamKey(topic: string): string;
 /** Build a durable event bus over a Redis Streams client. */
 export declare function createRedisDurableEventBus(redis: RedisStreamClient, opts?: {
     maxLen?: number;
@@ -85,12 +77,3 @@ export declare function createRedisDurableEventBus(redis: RedisStreamClient, opt
 export declare function createEnvRedisDurableEventBus(opts?: {
     maxLen?: number;
 }): DurableEventBus | null;
-/** Topic the entity-event bridge publishes to. */
-export declare const ENTITY_EVENT_TOPIC = "entity-events";
-/**
- * An {@link EntityEventSubscriber} that forwards each entity event to the durable
- * bus. `bus.publish` is fail-safe (drops-with-metric, never throws), matching the
- * emitter's fire-and-forget contract. Note `EntityEvent.timestamp` (a Date)
- * serializes to an ISO string on the wire — a consumer re-hydrates as needed.
- */
-export declare function createEntityEventBusPublisher(bus: DurableEventBus): EntityEventSubscriber;

package/lib/services/durable-event-bus.js

@@ -1,5 +1,32 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
+/**
+ * Durable, at-least-once event backbone (Redis Streams).
+ *
+ * The platform's cross-service signalling today is point-to-point HTTP plus
+ * polling reconcilers plus an IN-PROCESS best-effort emitter ({@link entityEvents}).
+ * There is no durable bus, so a signal produced on one pod is either delivered
+ * synchronously over HTTP (coupling + retry-storm risk) or lost if the consumer
+ * is momentarily down (the reconcilers exist to paper over exactly that).
+ *
+ * This is that missing bus, as a reusable primitive:
+ *  - **publish(topic, payload)** → `XADD` onto a bounded (`MAXLEN ~`) per-topic
+ *    stream. Durable across restarts, shared by all replicas.
+ *  - **subscribe({topic, group, consumer, handler})** → a `XREADGROUP` consumer
+ *    on its OWN connection (`duplicate()`), so a blocking read never delays a
+ *    publish. Consumer GROUPS give at-least-once: each group gets every message
+ *    once, a message stays pending until the handler `XACK`s it, and `XAUTOCLAIM`
+ *    reclaims messages stranded by a crashed consumer. A message that has been
+ *    delivered `maxDeliveries` times without an ack is moved to a dead-letter
+ *    stream (`evt:<topic>:dlq`) and acked, so a poison message can't redeliver
+ *    forever. Multiple groups on one topic = independent fan-out.
+ *
+ * FAIL-SAFE + OPT-IN, exactly like the audit spool: {@link createEnvRedisDurableEventBus}
+ * returns `null` when Redis isn't configured, so a service without it simply
+ * doesn't use the bus (keeps today's behavior). A publish failure is dropped-with-
+ * -metric, never thrown; a handler throw leaves the message un-acked for redelivery.
+ *
+ */
 import { createEnvRedisClient } from './env-redis.js';
 import { createLogger } from '../utils/logger.js';
 import { emitCounter } from '../utils/metric-emitter.js';
@@ -8,12 +35,22 @@ const DEFAULT_MAXLEN = 10_000;
 const DEFAULT_BATCH = 16;
 const DEFAULT_BLOCK_MS = 5_000;
 const DEFAULT_MIN_IDLE_MS = 60_000;
+const DEFAULT_MAX_DELIVERIES = 10;
 function errMsg(err) {
     return err instanceof Error ? err.message : String(err);
 }
 function streamKey(topic) {
     return `evt:${topic}`;
 }
+/** Dead-letter stream for a topic. */
+export function deadLetterStreamKey(topic) {
+    return `evt:${topic}:dlq`;
+}
+/** Publish time from a stream id (`<ms>-<seq>`); epoch 0 for an unparseable id. */
+function publishedAtFromId(id) {
+    const ms = Number(id.split('-')[0]);
+    return new Date(Number.isFinite(ms) ? ms : 0);
+}
 /** True when the error is Redis' "group already exists" (idempotent create). */
 function isBusyGroup(err) {
     return errMsg(err).includes('BUSYGROUP');
@@ -46,15 +83,16 @@ function parseEntries(topic, entries) {
         // A missing `d` field (an entry not written by publish()) OR a corrupt JSON
         // payload both yield an undefined-payload envelope so `deliver()` ACKs it —
         // a poison message must never wedge the group by staying perpetually pending.
+        const publishedAt = publishedAtFromId(id);
         if (raw === undefined) {
-            out.push({ id, topic, payload: undefined });
+            out.push({ id, topic, publishedAt, payload: undefined });
             continue;
         }
         try {
-            out.push({ id, topic, payload: JSON.parse(raw) });
+            out.push({ id, topic, publishedAt, payload: JSON.parse(raw) });
         }
         catch {
-            out.push({ id, topic, payload: undefined });
+            out.push({ id, topic, publishedAt, payload: undefined });
         }
     }
     return out;
@@ -80,11 +118,18 @@ export function createRedisDurableEventBus(redis, opts = {}) {
         subscribe(subOpts) {
             const { topic, group, consumer, handler } = subOpts;
             const key = streamKey(topic);
+            const dlqKey = deadLetterStreamKey(topic);
             const batch = Math.max(1, subOpts.batchSize ?? DEFAULT_BATCH);
             const blockMs = Math.max(0, subOpts.blockMs ?? DEFAULT_BLOCK_MS);
             const minIdle = Math.max(0, subOpts.minIdleMs ?? DEFAULT_MIN_IDLE_MS);
+            const maxDeliveries = Math.max(1, subOpts.maxDeliveries ?? DEFAULT_MAX_DELIVERIES);
+            // `XREADGROUP BLOCK` holds its connection for up to `blockMs`; on the
+            // shared client every publish queued behind it. Read on a dedicated one.
+            const reader = redis.duplicate();
+            // A duplicated ioredis connection doesn't inherit listeners; without one a
+            // connection error is an unhandled 'error' event that crashes the process.
+            reader.on?.('error', (err) => logger.warn('Event bus reader connection error', { topic, group, error: errMsg(err) }));
             let stopped = false;
-            let started = false;
             const deliver = async (envs) => {
                 for (const env of envs) {
                     try {
@@ -92,7 +137,7 @@ export function createRedisDurableEventBus(redis, opts = {}) {
                             await handler(env);
                         // Ack on success OR on an undefined (corrupt) payload — a poison
                         // message must not block the group forever.
-                        await redis.xack(key, group, env.id);
+                        await reader.xack(key, group, env.id);
                         emitCounter('event_bus_delivered_total', { topic, group });
                     }
                     catch (err) {
@@ -104,23 +149,67 @@ export function createRedisDurableEventBus(redis, opts = {}) {
                     }
                 }
             };
+            /**
+             * Move every idle pending message that has already been delivered
+             * `maxDeliveries` times to the dead-letter stream and ack it. The entry
+             * keeps its payload plus where it came from, so an operator can inspect or
+             * replay it. If copying fails the message is left pending (retried next
+             * pass) — it is never acked without being preserved.
+             */
+            const deadLetterExhausted = async () => {
+                const pending = await reader.xpending(key, group, 'IDLE', minIdle, '-', '+', batch);
+                if (!Array.isArray(pending))
+                    return;
+                for (const p of pending) {
+                    if (!Array.isArray(p) || p.length < 4)
+                        continue;
+                    const id = String(p[0]);
+                    const deliveries = Number(p[3]);
+                    if (!(deliveries >= maxDeliveries))
+                        continue;
+                    const entries = await reader.xrange(key, id, id);
+                    const fields = Array.isArray(entries) && Array.isArray(entries[0]) && Array.isArray(entries[0][1]) ? entries[0][1] : [];
+                    let raw = '';
+                    for (let i = 0; i + 1 < fields.length; i += 2) {
+                        if (String(fields[i]) === 'd') {
+                            raw = String(fields[i + 1]);
+                            break;
+                        }
+                    }
+                    await reader.xadd(dlqKey, 'MAXLEN', '~', maxLen, '*', 'd', raw, 'sourceId', id, 'group', group, 'deliveries', deliveries);
+                    await reader.xack(key, group, id);
+                    emitCounter('event_bus_dead_lettered_total', { topic, group });
+                    logger.error('Event exceeded max deliveries; moved to dead-letter stream', {
+                        topic, group, id, deliveries, deadLetterStream: dlqKey,
+                    });
+                }
+            };
+            // The consumer group must exist before XREADGROUP can succeed. Creating it
+            // is retried inside the loop: at startup the client may not have connected
+            // yet, and a single failed attempt used to leave the consumer reading a
+            // group that was never created — forever.
+            let groupReady = false;
             const ensureGroup = async () => {
                 try {
                     // MKSTREAM so the stream need not exist yet; '$' = only new messages.
-                    await redis.xgroup('CREATE', key, group, '$', 'MKSTREAM');
+                    await reader.xgroup('CREATE', key, group, '$', 'MKSTREAM');
+                    groupReady = true;
                 }
                 catch (err) {
-                    if (!isBusyGroup(err)) {
-                        logger.warn('Event bus group create failed', { topic, group, error: errMsg(err) });
-                    }
+                    if (!isBusyGroup(err))
+                        throw err;
+                    groupReady = true;
                 }
             };
             const loop = async () => {
-                await ensureGroup();
                 while (!stopped) {
                     try {
-                        // 1) Reclaim messages stranded by a crashed consumer in this group.
-                        const claimed = await redis.xautoclaim(key, group, consumer, minIdle, '0', 'COUNT', batch);
+                        if (!groupReady)
+                            await ensureGroup();
+                        // 1) Dead-letter messages that have exhausted their deliveries, then
+                        //    reclaim the rest stranded by a failed/crashed consumer.
+                        await deadLetterExhausted();
+                        const claimed = await reader.xautoclaim(key, group, consumer, minIdle, '0', 'COUNT', batch);
                         // XAUTOCLAIM reply: [nextCursor, entries, deletedIds]
                         if (Array.isArray(claimed) && claimed.length >= 2) {
                             await deliver(parseEntries(topic, claimed[1]));
@@ -128,7 +217,7 @@ export function createRedisDurableEventBus(redis, opts = {}) {
                         if (stopped)
                             break;
                         // 2) Read new, never-delivered messages for this group ('>').
-                        const res = await redis.xreadgroup('GROUP', group, consumer, 'COUNT', batch, 'BLOCK', blockMs, 'STREAMS', key, '>');
+                        const res = await reader.xreadgroup('GROUP', group, consumer, 'COUNT', batch, 'BLOCK', blockMs, 'STREAMS', key, '>');
                         // XREADGROUP reply: [[streamKey, entries]] | null (on block timeout)
                         if (Array.isArray(res) && res.length > 0 && Array.isArray(res[0]) && res[0].length >= 2) {
                             await deliver(parseEntries(topic, res[0][1]));
@@ -137,18 +226,17 @@ export function createRedisDurableEventBus(redis, opts = {}) {
                     catch (err) {
                         if (stopped)
                             break;
+                        // The stream or group was deleted out from under us — recreate it.
+                        if (/NOGROUP/i.test(errMsg(err)))
+                            groupReady = false;
                         logger.warn('Event bus consumer loop error; backing off', { topic, group, error: errMsg(err) });
                         // Back off so a persistent Redis error doesn't hot-spin.
                         await new Promise((r) => setTimeout(r, 1000));
                     }
                 }
             };
-            let loopPromise = Promise.resolve();
-            if (!started) {
-                started = true;
-                loopPromise = loop();
-                logger.info('Event bus consumer started', { topic, group, consumer });
-            }
+            const loopPromise = loop();
+            logger.info('Event bus consumer started', { topic, group, consumer, maxDeliveries });
             return {
                 async stop() {
                     stopped = true;
@@ -156,6 +244,7 @@ export function createRedisDurableEventBus(redis, opts = {}) {
                     // down its DB) doesn't race a message still being processed. Bounded by
                     // the XREADGROUP BLOCK window. Never rejects — the loop swallows errors.
                     await loopPromise.catch(() => undefined);
+                    await Promise.resolve(reader.quit?.()).catch(() => undefined);
                 },
             };
         },
@@ -174,31 +263,4 @@ export function createEnvRedisDurableEventBus(opts = {}) {
     logger.info('Redis durable event bus initialized');
     return createRedisDurableEventBus(inst, opts);
 }
-// ---------------------------------------------------------------------------
-// Entity-event bridge (additive, opt-in)
-//
-// Lets a service give its in-process {@link entityEvents} emitter a DURABLE,
-// cross-pod delivery leg WITHOUT changing existing behavior: register the
-// returned subscriber and every entity mutation is ALSO published to the bus.
-// A consumer elsewhere (`bus.subscribe`) then reacts at-least-once across pods
-// and restarts. The in-process subscribers keep firing exactly as before, so
-// this is purely additive — no double-processing unless a service intentionally
-// runs a bus consumer for the same reaction. Kept here (not in entity-events.ts)
-// so that module stays infrastructure-free per its own contract.
-// ---------------------------------------------------------------------------
-/** Topic the entity-event bridge publishes to. */
-export const ENTITY_EVENT_TOPIC = 'entity-events';
-/**
- * An {@link EntityEventSubscriber} that forwards each entity event to the durable
- * bus. `bus.publish` is fail-safe (drops-with-metric, never throws), matching the
- * emitter's fire-and-forget contract. Note `EntityEvent.timestamp` (a Date)
- * serializes to an ISO string on the wire — a consumer re-hydrates as needed.
- */
-export function createEntityEventBusPublisher(bus) {
-    return {
-        async onEntityEvent(event) {
-            await bus.publish(ENTITY_EVENT_TOPIC, event);
-        },
-    };
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"durable-event-bus.js","sourceRoot":"","sources":["../../src/services/durable-event-bus.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Durable, at-least-once event backbone (Redis Streams).\n *\n * The platform's cross-service signalling today is point-to-point HTTP plus\n * polling reconcilers plus an IN-PROCESS best-effort emitter ({@link entityEvents}).\n * There is no durable bus, so a signal produced on one pod is either delivered\n * synchronously over HTTP (coupling + retry-storm risk) or lost if the consumer\n * is momentarily down (the reconcilers exist to paper over exactly that).\n *\n * This is that missing bus, as a reusable primitive:\n *  - **publish(topic, payload)** → `XADD` onto a bounded (`MAXLEN ~`) per-topic\n *    stream. Durable across restarts, shared by all replicas.\n *  - **subscribe({topic, group, consumer, handler})** → a `XREADGROUP` consumer.\n *    Consumer GROUPS give at-least-once: each group gets every message once, a\n *    message stays pending until the handler `XACK`s it, and `XAUTOCLAIM`\n *    reclaims messages stranded by a crashed consumer. Multiple groups on one\n *    topic = independent fan-out (e.g. quota-sync AND audit both react).\n *\n * FAIL-SAFE + OPT-IN, exactly like the audit spool: {@link createEnvRedisDurableEventBus}\n * returns `null` when Redis isn't configured, so a service without it simply\n * doesn't use the bus (keeps today's behavior). A publish failure is dropped-with-\n * -metric, never thrown; a handler throw leaves the message un-acked for redelivery.\n *\n * Migrating a specific reconciler (e.g. billing→quota entitlement sync) onto this\n * is deliberately follow-on work — this lands the backbone + an additive entity-\n * event bridge; the reconcilers stay as the belt-and-suspenders backstop until a\n * flow is fully cut over.\n */\n\nimport type { EntityEvent, EntityEventSubscriber } from './entity-events.js';\nimport { createEnvRedisClient } from './env-redis.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('durable-event-bus');\n\n/** A delivered event: its stream id, topic, and decoded payload. */\nexport interface EventEnvelope<T = unknown> {\n  /** Redis Stream entry id (`<ms>-<seq>`) — also the idempotency handle. */\n  id: string;\n  topic: string;\n  payload: T;\n}\n\nexport interface SubscribeOptions<T = unknown> {\n  /** Topic (stream) to consume. */\n  topic: string;\n  /** Consumer group — one delivery per group; distinct groups fan out. */\n  group: string;\n  /** This consumer's id within the group (e.g. `${service}-${pid}`). */\n  consumer: string;\n  /** Async handler. Resolves ⇒ the message is acked; throws ⇒ left pending for redelivery. */\n  handler: (env: EventEnvelope<T>) => Promise<void>;\n  /** Max messages per read (default 16). */\n  batchSize?: number;\n  /** XREADGROUP block time in ms (default 5000). */\n  blockMs?: number;\n  /** A pending message idle this long (ms) is reclaimed from a dead consumer (default 60000). */\n  minIdleMs?: number;\n}\n\nexport interface EventSubscription {\n  /** Stop the consumer loop. Resolves once the in-flight read returns. */\n  stop(): Promise<void>;\n}\n\nexport interface DurableEventBus {\n  /** Publish a payload to a topic. Returns the stream id, or null on failure (dropped, never throws). */\n  publish<T>(topic: string, payload: T): Promise<string | null>;\n  /** Start a consumer-group reader for a topic. Fire-and-forget loop; call `stop()` to end it. */\n  subscribe<T>(opts: SubscribeOptions<T>): EventSubscription;\n}\n\n/**\n * The subset of ioredis' Stream API the bus uses. Kept minimal so a test can\n * supply an in-memory fake and so merely importing this never hard-depends on\n * ioredis (constructed via the shared env helper).\n */\nexport interface RedisStreamClient {\n  xadd(key: string, ...args: (string | number)[]): Promise<string | null>;\n  xgroup(...args: (string | number)[]): Promise<unknown>;\n  xreadgroup(...args: (string | number)[]): Promise<unknown>;\n  xack(key: string, group: string, ...ids: string[]): Promise<number>;\n  xautoclaim(...args: (string | number)[]): Promise<unknown>;\n}\n\nconst DEFAULT_MAXLEN = 10_000;\nconst DEFAULT_BATCH = 16;\nconst DEFAULT_BLOCK_MS = 5_000;\nconst DEFAULT_MIN_IDLE_MS = 60_000;\n\nfunction errMsg(err: unknown): string {\n  return err instanceof Error ? err.message : String(err);\n}\n\nfunction streamKey(topic: string): string {\n  return `evt:${topic}`;\n}\n\n/** True when the error is Redis' \"group already exists\" (idempotent create). */\nfunction isBusyGroup(err: unknown): boolean {\n  return errMsg(err).includes('BUSYGROUP');\n}\n\n/**\n * Parse the nested array shape XREADGROUP / XAUTOCLAIM return into flat envelopes.\n * XREADGROUP: `[[streamKey, [[id, [f, v, ...]], ...]]]`.\n * XAUTOCLAIM: `[nextCursor, [[id, [f, v, ...]], ...], deletedIds]`.\n * We store the JSON payload under a single field `d`.\n */\nfunction parseEntries<T>(topic: string, entries: unknown): EventEnvelope<T>[] {\n  const out: EventEnvelope<T>[] = [];\n  if (!Array.isArray(entries)) return out;\n  for (const entry of entries) {\n    if (!Array.isArray(entry) || entry.length < 2) continue;\n    const id = String(entry[0]);\n    const fields = entry[1];\n    if (!Array.isArray(fields)) continue;\n    // fields is [name, value, name, value, ...]; find 'd'.\n    let raw: string | undefined;\n    for (let i = 0; i + 1 < fields.length; i += 2) {\n      if (String(fields[i]) === 'd') { raw = String(fields[i + 1]); break; }\n    }\n    // A missing `d` field (an entry not written by publish()) OR a corrupt JSON\n    // payload both yield an undefined-payload envelope so `deliver()` ACKs it —\n    // a poison message must never wedge the group by staying perpetually pending.\n    if (raw === undefined) {\n      out.push({ id, topic, payload: undefined as unknown as T });\n      continue;\n    }\n    try {\n      out.push({ id, topic, payload: JSON.parse(raw) as T });\n    } catch {\n      out.push({ id, topic, payload: undefined as unknown as T });\n    }\n  }\n  return out;\n}\n\n/** Build a durable event bus over a Redis Streams client. */\nexport function createRedisDurableEventBus(\n  redis: RedisStreamClient,\n  opts: { maxLen?: number } = {},\n): DurableEventBus {\n  const maxLen = Math.max(1, opts.maxLen ?? DEFAULT_MAXLEN);\n\n  return {\n    async publish<T>(topic: string, payload: T): Promise<string | null> {\n      const key = streamKey(topic);\n      try {\n        // MAXLEN ~ <n> bounds the stream approximately (cheap); `*` = server id.\n        const id = await redis.xadd(key, 'MAXLEN', '~', maxLen, '*', 'd', JSON.stringify(payload));\n        emitCounter('event_bus_published_total', { topic });\n        return id;\n      } catch (err) {\n        emitCounter('event_bus_publish_failed_total', { topic });\n        logger.warn('Event bus publish failed (event dropped)', { topic, error: errMsg(err) });\n        return null;\n      }\n    },\n\n    subscribe<T>(subOpts: SubscribeOptions<T>): EventSubscription {\n      const { topic, group, consumer, handler } = subOpts;\n      const key = streamKey(topic);\n      const batch = Math.max(1, subOpts.batchSize ?? DEFAULT_BATCH);\n      const blockMs = Math.max(0, subOpts.blockMs ?? DEFAULT_BLOCK_MS);\n      const minIdle = Math.max(0, subOpts.minIdleMs ?? DEFAULT_MIN_IDLE_MS);\n\n      let stopped = false;\n      let started = false;\n\n      const deliver = async (envs: EventEnvelope<T>[]): Promise<void> => {\n        for (const env of envs) {\n          try {\n            if (env.payload !== undefined) await handler(env);\n            // Ack on success OR on an undefined (corrupt) payload — a poison\n            // message must not block the group forever.\n            await redis.xack(key, group, env.id);\n            emitCounter('event_bus_delivered_total', { topic, group });\n          } catch (err) {\n            // Leave it pending (no XACK) — XAUTOCLAIM redelivers it after minIdle.\n            emitCounter('event_bus_handler_failed_total', { topic, group });\n            logger.warn('Event handler failed; leaving message pending for redelivery', {\n              topic, group, id: env.id, error: errMsg(err),\n            });\n          }\n        }\n      };\n\n      const ensureGroup = async (): Promise<void> => {\n        try {\n          // MKSTREAM so the stream need not exist yet; '$' = only new messages.\n          await redis.xgroup('CREATE', key, group, '$', 'MKSTREAM');\n        } catch (err) {\n          if (!isBusyGroup(err)) {\n            logger.warn('Event bus group create failed', { topic, group, error: errMsg(err) });\n          }\n        }\n      };\n\n      const loop = async (): Promise<void> => {\n        await ensureGroup();\n        while (!stopped) {\n          try {\n            // 1) Reclaim messages stranded by a crashed consumer in this group.\n            const claimed = await redis.xautoclaim(key, group, consumer, minIdle, '0', 'COUNT', batch);\n            // XAUTOCLAIM reply: [nextCursor, entries, deletedIds]\n            if (Array.isArray(claimed) && claimed.length >= 2) {\n              await deliver(parseEntries<T>(topic, claimed[1]));\n            }\n            if (stopped) break;\n\n            // 2) Read new, never-delivered messages for this group ('>').\n            const res = await redis.xreadgroup(\n              'GROUP', group, consumer, 'COUNT', batch, 'BLOCK', blockMs, 'STREAMS', key, '>',\n            );\n            // XREADGROUP reply: [[streamKey, entries]] | null (on block timeout)\n            if (Array.isArray(res) && res.length > 0 && Array.isArray(res[0]) && res[0].length >= 2) {\n              await deliver(parseEntries<T>(topic, res[0][1]));\n            }\n          } catch (err) {\n            if (stopped) break;\n            logger.warn('Event bus consumer loop error; backing off', { topic, group, error: errMsg(err) });\n            // Back off so a persistent Redis error doesn't hot-spin.\n            await new Promise((r) => setTimeout(r, 1000));\n          }\n        }\n      };\n\n      let loopPromise = Promise.resolve();\n      if (!started) {\n        started = true;\n        loopPromise = loop();\n        logger.info('Event bus consumer started', { topic, group, consumer });\n      }\n\n      return {\n        async stop(): Promise<void> {\n          stopped = true;\n          // Await the in-flight read/handler so a caller (e.g. a service shutting\n          // down its DB) doesn't race a message still being processed. Bounded by\n          // the XREADGROUP BLOCK window. Never rejects — the loop swallows errors.\n          await loopPromise.catch(() => undefined);\n        },\n      };\n    },\n  };\n}\n\n/**\n * Build a durable event bus from the ambient Redis env via the shared\n * `createEnvRedisClient`. Returns `null` when Redis is not configured — the\n * caller then runs without a bus (today's HTTP/reconciler behavior), never\n * crashing. Opt in with a single boot line where a service wants durable events.\n */\nexport function createEnvRedisDurableEventBus(opts: { maxLen?: number } = {}): DurableEventBus | null {\n  const inst = createEnvRedisClient<RedisStreamClient>('event-bus');\n  if (!inst) return null;\n  logger.info('Redis durable event bus initialized');\n  return createRedisDurableEventBus(inst, opts);\n}\n\n// ---------------------------------------------------------------------------\n// Entity-event bridge (additive, opt-in)\n//\n// Lets a service give its in-process {@link entityEvents} emitter a DURABLE,\n// cross-pod delivery leg WITHOUT changing existing behavior: register the\n// returned subscriber and every entity mutation is ALSO published to the bus.\n// A consumer elsewhere (`bus.subscribe`) then reacts at-least-once across pods\n// and restarts. The in-process subscribers keep firing exactly as before, so\n// this is purely additive — no double-processing unless a service intentionally\n// runs a bus consumer for the same reaction. Kept here (not in entity-events.ts)\n// so that module stays infrastructure-free per its own contract.\n// ---------------------------------------------------------------------------\n\n/** Topic the entity-event bridge publishes to. */\nexport const ENTITY_EVENT_TOPIC = 'entity-events';\n\n/**\n * An {@link EntityEventSubscriber} that forwards each entity event to the durable\n * bus. `bus.publish` is fail-safe (drops-with-metric, never throws), matching the\n * emitter's fire-and-forget contract. Note `EntityEvent.timestamp` (a Date)\n * serializes to an ISO string on the wire — a consumer re-hydrates as needed.\n */\nexport function createEntityEventBusPublisher(bus: DurableEventBus): EntityEventSubscriber {\n  return {\n    async onEntityEvent(event: EntityEvent): Promise<void> {\n      await bus.publish(ENTITY_EVENT_TOPIC, event);\n    },\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"durable-event-bus.js","sourceRoot":"","sources":["../../src/services/durable-event-bus.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Durable, at-least-once event backbone (Redis Streams).\n *\n * The platform's cross-service signalling today is point-to-point HTTP plus\n * polling reconcilers plus an IN-PROCESS best-effort emitter ({@link entityEvents}).\n * There is no durable bus, so a signal produced on one pod is either delivered\n * synchronously over HTTP (coupling + retry-storm risk) or lost if the consumer\n * is momentarily down (the reconcilers exist to paper over exactly that).\n *\n * This is that missing bus, as a reusable primitive:\n *  - **publish(topic, payload)** → `XADD` onto a bounded (`MAXLEN ~`) per-topic\n *    stream. Durable across restarts, shared by all replicas.\n *  - **subscribe({topic, group, consumer, handler})** → a `XREADGROUP` consumer\n *    on its OWN connection (`duplicate()`), so a blocking read never delays a\n *    publish. Consumer GROUPS give at-least-once: each group gets every message\n *    once, a message stays pending until the handler `XACK`s it, and `XAUTOCLAIM`\n *    reclaims messages stranded by a crashed consumer. A message that has been\n *    delivered `maxDeliveries` times without an ack is moved to a dead-letter\n *    stream (`evt:<topic>:dlq`) and acked, so a poison message can't redeliver\n *    forever. Multiple groups on one topic = independent fan-out.\n *\n * FAIL-SAFE + OPT-IN, exactly like the audit spool: {@link createEnvRedisDurableEventBus}\n * returns `null` when Redis isn't configured, so a service without it simply\n * doesn't use the bus (keeps today's behavior). A publish failure is dropped-with-\n * -metric, never thrown; a handler throw leaves the message un-acked for redelivery.\n *\n */\n\nimport { createEnvRedisClient } from './env-redis.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('durable-event-bus');\n\n/** A delivered event: its stream id, topic, publish time, and decoded payload. */\nexport interface EventEnvelope<T = unknown> {\n  /** Redis Stream entry id (`<ms>-<seq>`) — also the idempotency handle. */\n  id: string;\n  topic: string;\n  /**\n   * When the event was published (the Redis server time embedded in the stream\n   * id). A redelivery keeps its ORIGINAL publish time, so a consumer applying\n   * last-writer-wins state (e.g. an entitlement sync) can order events by it\n   * instead of by delivery time and refuse to let a stale retry overwrite a\n   * newer state.\n   */\n  publishedAt: Date;\n  payload: T;\n}\n\nexport interface SubscribeOptions<T = unknown> {\n  /** Topic (stream) to consume. */\n  topic: string;\n  /** Consumer group — one delivery per group; distinct groups fan out. */\n  group: string;\n  /** This consumer's id within the group (e.g. `${service}-${pid}`). */\n  consumer: string;\n  /** Async handler. Resolves ⇒ the message is acked; throws ⇒ left pending for redelivery. */\n  handler: (env: EventEnvelope<T>) => Promise<void>;\n  /** Max messages per read (default 16). */\n  batchSize?: number;\n  /** XREADGROUP block time in ms (default 5000). */\n  blockMs?: number;\n  /** A pending message idle this long (ms) is reclaimed from a dead consumer (default 60000). */\n  minIdleMs?: number;\n  /**\n   * Deliveries after which an un-acked message is dead-lettered to\n   * `evt:<topic>:dlq` and acked instead of being redelivered again (default 10).\n   */\n  maxDeliveries?: number;\n}\n\nexport interface EventSubscription {\n  /** Stop the consumer loop. Resolves once the in-flight read returns. */\n  stop(): Promise<void>;\n}\n\nexport interface DurableEventBus {\n  /** Publish a payload to a topic. Returns the stream id, or null on failure (dropped, never throws). */\n  publish<T>(topic: string, payload: T): Promise<string | null>;\n  /** Start a consumer-group reader for a topic. Fire-and-forget loop; call `stop()` to end it. */\n  subscribe<T>(opts: SubscribeOptions<T>): EventSubscription;\n}\n\n/**\n * The subset of ioredis' Stream API the bus uses. Kept minimal so a test can\n * supply an in-memory fake and so merely importing this never hard-depends on\n * ioredis (constructed via the shared env helper).\n */\nexport interface RedisStreamClient {\n  xadd(key: string, ...args: (string | number)[]): Promise<string | null>;\n  xgroup(...args: (string | number)[]): Promise<unknown>;\n  xreadgroup(...args: (string | number)[]): Promise<unknown>;\n  xack(key: string, group: string, ...ids: string[]): Promise<number>;\n  xautoclaim(...args: (string | number)[]): Promise<unknown>;\n  xpending(key: string, group: string, ...args: (string | number)[]): Promise<unknown>;\n  xrange(key: string, start: string, end: string, ...args: (string | number)[]): Promise<unknown>;\n  /** A new connection with the same options — each subscriber reads on its own. */\n  duplicate(): RedisStreamClient;\n  quit?(): Promise<unknown>;\n  on?(event: 'error', cb: (err: unknown) => void): unknown;\n}\n\nconst DEFAULT_MAXLEN = 10_000;\nconst DEFAULT_BATCH = 16;\nconst DEFAULT_BLOCK_MS = 5_000;\nconst DEFAULT_MIN_IDLE_MS = 60_000;\nconst DEFAULT_MAX_DELIVERIES = 10;\n\nfunction errMsg(err: unknown): string {\n  return err instanceof Error ? err.message : String(err);\n}\n\nfunction streamKey(topic: string): string {\n  return `evt:${topic}`;\n}\n\n/** Dead-letter stream for a topic. */\nexport function deadLetterStreamKey(topic: string): string {\n  return `evt:${topic}:dlq`;\n}\n\n/** Publish time from a stream id (`<ms>-<seq>`); epoch 0 for an unparseable id. */\nfunction publishedAtFromId(id: string): Date {\n  const ms = Number(id.split('-')[0]);\n  return new Date(Number.isFinite(ms) ? ms : 0);\n}\n\n/** True when the error is Redis' \"group already exists\" (idempotent create). */\nfunction isBusyGroup(err: unknown): boolean {\n  return errMsg(err).includes('BUSYGROUP');\n}\n\n/**\n * Parse the nested array shape XREADGROUP / XAUTOCLAIM return into flat envelopes.\n * XREADGROUP: `[[streamKey, [[id, [f, v, ...]], ...]]]`.\n * XAUTOCLAIM: `[nextCursor, [[id, [f, v, ...]], ...], deletedIds]`.\n * We store the JSON payload under a single field `d`.\n */\nfunction parseEntries<T>(topic: string, entries: unknown): EventEnvelope<T>[] {\n  const out: EventEnvelope<T>[] = [];\n  if (!Array.isArray(entries)) return out;\n  for (const entry of entries) {\n    if (!Array.isArray(entry) || entry.length < 2) continue;\n    const id = String(entry[0]);\n    const fields = entry[1];\n    if (!Array.isArray(fields)) continue;\n    // fields is [name, value, name, value, ...]; find 'd'.\n    let raw: string | undefined;\n    for (let i = 0; i + 1 < fields.length; i += 2) {\n      if (String(fields[i]) === 'd') { raw = String(fields[i + 1]); break; }\n    }\n    // A missing `d` field (an entry not written by publish()) OR a corrupt JSON\n    // payload both yield an undefined-payload envelope so `deliver()` ACKs it —\n    // a poison message must never wedge the group by staying perpetually pending.\n    const publishedAt = publishedAtFromId(id);\n    if (raw === undefined) {\n      out.push({ id, topic, publishedAt, payload: undefined as unknown as T });\n      continue;\n    }\n    try {\n      out.push({ id, topic, publishedAt, payload: JSON.parse(raw) as T });\n    } catch {\n      out.push({ id, topic, publishedAt, payload: undefined as unknown as T });\n    }\n  }\n  return out;\n}\n\n/** Build a durable event bus over a Redis Streams client. */\nexport function createRedisDurableEventBus(\n  redis: RedisStreamClient,\n  opts: { maxLen?: number } = {},\n): DurableEventBus {\n  const maxLen = Math.max(1, opts.maxLen ?? DEFAULT_MAXLEN);\n\n  return {\n    async publish<T>(topic: string, payload: T): Promise<string | null> {\n      const key = streamKey(topic);\n      try {\n        // MAXLEN ~ <n> bounds the stream approximately (cheap); `*` = server id.\n        const id = await redis.xadd(key, 'MAXLEN', '~', maxLen, '*', 'd', JSON.stringify(payload));\n        emitCounter('event_bus_published_total', { topic });\n        return id;\n      } catch (err) {\n        emitCounter('event_bus_publish_failed_total', { topic });\n        logger.warn('Event bus publish failed (event dropped)', { topic, error: errMsg(err) });\n        return null;\n      }\n    },\n\n    subscribe<T>(subOpts: SubscribeOptions<T>): EventSubscription {\n      const { topic, group, consumer, handler } = subOpts;\n      const key = streamKey(topic);\n      const dlqKey = deadLetterStreamKey(topic);\n      const batch = Math.max(1, subOpts.batchSize ?? DEFAULT_BATCH);\n      const blockMs = Math.max(0, subOpts.blockMs ?? DEFAULT_BLOCK_MS);\n      const minIdle = Math.max(0, subOpts.minIdleMs ?? DEFAULT_MIN_IDLE_MS);\n      const maxDeliveries = Math.max(1, subOpts.maxDeliveries ?? DEFAULT_MAX_DELIVERIES);\n\n      // `XREADGROUP BLOCK` holds its connection for up to `blockMs`; on the\n      // shared client every publish queued behind it. Read on a dedicated one.\n      const reader = redis.duplicate();\n      // A duplicated ioredis connection doesn't inherit listeners; without one a\n      // connection error is an unhandled 'error' event that crashes the process.\n      reader.on?.('error', (err) => logger.warn('Event bus reader connection error', { topic, group, error: errMsg(err) }));\n\n      let stopped = false;\n\n      const deliver = async (envs: EventEnvelope<T>[]): Promise<void> => {\n        for (const env of envs) {\n          try {\n            if (env.payload !== undefined) await handler(env);\n            // Ack on success OR on an undefined (corrupt) payload — a poison\n            // message must not block the group forever.\n            await reader.xack(key, group, env.id);\n            emitCounter('event_bus_delivered_total', { topic, group });\n          } catch (err) {\n            // Leave it pending (no XACK) — XAUTOCLAIM redelivers it after minIdle.\n            emitCounter('event_bus_handler_failed_total', { topic, group });\n            logger.warn('Event handler failed; leaving message pending for redelivery', {\n              topic, group, id: env.id, error: errMsg(err),\n            });\n          }\n        }\n      };\n\n      /**\n       * Move every idle pending message that has already been delivered\n       * `maxDeliveries` times to the dead-letter stream and ack it. The entry\n       * keeps its payload plus where it came from, so an operator can inspect or\n       * replay it. If copying fails the message is left pending (retried next\n       * pass) — it is never acked without being preserved.\n       */\n      const deadLetterExhausted = async (): Promise<void> => {\n        const pending = await reader.xpending(key, group, 'IDLE', minIdle, '-', '+', batch);\n        if (!Array.isArray(pending)) return;\n        for (const p of pending) {\n          if (!Array.isArray(p) || p.length < 4) continue;\n          const id = String(p[0]);\n          const deliveries = Number(p[3]);\n          if (!(deliveries >= maxDeliveries)) continue;\n          const entries = await reader.xrange(key, id, id);\n          const fields = Array.isArray(entries) && Array.isArray(entries[0]) && Array.isArray(entries[0][1]) ? entries[0][1] : [];\n          let raw = '';\n          for (let i = 0; i + 1 < fields.length; i += 2) {\n            if (String(fields[i]) === 'd') { raw = String(fields[i + 1]); break; }\n          }\n          await reader.xadd(\n            dlqKey, 'MAXLEN', '~', maxLen, '*',\n            'd', raw, 'sourceId', id, 'group', group, 'deliveries', deliveries,\n          );\n          await reader.xack(key, group, id);\n          emitCounter('event_bus_dead_lettered_total', { topic, group });\n          logger.error('Event exceeded max deliveries; moved to dead-letter stream', {\n            topic, group, id, deliveries, deadLetterStream: dlqKey,\n          });\n        }\n      };\n\n      // The consumer group must exist before XREADGROUP can succeed. Creating it\n      // is retried inside the loop: at startup the client may not have connected\n      // yet, and a single failed attempt used to leave the consumer reading a\n      // group that was never created — forever.\n      let groupReady = false;\n      const ensureGroup = async (): Promise<void> => {\n        try {\n          // MKSTREAM so the stream need not exist yet; '$' = only new messages.\n          await reader.xgroup('CREATE', key, group, '$', 'MKSTREAM');\n          groupReady = true;\n        } catch (err) {\n          if (!isBusyGroup(err)) throw err;\n          groupReady = true;\n        }\n      };\n\n      const loop = async (): Promise<void> => {\n        while (!stopped) {\n          try {\n            if (!groupReady) await ensureGroup();\n            // 1) Dead-letter messages that have exhausted their deliveries, then\n            //    reclaim the rest stranded by a failed/crashed consumer.\n            await deadLetterExhausted();\n            const claimed = await reader.xautoclaim(key, group, consumer, minIdle, '0', 'COUNT', batch);\n            // XAUTOCLAIM reply: [nextCursor, entries, deletedIds]\n            if (Array.isArray(claimed) && claimed.length >= 2) {\n              await deliver(parseEntries<T>(topic, claimed[1]));\n            }\n            if (stopped) break;\n\n            // 2) Read new, never-delivered messages for this group ('>').\n            const res = await reader.xreadgroup(\n              'GROUP', group, consumer, 'COUNT', batch, 'BLOCK', blockMs, 'STREAMS', key, '>',\n            );\n            // XREADGROUP reply: [[streamKey, entries]] | null (on block timeout)\n            if (Array.isArray(res) && res.length > 0 && Array.isArray(res[0]) && res[0].length >= 2) {\n              await deliver(parseEntries<T>(topic, res[0][1]));\n            }\n          } catch (err) {\n            if (stopped) break;\n            // The stream or group was deleted out from under us — recreate it.\n            if (/NOGROUP/i.test(errMsg(err))) groupReady = false;\n            logger.warn('Event bus consumer loop error; backing off', { topic, group, error: errMsg(err) });\n            // Back off so a persistent Redis error doesn't hot-spin.\n            await new Promise((r) => setTimeout(r, 1000));\n          }\n        }\n      };\n\n      const loopPromise = loop();\n      logger.info('Event bus consumer started', { topic, group, consumer, maxDeliveries });\n\n      return {\n        async stop(): Promise<void> {\n          stopped = true;\n          // Await the in-flight read/handler so a caller (e.g. a service shutting\n          // down its DB) doesn't race a message still being processed. Bounded by\n          // the XREADGROUP BLOCK window. Never rejects — the loop swallows errors.\n          await loopPromise.catch(() => undefined);\n          await Promise.resolve(reader.quit?.()).catch(() => undefined);\n        },\n      };\n    },\n  };\n}\n\n/**\n * Build a durable event bus from the ambient Redis env via the shared\n * `createEnvRedisClient`. Returns `null` when Redis is not configured — the\n * caller then runs without a bus (today's HTTP/reconciler behavior), never\n * crashing. Opt in with a single boot line where a service wants durable events.\n */\nexport function createEnvRedisDurableEventBus(opts: { maxLen?: number } = {}): DurableEventBus | null {\n  const inst = createEnvRedisClient<RedisStreamClient>('event-bus');\n  if (!inst) return null;\n  logger.info('Redis durable event bus initialized');\n  return createRedisDurableEventBus(inst, opts);\n}\n"]}

package/lib/services/env-redis.d.ts

@@ -1,44 +1,123 @@
 /**
- * Parse `REDIS_SENTINELS` (comma-separated `host:port` list) into the ioredis
- * `{ host, port }[]` sentinel array. Blank/garbage entries are skipped; a
- * missing port defaults to the Sentinel default 26379. Returns an empty array
- * when the env is unset/empty (→ non-sentinel mode).
+ * The ONE place Redis connection settings are read from the environment.
+ *
+ * Two shapes, exactly one of which may be set:
+ *
+ * - **Standalone** — `REDIS_URL` (`redis://host:6379[/db]`, or `rediss://` for
+ *   TLS). Credentials may sit in the URL or in `REDIS_PASSWORD`.
+ * - **HA (Sentinel)** — `REDIS_SENTINELS` (comma-separated `host:port`) plus
+ *   `REDIS_SENTINEL_MASTER` (default `mymaster`) and optional
+ *   `REDIS_SENTINEL_PASSWORD`. `REDIS_PASSWORD` authenticates to the data nodes.
+ *   ioredis follows the master across a failover.
+ *
+ * Neither set → Redis is off, and each caller degrades to its documented
+ * no-Redis behavior.
+ *
+ * `REDIS_HOST` / `REDIS_PORT` are not read. `REDIS_HOST` is refused outright so a
+ * stale config fails at startup instead of silently running without Redis.
+ * `REDIS_PORT` can't be refused: Kubernetes injects `REDIS_PORT=tcp://<ip>:6379`
+ * into every pod in a namespace with a Service named `redis`, which is exactly
+ * why a host/port pair was unsafe to parse.
+ *
+ * Misconfiguration throws {@link RedisConfigError}. Writers and readers of the
+ * same keys (revocation, step-up, leader locks) must resolve Redis identically;
+ * a config that quietly resolved to "no Redis" on one side is how revocation
+ * once did nothing at all.
+ */
+/** Thrown for a Redis environment that can't be used as written. */
+export declare class RedisConfigError extends Error {
+    constructor(message: string);
+}
+/** Resolved connection, independent of any client library. */
+export type RedisConnection = {
+    mode: 'sentinel';
+    sentinels: Array<{
+        host: string;
+        port: number;
+    }>;
+    masterName: string;
+    password?: string;
+    sentinelPassword?: string;
+} | {
+    mode: 'url';
+    url: string;
+    password?: string;
+};
+/**
+ * Parse `REDIS_SENTINELS` into `{ host, port }[]`. Blank entries are skipped and
+ * a missing port means the Sentinel default 26379; a port that isn't a valid
+ * TCP port is a configuration error.
  */
 export declare function parseSentinels(raw: string | undefined): Array<{
     host: string;
     port: number;
 }>;
 /**
- * Construct an ioredis client from the standard `REDIS_URL` or
- * `REDIS_HOST`/`REDIS_PORT` env — OR, for HA, from Redis Sentinel via
- * `REDIS_SENTINELS` + `REDIS_SENTINEL_MASTER`. The shared construction was
- * previously duplicated across the leader-lock, audit-spool, and
- * token-revocation env factories.
- *
- * Connection modes (first that matches wins):
- * 1. SENTINEL — `REDIS_SENTINELS` set (comma-separated `host:port`): ioredis
- *    resolves the current master from the sentinels (`name` = `REDIS_SENTINEL_MASTER`,
- *    default `mymaster`) and transparently reconnects to the new master after a
- *    failover. This is how the app gets HA against a single-node Redis loss —
- *    also the shape a managed ElastiCache (cluster-mode-disabled) speaks.
- * 2. URL — `REDIS_URL`.
- * 3. HOST/PORT — `REDIS_HOST`(+`REDIS_PORT`).
- *
- * Semantics every caller relies on (kept identical across the consolidation):
- * - Returns `null` when NONE of sentinels/url/host is set, so a caller degrades
- *   to its no-Redis fallback (run-on-every-pod / best-effort / fail-open).
- * - FAIL-SAFE: any ioredis load or construction error is swallowed and returns
- *   `null` — Redis being unavailable must never crash the importing service.
- * - `ioredis` is a runtime-only optional dep loaded via `createRequire`, so this
- *   module stays importable in CJS bundles and where Redis isn't installed.
- * - `maxRetriesPerRequest: 1` + `enableOfflineQueue: false`: commands fail fast
- *   rather than queueing during an outage (callers are fail-open/best-effort).
- * - An `error` listener is attached (ioredis auto-reconnects) so a dropped
- *   connection can't surface as an unhandled `'error'` event that crashes Node.
- *
- * Optional auth: `REDIS_PASSWORD` (data-node AUTH) and `REDIS_SENTINEL_PASSWORD`
- * (sentinel AUTH, sentinel mode only) are threaded through when set.
- *
- * @param label short human name for this client, used in the two warn logs.
+ * Resolve the Redis connection from `env`, or `null` when Redis isn't
+ * configured. Throws {@link RedisConfigError} for an unusable configuration.
+ */
+export declare function resolveRedisConnection(env?: NodeJS.ProcessEnv): RedisConnection | null;
+/** A log-safe description of a connection (never includes credentials). */
+export declare function describeRedisConnection(conn: RedisConnection): Record<string, unknown>;
+/**
+ * Construct an ioredis client for a resolved connection. `options` are merged
+ * into the client options (e.g. `{ db, maxRetriesPerRequest: null }` for BullMQ).
+ * An `error` listener is always attached so a dropped connection is logged
+ * rather than surfacing as an unhandled `'error'` event that crashes Node.
+ */
+export declare function createRedisClient<T = unknown>(conn: RedisConnection, label: string, options?: Record<string, unknown>): T;
+/**
+ * The shared application Redis client: `null` when Redis isn't configured, so
+ * the caller degrades to its no-Redis behavior.
+ *
+ * Commands fail fast (`maxRetriesPerRequest: 1`, no offline queue) because the
+ * request-path callers are best-effort or fail closed on their own terms — a
+ * request must not hang behind a Redis outage. That includes the moments before
+ * the first connection completes: a background caller that runs at startup must
+ * either tolerate a rejected command or wait with {@link whenRedisReady}.
+ *
+ * Throws {@link RedisConfigError} for a bad configuration, and if Redis is
+ * configured but `ioredis` can't be loaded — both are deployment errors that
+ * must not quietly turn Redis-backed guarantees off.
  */
 export declare function createEnvRedisClient<T = unknown>(label: string): T | null;
+/** The subset of ioredis needed to wait for a connection. */
+export interface ReadyAwareRedis {
+    status?: string;
+    once?(event: string, cb: (...args: unknown[]) => void): unknown;
+    off?(event: string, cb: (...args: unknown[]) => void): unknown;
+}
+/**
+ * Resolve once `client` is connected and ready for commands, or reject after
+ * `timeoutMs`. For startup work (creating a consumer group, subscribing) that
+ * otherwise races the first connection. A client without ioredis' `status`
+ * (e.g. a test double) counts as ready.
+ */
+export declare function whenRedisReady(client: ReadyAwareRedis, timeoutMs?: number): Promise<void>;
+/** Default bound for {@link createRedisReadyGate}: short enough for a request path. */
+export declare const REQUEST_PATH_REDIS_READY_TIMEOUT_MS = 2000;
+/**
+ * A request-path readiness gate for a lazily built env Redis client.
+ *
+ * The env client has no offline queue, so a command issued before the first
+ * connection completes is rejected outright — the first request after a lazy
+ * construction would otherwise hit that rejection (e.g. the first step-up per
+ * pod failing, or the first impersonation check reading "unavailable").
+ *
+ * The returned function resolves once the client is ready, or after
+ * `timeoutMs` — it NEVER rejects: the caller then runs its command and keeps its
+ * own fail-open / fail-closed semantics. Concurrent callers share one wait. After
+ * a wait times out (Redis genuinely down) later calls stop waiting until the
+ * client reports `ready` again, so an outage costs one bounded wait instead of
+ * adding `timeoutMs` to every request.
+ */
+export declare function createRedisReadyGate(client: ReadyAwareRedis, timeoutMs?: number): () => Promise<void>;
+/** The subset of ioredis needed by {@link incrWindow}. */
+export interface RedisEvalClient {
+    eval(script: string, numKeys: number, ...args: (string | number)[]): Promise<unknown>;
+}
+/**
+ * Increment `key` within a window of `windowMs` and return the new count.
+ * Throws when Redis errors — callers choose their own failure policy.
+ */
+export declare function incrWindow(redis: RedisEvalClient, key: string, windowMs: number): Promise<number>;