@pipeline-builder/api-core 0.0.1

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

@@ -0,0 +1,204 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { createEnvRedisClient } from './env-redis.js';
+import { createLogger } from '../utils/logger.js';
+import { emitCounter } from '../utils/metric-emitter.js';
+const logger = createLogger('durable-event-bus');
+const DEFAULT_MAXLEN = 10_000;
+const DEFAULT_BATCH = 16;
+const DEFAULT_BLOCK_MS = 5_000;
+const DEFAULT_MIN_IDLE_MS = 60_000;
+function errMsg(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function streamKey(topic) {
+    return `evt:${topic}`;
+}
+/** True when the error is Redis' "group already exists" (idempotent create). */
+function isBusyGroup(err) {
+    return errMsg(err).includes('BUSYGROUP');
+}
+/**
+ * Parse the nested array shape XREADGROUP / XAUTOCLAIM return into flat envelopes.
+ * XREADGROUP: `[[streamKey, [[id, [f, v, ...]], ...]]]`.
+ * XAUTOCLAIM: `[nextCursor, [[id, [f, v, ...]], ...], deletedIds]`.
+ * We store the JSON payload under a single field `d`.
+ */
+function parseEntries(topic, entries) {
+    const out = [];
+    if (!Array.isArray(entries))
+        return out;
+    for (const entry of entries) {
+        if (!Array.isArray(entry) || entry.length < 2)
+            continue;
+        const id = String(entry[0]);
+        const fields = entry[1];
+        if (!Array.isArray(fields))
+            continue;
+        // fields is [name, value, name, value, ...]; find 'd'.
+        let raw;
+        for (let i = 0; i + 1 < fields.length; i += 2) {
+            if (String(fields[i]) === 'd') {
+                raw = String(fields[i + 1]);
+                break;
+            }
+        }
+        // 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.
+        if (raw === undefined) {
+            out.push({ id, topic, payload: undefined });
+            continue;
+        }
+        try {
+            out.push({ id, topic, payload: JSON.parse(raw) });
+        }
+        catch {
+            out.push({ id, topic, payload: undefined });
+        }
+    }
+    return out;
+}
+/** Build a durable event bus over a Redis Streams client. */
+export function createRedisDurableEventBus(redis, opts = {}) {
+    const maxLen = Math.max(1, opts.maxLen ?? DEFAULT_MAXLEN);
+    return {
+        async publish(topic, payload) {
+            const key = streamKey(topic);
+            try {
+                // MAXLEN ~ <n> bounds the stream approximately (cheap); `*` = server id.
+                const id = await redis.xadd(key, 'MAXLEN', '~', maxLen, '*', 'd', JSON.stringify(payload));
+                emitCounter('event_bus_published_total', { topic });
+                return id;
+            }
+            catch (err) {
+                emitCounter('event_bus_publish_failed_total', { topic });
+                logger.warn('Event bus publish failed (event dropped)', { topic, error: errMsg(err) });
+                return null;
+            }
+        },
+        subscribe(subOpts) {
+            const { topic, group, consumer, handler } = subOpts;
+            const key = streamKey(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);
+            let stopped = false;
+            let started = false;
+            const deliver = async (envs) => {
+                for (const env of envs) {
+                    try {
+                        if (env.payload !== undefined)
+                            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);
+                        emitCounter('event_bus_delivered_total', { topic, group });
+                    }
+                    catch (err) {
+                        // Leave it pending (no XACK) — XAUTOCLAIM redelivers it after minIdle.
+                        emitCounter('event_bus_handler_failed_total', { topic, group });
+                        logger.warn('Event handler failed; leaving message pending for redelivery', {
+                            topic, group, id: env.id, error: errMsg(err),
+                        });
+                    }
+                }
+            };
+            const ensureGroup = async () => {
+                try {
+                    // MKSTREAM so the stream need not exist yet; '$' = only new messages.
+                    await redis.xgroup('CREATE', key, group, '$', 'MKSTREAM');
+                }
+                catch (err) {
+                    if (!isBusyGroup(err)) {
+                        logger.warn('Event bus group create failed', { topic, group, error: errMsg(err) });
+                    }
+                }
+            };
+            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);
+                        // XAUTOCLAIM reply: [nextCursor, entries, deletedIds]
+                        if (Array.isArray(claimed) && claimed.length >= 2) {
+                            await deliver(parseEntries(topic, claimed[1]));
+                        }
+                        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, '>');
+                        // 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]));
+                        }
+                    }
+                    catch (err) {
+                        if (stopped)
+                            break;
+                        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 });
+            }
+            return {
+                async stop() {
+                    stopped = true;
+                    // Await the in-flight read/handler so a caller (e.g. a service shutting
+                    // 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);
+                },
+            };
+        },
+    };
+}
+/**
+ * Build a durable event bus from the ambient Redis env via the shared
+ * `createEnvRedisClient`. Returns `null` when Redis is not configured — the
+ * caller then runs without a bus (today's HTTP/reconciler behavior), never
+ * crashing. Opt in with a single boot line where a service wants durable events.
+ */
+export function createEnvRedisDurableEventBus(opts = {}) {
+    const inst = createEnvRedisClient('event-bus');
+    if (!inst)
+        return null;
+    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"]}

package/lib/services/entity-events.d.ts

@@ -0,0 +1,48 @@
+export type EntityEventType = 'created' | 'updated' | 'deleted';
+export type EntityTarget = 'plugin' | 'pipeline' | 'message' | 'organization' | 'user';
+export interface EntityEvent {
+    /** The type of mutation that occurred */
+    eventType: EntityEventType;
+    /** The entity type that was mutated */
+    target: EntityTarget;
+    /** The entity's unique ID */
+    entityId: string;
+    /** The organization that owns this entity */
+    orgId: string;
+    /** Org → team hierarchy: the owning org's parent (present only when `orgId` is
+     *  a team). Lets compliance evaluate parent `propagateToChildren` rules on the
+     *  async event path, matching live validation. */
+    parentOrgId?: string;
+    /** The user who performed the mutation */
+    userId: string;
+    /** When the event occurred */
+    timestamp: Date;
+    /** Snapshot of entity attributes (for compliance evaluation) */
+    attributes: Record<string, unknown>;
+}
+export interface EntityEventSubscriber {
+    onEntityEvent(event: EntityEvent): Promise<void>;
+}
+declare class EntityEventEmitter {
+    private subscribers;
+    /**
+     * Register a subscriber to receive entity events.
+     */
+    subscribe(subscriber: EntityEventSubscriber): void;
+    /**
+     * Remove a subscriber.
+     */
+    unsubscribe(subscriber: EntityEventSubscriber): void;
+    /**
+     * Emit an entity event to all subscribers.
+     * Fire-and-forget: errors are caught and logged, never thrown.
+     */
+    emit(event: EntityEvent): void;
+    /**
+     * Get the current subscriber count (for testing/diagnostics).
+     */
+    get subscriberCount(): number;
+}
+/** Singleton entity event emitter — shared across the process */
+export declare const entityEvents: EntityEventEmitter;
+export {};

package/lib/services/entity-events.js

@@ -0,0 +1,79 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Lightweight in-process event emitter for entity lifecycle events.
+ *
+ * Services emit events after mutations (create/update/delete) via CrudService hooks.
+ * Subscribers react asynchronously to entity changes.
+ *
+ * Active subscribers:
+ * - **Compliance event subscriber** (`registerComplianceEventSubscriber()`) — forwards
+ *   entity events to the compliance service for post-mutation rule evaluation.
+ *   Registered at startup in plugin and pipeline service index.ts.
+ *
+ * Design:
+ * - Fire-and-forget: emit() never throws, subscriber errors are logged
+ * - In-process only: no network, no Redis, no infrastructure
+ * - Subscribers run async: never block the original request
+ *
+ * Durability contract (deliberately BEST-EFFORT):
+ * - The post-mutation compliance evaluation this feeds is NOT the enforcement
+ *   gate — LIVE validation on the mutation path already enforces compliance
+ *   before the write commits. This async fan-out is a convenience/reporting
+ *   signal, so a lost delivery (subscriber throw, process crash mid-callback)
+ *   downgrades timeliness, not correctness. Backing it with the durable Redis
+ *   spool would pull network/infra into a module whose whole point is to have
+ *   none, for no enforcement benefit — so instead a dropped delivery is made
+ *   OBSERVABLE via the `entity_event_subscriber_failed_total` counter (alert on
+ *   a sustained rate) rather than silently swallowed at debug level.
+ */
+import { createLogger } from '../utils/logger.js';
+import { emitCounter } from '../utils/metric-emitter.js';
+const logger = createLogger('entity-events');
+class EntityEventEmitter {
+    subscribers = [];
+    /**
+     * Register a subscriber to receive entity events.
+     */
+    subscribe(subscriber) {
+        this.subscribers.push(subscriber);
+    }
+    /**
+     * Remove a subscriber.
+     */
+    unsubscribe(subscriber) {
+        this.subscribers = this.subscribers.filter((s) => s !== subscriber);
+    }
+    /**
+     * Emit an entity event to all subscribers.
+     * Fire-and-forget: errors are caught and logged, never thrown.
+     */
+    emit(event) {
+        for (const subscriber of this.subscribers) {
+            subscriber.onEntityEvent(event).catch((err) => {
+                // Make the drop observable — a lost async compliance eval is best-effort
+                // (live validation already enforced), but a sustained failure rate is an
+                // operational signal, not something to bury at debug level.
+                emitCounter('entity_event_subscriber_failed_total', {
+                    target: event.target,
+                    eventType: event.eventType,
+                });
+                logger.debug('Entity event subscriber failed', {
+                    target: event.target,
+                    eventType: event.eventType,
+                    entityId: event.entityId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            });
+        }
+    }
+    /**
+     * Get the current subscriber count (for testing/diagnostics).
+     */
+    get subscriberCount() {
+        return this.subscribers.length;
+    }
+}
+/** Singleton entity event emitter — shared across the process */
+export const entityEvents = new EntityEventEmitter();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,44 @@
+/**
+ * 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).
+ */
+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.
+ */
+export declare function createEnvRedisClient<T = unknown>(label: string): T | null;

package/lib/services/env-redis.js

@@ -0,0 +1,94 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { createRequire } from 'module';
+import { createLogger } from '../utils/logger.js';
+const logger = createLogger('env-redis');
+/**
+ * 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).
+ */
+export function parseSentinels(raw) {
+    if (!raw)
+        return [];
+    return raw.split(',').map((s) => s.trim()).filter(Boolean).map((entry) => {
+        const [host, port] = entry.split(':');
+        return { host, port: parseInt(port ?? '26379', 10) || 26379 };
+    }).filter((s) => !!s.host);
+}
+/**
+ * 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.
+ */
+export function createEnvRedisClient(label) {
+    try {
+        const sentinels = parseSentinels(process.env.REDIS_SENTINELS);
+        const url = process.env.REDIS_URL;
+        const host = process.env.REDIS_HOST;
+        if (sentinels.length === 0 && !url && !host)
+            return null;
+        const req = createRequire(import.meta.url);
+        const mod = req('ioredis');
+        const RedisCtor = (mod.Redis ?? mod.default ?? mod);
+        const redisOpts = { maxRetriesPerRequest: 1, enableOfflineQueue: false };
+        if (process.env.REDIS_PASSWORD)
+            redisOpts.password = process.env.REDIS_PASSWORD;
+        let inst;
+        if (sentinels.length > 0) {
+            // Sentinel mode: ioredis tracks the master via the sentinels + auto-fails-over.
+            const sentinelOpts = {
+                sentinels,
+                name: process.env.REDIS_SENTINEL_MASTER || 'mymaster',
+                ...redisOpts,
+            };
+            if (process.env.REDIS_SENTINEL_PASSWORD)
+                sentinelOpts.sentinelPassword = process.env.REDIS_SENTINEL_PASSWORD;
+            inst = new RedisCtor(sentinelOpts);
+            logger.info(`Redis ${label}: Sentinel mode`, { master: sentinelOpts.name, sentinels: sentinels.length });
+        }
+        else if (url) {
+            inst = new RedisCtor(url, redisOpts);
+        }
+        else {
+            inst = new RedisCtor({ host, port: parseInt(process.env.REDIS_PORT ?? '6379', 10), ...redisOpts });
+        }
+        inst
+            .on('error', (e) => logger.warn(`Redis ${label} client error`, { error: e instanceof Error ? e.message : String(e) }));
+        return inst;
+    }
+    catch (err) {
+        logger.warn(`Redis unavailable for ${label}`, { error: err instanceof Error ? err.message : String(err) });
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"env-redis.js","sourceRoot":"","sources":["../../src/services/env-redis.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createRequire } from 'module';\n\nimport { createLogger } from '../utils/logger.js';\n\nconst logger = createLogger('env-redis');\n\n/**\n * Parse `REDIS_SENTINELS` (comma-separated `host:port` list) into the ioredis\n * `{ host, port }[]` sentinel array. Blank/garbage entries are skipped; a\n * missing port defaults to the Sentinel default 26379. Returns an empty array\n * when the env is unset/empty (→ non-sentinel mode).\n */\nexport function parseSentinels(raw: string | undefined): Array<{ host: string; port: number }> {\n  if (!raw) return [];\n  return raw.split(',').map((s) => s.trim()).filter(Boolean).map((entry) => {\n    const [host, port] = entry.split(':');\n    return { host, port: parseInt(port ?? '26379', 10) || 26379 };\n  }).filter((s) => !!s.host);\n}\n\n/**\n * Construct an ioredis client from the standard `REDIS_URL` or\n * `REDIS_HOST`/`REDIS_PORT` env — OR, for HA, from Redis Sentinel via\n * `REDIS_SENTINELS` + `REDIS_SENTINEL_MASTER`. The shared construction was\n * previously duplicated across the leader-lock, audit-spool, and\n * token-revocation env factories.\n *\n * Connection modes (first that matches wins):\n * 1. SENTINEL — `REDIS_SENTINELS` set (comma-separated `host:port`): ioredis\n *    resolves the current master from the sentinels (`name` = `REDIS_SENTINEL_MASTER`,\n *    default `mymaster`) and transparently reconnects to the new master after a\n *    failover. This is how the app gets HA against a single-node Redis loss —\n *    also the shape a managed ElastiCache (cluster-mode-disabled) speaks.\n * 2. URL — `REDIS_URL`.\n * 3. HOST/PORT — `REDIS_HOST`(+`REDIS_PORT`).\n *\n * Semantics every caller relies on (kept identical across the consolidation):\n * - Returns `null` when NONE of sentinels/url/host is set, so a caller degrades\n *   to its no-Redis fallback (run-on-every-pod / best-effort / fail-open).\n * - FAIL-SAFE: any ioredis load or construction error is swallowed and returns\n *   `null` — Redis being unavailable must never crash the importing service.\n * - `ioredis` is a runtime-only optional dep loaded via `createRequire`, so this\n *   module stays importable in CJS bundles and where Redis isn't installed.\n * - `maxRetriesPerRequest: 1` + `enableOfflineQueue: false`: commands fail fast\n *   rather than queueing during an outage (callers are fail-open/best-effort).\n * - An `error` listener is attached (ioredis auto-reconnects) so a dropped\n *   connection can't surface as an unhandled `'error'` event that crashes Node.\n *\n * Optional auth: `REDIS_PASSWORD` (data-node AUTH) and `REDIS_SENTINEL_PASSWORD`\n * (sentinel AUTH, sentinel mode only) are threaded through when set.\n *\n * @param label short human name for this client, used in the two warn logs.\n */\nexport function createEnvRedisClient<T = unknown>(label: string): T | null {\n  try {\n    const sentinels = parseSentinels(process.env.REDIS_SENTINELS);\n    const url = process.env.REDIS_URL;\n    const host = process.env.REDIS_HOST;\n    if (sentinels.length === 0 && !url && !host) return null;\n    const req = createRequire(import.meta.url);\n    const mod = req('ioredis') as {\n      Redis?: new (...args: unknown[]) => unknown;\n      default?: new (...args: unknown[]) => unknown;\n    };\n    const RedisCtor = (mod.Redis ?? mod.default ?? mod) as new (...args: unknown[]) => T;\n    const redisOpts: Record<string, unknown> = { maxRetriesPerRequest: 1, enableOfflineQueue: false };\n    if (process.env.REDIS_PASSWORD) redisOpts.password = process.env.REDIS_PASSWORD;\n\n    let inst: T;\n    if (sentinels.length > 0) {\n      // Sentinel mode: ioredis tracks the master via the sentinels + auto-fails-over.\n      const sentinelOpts: Record<string, unknown> = {\n        sentinels,\n        name: process.env.REDIS_SENTINEL_MASTER || 'mymaster',\n        ...redisOpts,\n      };\n      if (process.env.REDIS_SENTINEL_PASSWORD) sentinelOpts.sentinelPassword = process.env.REDIS_SENTINEL_PASSWORD;\n      inst = new RedisCtor(sentinelOpts);\n      logger.info(`Redis ${label}: Sentinel mode`, { master: sentinelOpts.name, sentinels: sentinels.length });\n    } else if (url) {\n      inst = new RedisCtor(url, redisOpts);\n    } else {\n      inst = new RedisCtor({ host, port: parseInt(process.env.REDIS_PORT ?? '6379', 10), ...redisOpts });\n    }\n    (inst as unknown as { on: (evt: string, cb: (e: unknown) => void) => void })\n      .on('error', (e) => logger.warn(`Redis ${label} client error`, { error: e instanceof Error ? e.message : String(e) }));\n    return inst;\n  } catch (err) {\n    logger.warn(`Redis unavailable for ${label}`, { error: err instanceof Error ? err.message : String(err) });\n    return null;\n  }\n}\n"]}