@pipeline-builder/api-core 4.1.1 → 4.1.3

package/lib/services/cache-service.d.ts

@@ -22,7 +22,54 @@ export interface CacheConfig {
     maxEntries?: number;
     /** Optional Redis client — uses in-memory cache if not provided */
     redis?: RedisCacheClient;
+    /**
+     * Cross-replica invalidation bus for the in-memory backend. Omit to use the
+     * shared env-Redis bus (null when Redis isn't configured → single-process
+     * semantics); pass `null` to disable explicitly. Ignored with `redis` (the
+     * store itself is shared, so there is nothing to fan out).
+     */
+    invalidationBus?: CacheInvalidationBus | null;
+}
+/** One invalidation broadcast to every replica. */
+export interface CacheInvalidationMessage {
+    /** Id of the CacheService instance that invalidated (it ignores its own echo). */
+    origin: string;
+    /** The cache namespace (`CacheConfig.prefix`) the invalidation applies to. */
+    prefix: string;
+    op: 'del' | 'pattern' | 'clear';
+    /** Un-prefixed key (`del`) or glob pattern (`pattern`). */
+    key?: string;
+}
+/** Transport that fans cache invalidations out to every replica. */
+export interface CacheInvalidationBus {
+    /** Fire-and-forget broadcast. Never throws. */
+    publish(msg: CacheInvalidationMessage): void;
+    /**
+     * Register handlers. `onMessage` receives every broadcast (including this
+     * process's own); `onResync` fires whenever the subscription is (re)established,
+     * i.e. whenever invalidations may have been missed.
+     */
+    subscribe(onMessage: (msg: CacheInvalidationMessage) => void, onResync: () => void): void;
 }
+/** Minimal ioredis pub/sub surface the env bus needs. */
+export interface RedisInvalidationClient {
+    publish(channel: string, message: string): Promise<number>;
+    subscribe(...channels: string[]): Promise<unknown>;
+    on(event: string, cb: (...args: any[]) => void): unknown;
+    duplicate(): RedisInvalidationClient;
+    status?: string;
+}
+/**
+ * Redis pub/sub invalidation bus. PUBLISH on the given client; SUBSCRIBE on a
+ * `duplicate()` (a subscribed ioredis connection can't run other commands).
+ *
+ * The SUBSCRIBE is issued on every `ready` (initial connect AND each reconnect)
+ * rather than once at construction: the env client runs without an offline
+ * queue, so a subscribe issued before the connection is up is rejected and would
+ * never be retried. Each `ready` also triggers `onResync` so every cache flushes
+ * whatever it may have missed while disconnected.
+ */
+export declare function createRedisCacheInvalidationBus(publisher: RedisInvalidationClient): CacheInvalidationBus;
 /**
  * Cache service with get/set/del operations and automatic TTL expiry.
  *
@@ -55,6 +102,14 @@ export declare class CacheService {
     private readonly defaultTtlMs;
     private readonly maxEntries;
     private readonly redis?;
+    private readonly bus;
+    private readonly instanceId;
+    /**
+     * Bumped on EVERY invalidation (local or remote). `getOrSet` only caches a
+     * factory result if no invalidation happened while the factory ran — otherwise
+     * it could re-cache a value read before the write that invalidated it.
+     */
+    private generation;
     /** Cache metrics — tracks hits, misses, and invalidations. */
     readonly metrics: {
         hits: number;
@@ -63,6 +118,10 @@ export declare class CacheService {
         invalidations: number;
     };
     constructor(config: CacheConfig);
+    /** Broadcast an invalidation to the other replicas (in-memory backend only). */
+    private broadcast;
+    /** Apply an invalidation to THIS process's in-memory entries. Returns the count removed. */
+    private applyLocalInvalidation;
     private fullKey;
     /**
      * Get a cached value. Returns null on miss or error.

package/lib/services/cache-service.js

@@ -1,5 +1,33 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
+/**
+ * Lightweight caching service with TTL support.
+ *
+ * Two implementations:
+ * - In-memory (default): true-LRU Map cache, no external dependencies
+ * - Redis: When a Redis client is provided, uses Redis for cross-process caching
+ *
+ * Cross-replica invalidation (in-memory backend): every service runs several
+ * replicas (HPA), each with its OWN in-memory cache. An invalidation performed on
+ * one pod (`del` / `invalidatePattern` / `clear`) is broadcast over Redis pub/sub
+ * ({@link CacheInvalidationBus}, wired from the ambient Redis env by default) and
+ * applied by every other pod, so a write on pod A can't leave pod B serving the
+ * stale entry until its TTL lapses. A pod whose subscriber (re)connects flushes
+ * its local cache — it may have missed invalidations while disconnected — and a
+ * `getOrSet` whose factory raced an invalidation does not cache its result.
+ *
+ * Design:
+ * - All operations are fail-safe: cache misses/errors return null, never throw
+ * - JSON serialization for Redis; the in-memory backend deep-clones on read so
+ *   both backends return an independent copy (mutating a result is always safe)
+ * - `getOrSet` is single-flight: concurrent misses share one factory() call
+ * - Key namespace prefixing to avoid collisions between services
+ */
+import { randomUUID } from 'crypto';
+import { createEnvRedisClient } from './env-redis.js';
+import { createLogger } from '../utils/logger.js';
+import { emitCounter } from '../utils/metric-emitter.js';
+const logger = createLogger('cache-service');
 /**
  * Deep-clone a value so the in-memory backend hands back an INDEPENDENT copy on
  * every read — matching the Redis backend, which returns a fresh `JSON.parse`
@@ -20,6 +48,87 @@ function cloneValue(value) {
         return JSON.parse(JSON.stringify(value));
     }
 }
+const CACHE_INVALIDATION_CHANNEL = 'cache:invalidate';
+/**
+ * Redis pub/sub invalidation bus. PUBLISH on the given client; SUBSCRIBE on a
+ * `duplicate()` (a subscribed ioredis connection can't run other commands).
+ *
+ * The SUBSCRIBE is issued on every `ready` (initial connect AND each reconnect)
+ * rather than once at construction: the env client runs without an offline
+ * queue, so a subscribe issued before the connection is up is rejected and would
+ * never be retried. Each `ready` also triggers `onResync` so every cache flushes
+ * whatever it may have missed while disconnected.
+ */
+export function createRedisCacheInvalidationBus(publisher) {
+    const subscriber = publisher.duplicate();
+    const messageHandlers = [];
+    const resyncHandlers = [];
+    const resync = () => {
+        for (const h of resyncHandlers) {
+            try {
+                h();
+            }
+            catch { /* isolated */ }
+        }
+    };
+    const doSubscribe = () => {
+        void Promise.resolve(subscriber.subscribe(CACHE_INVALIDATION_CHANNEL))
+            .then(() => resync())
+            .catch((err) => {
+            emitCounter('cache_invalidation_subscribe_failed_total', {});
+            logger.warn('Cache invalidation subscribe failed; will retry on next reconnect', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        });
+    };
+    subscriber.on('message', (channel, raw) => {
+        if (channel !== CACHE_INVALIDATION_CHANNEL)
+            return;
+        let msg;
+        try {
+            msg = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        for (const h of messageHandlers) {
+            try {
+                h(msg);
+            }
+            catch { /* one cache can't break the others */ }
+        }
+    });
+    subscriber.on('ready', doSubscribe);
+    subscriber.on('error', (e) => logger.warn('Cache invalidation subscriber error', { error: e instanceof Error ? e.message : String(e) }));
+    if (subscriber.status === 'ready')
+        doSubscribe();
+    return {
+        publish(msg) {
+            void Promise.resolve()
+                .then(() => publisher.publish(CACHE_INVALIDATION_CHANNEL, JSON.stringify(msg)))
+                .catch((err) => {
+                emitCounter('cache_invalidation_publish_failed_total', { prefix: msg.prefix });
+                logger.warn('Cache invalidation publish failed (other replicas keep the entry until TTL)', {
+                    prefix: msg.prefix, op: msg.op, error: err instanceof Error ? err.message : String(err),
+                });
+            });
+        },
+        subscribe(onMessage, onResync) {
+            messageHandlers.push(onMessage);
+            resyncHandlers.push(onResync);
+        },
+    };
+}
+// undefined = not yet attempted; null = attempted, Redis not configured.
+let envInvalidationBus;
+/** Process-wide invalidation bus from the ambient Redis env (null without Redis). */
+function getEnvCacheInvalidationBus() {
+    if (envInvalidationBus === undefined) {
+        const client = createEnvRedisClient('cache-invalidation');
+        envInvalidationBus = client ? createRedisCacheInvalidationBus(client) : null;
+    }
+    return envInvalidationBus;
+}
 /**
  * Cache service with get/set/del operations and automatic TTL expiry.
  *
@@ -52,6 +161,14 @@ export class CacheService {
     defaultTtlMs;
     maxEntries;
     redis;
+    bus;
+    instanceId = randomUUID();
+    /**
+     * Bumped on EVERY invalidation (local or remote). `getOrSet` only caches a
+     * factory result if no invalidation happened while the factory ran — otherwise
+     * it could re-cache a value read before the write that invalidated it.
+     */
+    generation = 0;
     /** Cache metrics — tracks hits, misses, and invalidations. */
     metrics = { hits: 0, misses: 0, sets: 0, invalidations: 0 };
     constructor(config) {
@@ -59,6 +176,41 @@ export class CacheService {
         this.defaultTtlMs = config.defaultTtlSeconds * 1000;
         this.maxEntries = config.maxEntries ?? 1000;
         this.redis = config.redis;
+        this.bus = this.redis ? null : (config.invalidationBus === undefined ? getEnvCacheInvalidationBus() : config.invalidationBus);
+        this.bus?.subscribe((msg) => {
+            if (msg.origin === this.instanceId || msg.prefix !== this.prefix)
+                return;
+            this.applyLocalInvalidation(msg.op, msg.key);
+        }, () => this.applyLocalInvalidation('clear'));
+    }
+    /** Broadcast an invalidation to the other replicas (in-memory backend only). */
+    broadcast(op, key) {
+        this.bus?.publish({ origin: this.instanceId, prefix: this.prefix, op, ...(key !== undefined && { key }) });
+    }
+    /** Apply an invalidation to THIS process's in-memory entries. Returns the count removed. */
+    applyLocalInvalidation(op, key) {
+        this.generation++;
+        if (op === 'clear') {
+            const n = this.memory.size;
+            this.memory.clear();
+            return n;
+        }
+        if (op === 'del') {
+            return this.memory.delete(this.fullKey(key ?? '')) ? 1 : 0;
+        }
+        // Glob pattern. Escape regex metacharacters first so a literal `.`/`(`/`[`
+        // in a key prefix (e.g. `org:v1.2:*`) can't over-match or throw (a throw
+        // here would leave entries stale); only `*` is treated as a wildcard.
+        const fp = this.fullKey(key ?? '');
+        const regex = new RegExp('^' + fp.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\\\*/g, '.*') + '$');
+        let deleted = 0;
+        for (const k of this.memory.keys()) {
+            if (regex.test(k)) {
+                this.memory.delete(k);
+                deleted++;
+            }
+        }
+        return deleted;
     }
     fullKey(key) {
         return `${this.prefix}${key}`;
@@ -153,7 +305,8 @@ export class CacheService {
                 await this.redis.del(fk);
                 return;
             }
-            this.memory.delete(fk);
+            this.applyLocalInvalidation('del', key);
+            this.broadcast('del', key);
         }
         catch {
             // Cache delete failure is non-fatal
@@ -176,18 +329,9 @@ export class CacheService {
                 }
                 return keys.length;
             }
-            // In-memory — match glob-style pattern. Escape regex metacharacters first
-            // so a literal `.`/`(`/`[` in a key prefix (e.g. `org:v1.2:*`) can't
-            // over-match or throw (a throw here is swallowed → nothing invalidated →
-            // stale reads); only `*` is treated as a wildcard.
-            const regex = new RegExp('^' + fp.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\\\*/g, '.*') + '$');
-            let deleted = 0;
-            for (const key of this.memory.keys()) {
-                if (regex.test(key)) {
-                    this.memory.delete(key);
-                    deleted++;
-                }
-            }
+            // In-memory — apply locally, then fan out to the other replicas.
+            const deleted = this.applyLocalInvalidation('pattern', pattern);
+            this.broadcast('pattern', pattern);
             this.metrics.invalidations += deleted;
             return deleted;
         }
@@ -234,9 +378,13 @@ export class CacheService {
         const existing = this.inflight.get(fk);
         if (existing)
             return cloneValue(await existing);
+        const generationAtStart = this.generation;
         const flight = (async () => {
             const value = await factory();
-            await this.set(key, value, ttlSeconds);
+            // An invalidation (here or on another replica) landed while the factory
+            // ran: its read may predate that write, so don't cache it.
+            if (this.generation === generationAtStart)
+                await this.set(key, value, ttlSeconds);
             return value;
         })();
         this.inflight.set(fk, flight);
@@ -255,7 +403,8 @@ export class CacheService {
             await this.invalidatePattern('*');
         }
         else {
-            this.memory.clear();
+            this.applyLocalInvalidation('clear');
+            this.broadcast('clear');
         }
     }
     /** Current in-memory cache size (for diagnostics). */
@@ -273,4 +422,4 @@ export class CacheService {
 export function createCacheService(prefix, defaultTtlSeconds = 300, redis) {
     return new CacheService({ prefix, defaultTtlSeconds, redis });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache-service.js","sourceRoot":"","sources":["../../src/services/cache-service.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Lightweight caching service with TTL support.\n *\n * Two implementations:\n * - In-memory (default): true-LRU Map cache, no external dependencies\n * - Redis: When a Redis client is provided, uses Redis for cross-process caching\n *\n * Design:\n * - All operations are fail-safe: cache misses/errors return null, never throw\n * - JSON serialization for Redis; the in-memory backend deep-clones on read so\n *   both backends return an independent copy (mutating a result is always safe)\n * - `getOrSet` is single-flight: concurrent misses share one factory() call\n * - Key namespace prefixing to avoid collisions between services\n */\n\n\n/**\n * Cache entry with value and expiration time.\n */\ninterface CacheEntry<T> {\n  value: T;\n  expiresAt: number; // Unix timestamp in ms\n}\n\n/**\n * Deep-clone a value so the in-memory backend hands back an INDEPENDENT copy on\n * every read — matching the Redis backend, which returns a fresh `JSON.parse`\n * clone each time. Without this the in-memory cache returns the same stored\n * object reference, so a consumer mutating a \"cached\" object silently corrupts\n * the shared cache (a footgun that only bites under the memory backend).\n *\n * Primitives are returned as-is. Prefers the structured-clone algorithm; falls\n * back to a JSON round-trip on older runtimes or exotic values.\n */\nfunction cloneValue<T>(value: T): T {\n  if (value === null || typeof value !== 'object') return value;\n  try {\n    return structuredClone(value);\n  } catch {\n    return JSON.parse(JSON.stringify(value)) as T;\n  }\n}\n\n/**\n * Minimal Redis-like client interface (subset of ioredis).\n * Services pass their own Redis client instance.\n */\nexport interface RedisCacheClient {\n  get(key: string): Promise<string | null>;\n  set(key: string, value: string, ...args: unknown[]): Promise<unknown>;\n  del(...keys: string[]): Promise<number>;\n  keys(pattern: string): Promise<string[]>;\n  /** SCAN-based iteration (preferred over KEYS for production). */\n  scanStream?(options: { match: string; count?: number }): NodeJS.ReadableStream;\n}\n\nexport interface CacheConfig {\n  /** Key prefix for namespace isolation (e.g., 'plugin:', 'compliance:') */\n  prefix: string;\n  /** Default TTL in seconds */\n  defaultTtlSeconds: number;\n  /** Max entries for in-memory cache (default 1000) */\n  maxEntries?: number;\n  /** Optional Redis client — uses in-memory cache if not provided */\n  redis?: RedisCacheClient;\n}\n\n/**\n * Cache service with get/set/del operations and automatic TTL expiry.\n *\n * @example\n * ```typescript\n * const cache = new CacheService({ prefix: 'plugin:', defaultTtlSeconds: 300 });\n *\n * // Set with default TTL\n * await cache.set('org123:list', plugins);\n *\n * // Get (returns null on miss)\n * const cached = await cache.get<Plugin[]>('org123:list');\n *\n * // Invalidate\n * await cache.del('org123:list');\n *\n * // Invalidate by pattern\n * await cache.invalidatePattern('org123:*');\n * ```\n */\nexport class CacheService {\n  private memory = new Map<string, CacheEntry<unknown>>();\n  /**\n   * In-flight `getOrSet` factory promises, keyed by full cache key. Coalesces\n   * concurrent cold callers onto a single `factory()` invocation (single-flight\n   * / stampede protection); entries are cleared once the promise settles.\n   */\n  private inflight = new Map<string, Promise<unknown>>();\n  private readonly prefix: string;\n  private readonly defaultTtlMs: number;\n  private readonly maxEntries: number;\n  private readonly redis?: RedisCacheClient;\n\n  /** Cache metrics — tracks hits, misses, and invalidations. */\n  readonly metrics = { hits: 0, misses: 0, sets: 0, invalidations: 0 };\n\n  constructor(config: CacheConfig) {\n    this.prefix = config.prefix;\n    this.defaultTtlMs = config.defaultTtlSeconds * 1000;\n    this.maxEntries = config.maxEntries ?? 1000;\n    this.redis = config.redis;\n  }\n\n  private fullKey(key: string): string {\n    return `${this.prefix}${key}`;\n  }\n\n  /**\n   * Get a cached value. Returns null on miss or error.\n   *\n   * The returned value is an INDEPENDENT deep copy — mutating it never affects\n   * the cached entry (the in-memory backend clones on read for parity with\n   * Redis, which returns a fresh JSON clone). Callers may still treat results as\n   * immutable, but doing so is no longer load-bearing for cache integrity.\n   */\n  async get<T>(key: string): Promise<T | null> {\n    const fk = this.fullKey(key);\n\n    try {\n      if (this.redis) {\n        const raw = await this.redis.get(fk);\n        if (!raw) { this.metrics.misses++; return null; }\n        this.metrics.hits++;\n        return JSON.parse(raw) as T;\n      }\n\n      // In-memory\n      const entry = this.memory.get(fk);\n      if (!entry) { this.metrics.misses++; return null; }\n      if (Date.now() > entry.expiresAt) {\n        this.memory.delete(fk);\n        this.metrics.misses++;\n        return null;\n      }\n      // LRU touch: delete + re-insert moves this key to the newest position\n      // (Map preserves insertion order), so `set`'s oldest-first eviction is a\n      // true least-recently-USED eviction rather than first-inserted (FIFO).\n      this.memory.delete(fk);\n      this.memory.set(fk, entry);\n      this.metrics.hits++;\n      // Clone so a caller mutating the result can't corrupt the shared entry.\n      return cloneValue(entry.value) as T;\n    } catch {\n      this.metrics.misses++;\n      return null;\n    }\n  }\n\n  /**\n   * Set a cached value with optional TTL override.\n   *\n   * @param key - Cache key (prefix is added automatically)\n   * @param value - Value to cache (must be JSON-serializable for Redis)\n   * @param ttlSeconds - TTL override (uses default if not provided)\n   */\n  async set<T>(key: string, value: T, ttlSeconds?: number): Promise<void> {\n    const fk = this.fullKey(key);\n    const ttl = ttlSeconds ?? this.defaultTtlMs / 1000;\n\n    try {\n      this.metrics.sets++;\n      if (this.redis) {\n        await this.redis.set(fk, JSON.stringify(value), 'EX', ttl);\n        return;\n      }\n\n      // In-memory — a write counts as a use, so drop any existing entry first\n      // and re-insert below as the newest (Map preserves insertion order). This\n      // keeps the Map ordered oldest-USED → newest-USED so the eviction below is\n      // true LRU, and avoids evicting a victim when merely updating a key.\n      this.memory.delete(fk);\n      if (this.memory.size >= this.maxEntries) {\n        const firstKey = this.memory.keys().next().value;\n        if (firstKey) this.memory.delete(firstKey);\n      }\n\n      this.memory.set(fk, {\n        value,\n        expiresAt: Date.now() + ttl * 1000,\n      });\n    } catch {\n      // Cache set failure is non-fatal\n    }\n  }\n\n  /**\n   * Delete a cached value.\n   */\n  async del(key: string): Promise<void> {\n    const fk = this.fullKey(key);\n\n    try {\n      if (this.redis) {\n        await this.redis.del(fk);\n        return;\n      }\n      this.memory.delete(fk);\n    } catch {\n      // Cache delete failure is non-fatal\n    }\n  }\n\n  /**\n   * Invalidate all keys matching a pattern (e.g., 'org123:*').\n   * Uses SCAN for Redis (non-blocking) with KEYS fallback, or regex for in-memory.\n   */\n  async invalidatePattern(pattern: string): Promise<number> {\n    const fp = this.fullKey(pattern);\n\n    try {\n      if (this.redis) {\n        const keys = this.redis.scanStream\n          ? await this.scanKeys(fp)\n          : await this.redis.keys(fp);\n        if (keys.length > 0) {\n          await this.redis.del(...keys);\n          this.metrics.invalidations += keys.length;\n        }\n        return keys.length;\n      }\n\n      // In-memory — match glob-style pattern. Escape regex metacharacters first\n      // so a literal `.`/`(`/`[` in a key prefix (e.g. `org:v1.2:*`) can't\n      // over-match or throw (a throw here is swallowed → nothing invalidated →\n      // stale reads); only `*` is treated as a wildcard.\n      const regex = new RegExp('^' + fp.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&').replace(/\\\\\\*/g, '.*') + '$');\n      let deleted = 0;\n      for (const key of this.memory.keys()) {\n        if (regex.test(key)) {\n          this.memory.delete(key);\n          deleted++;\n        }\n      }\n      this.metrics.invalidations += deleted;\n      return deleted;\n    } catch {\n      return 0;\n    }\n  }\n\n  /** Collect keys via Redis SCAN (non-blocking alternative to KEYS). */\n  private scanKeys(pattern: string): Promise<string[]> {\n    return new Promise((resolve, reject) => {\n      const stream = this.redis!.scanStream!({ match: pattern, count: 100 });\n      const keys: string[] = [];\n      stream.on('data', (batch: string[]) => keys.push(...batch));\n      stream.once('end', () => resolve(keys));\n      stream.once('error', reject);\n    });\n  }\n\n  /**\n   * Get or compute: returns cached value if available, otherwise calls the\n   * factory function, caches the result, and returns it.\n   *\n   * Single-flight / stampede protection: when N callers miss concurrently for\n   * the same key, only ONE `factory()` runs — the rest await its shared promise.\n   * The in-flight entry is cleared once it settles (success or failure), so a\n   * failed factory doesn't poison later calls.\n   *\n   * @param key - Cache key\n   * @param factory - Async function to compute the value on cache miss\n   * @param ttlSeconds - Optional TTL override\n   * @returns The cached or computed value\n   */\n  async getOrSet<T>(key: string, factory: () => Promise<T>, ttlSeconds?: number): Promise<T> {\n    const cached = await this.get<T>(key);\n    if (cached !== null) return cached;\n\n    const fk = this.fullKey(key);\n    // Coalesce concurrent cold callers onto a single factory() invocation. The\n    // in-flight promise resolves to the RAW value; each awaiter (the primary\n    // caller below AND every coalesced caller here) clones it INDEPENDENTLY.\n    // Cloning inside the flight instead would hand one shared clone to all N\n    // coalesced callers, so one caller mutating its \"independent\" result would\n    // corrupt what the others read — the exact footgun get()'s clone-on-read\n    // prevents. (Redis backend is unaffected: set serializes, get JSON.parses.)\n    const existing = this.inflight.get(fk) as Promise<T> | undefined;\n    if (existing) return cloneValue(await existing);\n\n    const flight = (async () => {\n      const value = await factory();\n      await this.set(key, value, ttlSeconds);\n      return value;\n    })();\n    this.inflight.set(fk, flight);\n    try {\n      return cloneValue(await flight);\n    } finally {\n      this.inflight.delete(fk);\n    }\n  }\n\n  /**\n   * Clear all entries (useful for testing).\n   */\n  async clear(): Promise<void> {\n    if (this.redis) {\n      await this.invalidatePattern('*');\n    } else {\n      this.memory.clear();\n    }\n  }\n\n  /** Current in-memory cache size (for diagnostics). */\n  get size(): number {\n    return this.memory.size;\n  }\n}\n\n/**\n * Create a cache service instance.\n *\n * @param prefix - Namespace prefix (e.g., 'compliance:', 'plugin:')\n * @param defaultTtlSeconds - Default TTL in seconds (default 300 = 5 min)\n * @param redis - Optional Redis client for cross-process caching\n */\nexport function createCacheService(\n  prefix: string,\n  defaultTtlSeconds = 300,\n  redis?: RedisCacheClient,\n): CacheService {\n  return new CacheService({ prefix, defaultTtlSeconds, redis });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache-service.js","sourceRoot":"","sources":["../../src/services/cache-service.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Lightweight caching service with TTL support.\n *\n * Two implementations:\n * - In-memory (default): true-LRU Map cache, no external dependencies\n * - Redis: When a Redis client is provided, uses Redis for cross-process caching\n *\n * Cross-replica invalidation (in-memory backend): every service runs several\n * replicas (HPA), each with its OWN in-memory cache. An invalidation performed on\n * one pod (`del` / `invalidatePattern` / `clear`) is broadcast over Redis pub/sub\n * ({@link CacheInvalidationBus}, wired from the ambient Redis env by default) and\n * applied by every other pod, so a write on pod A can't leave pod B serving the\n * stale entry until its TTL lapses. A pod whose subscriber (re)connects flushes\n * its local cache — it may have missed invalidations while disconnected — and a\n * `getOrSet` whose factory raced an invalidation does not cache its result.\n *\n * Design:\n * - All operations are fail-safe: cache misses/errors return null, never throw\n * - JSON serialization for Redis; the in-memory backend deep-clones on read so\n *   both backends return an independent copy (mutating a result is always safe)\n * - `getOrSet` is single-flight: concurrent misses share one factory() call\n * - Key namespace prefixing to avoid collisions between services\n */\n\nimport { randomUUID } from 'crypto';\n\nimport { createEnvRedisClient } from './env-redis.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('cache-service');\n\n/**\n * Cache entry with value and expiration time.\n */\ninterface CacheEntry<T> {\n  value: T;\n  expiresAt: number; // Unix timestamp in ms\n}\n\n/**\n * Deep-clone a value so the in-memory backend hands back an INDEPENDENT copy on\n * every read — matching the Redis backend, which returns a fresh `JSON.parse`\n * clone each time. Without this the in-memory cache returns the same stored\n * object reference, so a consumer mutating a \"cached\" object silently corrupts\n * the shared cache (a footgun that only bites under the memory backend).\n *\n * Primitives are returned as-is. Prefers the structured-clone algorithm; falls\n * back to a JSON round-trip on older runtimes or exotic values.\n */\nfunction cloneValue<T>(value: T): T {\n  if (value === null || typeof value !== 'object') return value;\n  try {\n    return structuredClone(value);\n  } catch {\n    return JSON.parse(JSON.stringify(value)) as T;\n  }\n}\n\n/**\n * Minimal Redis-like client interface (subset of ioredis).\n * Services pass their own Redis client instance.\n */\nexport interface RedisCacheClient {\n  get(key: string): Promise<string | null>;\n  set(key: string, value: string, ...args: unknown[]): Promise<unknown>;\n  del(...keys: string[]): Promise<number>;\n  keys(pattern: string): Promise<string[]>;\n  /** SCAN-based iteration (preferred over KEYS for production). */\n  scanStream?(options: { match: string; count?: number }): NodeJS.ReadableStream;\n}\n\nexport interface CacheConfig {\n  /** Key prefix for namespace isolation (e.g., 'plugin:', 'compliance:') */\n  prefix: string;\n  /** Default TTL in seconds */\n  defaultTtlSeconds: number;\n  /** Max entries for in-memory cache (default 1000) */\n  maxEntries?: number;\n  /** Optional Redis client — uses in-memory cache if not provided */\n  redis?: RedisCacheClient;\n  /**\n   * Cross-replica invalidation bus for the in-memory backend. Omit to use the\n   * shared env-Redis bus (null when Redis isn't configured → single-process\n   * semantics); pass `null` to disable explicitly. Ignored with `redis` (the\n   * store itself is shared, so there is nothing to fan out).\n   */\n  invalidationBus?: CacheInvalidationBus | null;\n}\n\n/** One invalidation broadcast to every replica. */\nexport interface CacheInvalidationMessage {\n  /** Id of the CacheService instance that invalidated (it ignores its own echo). */\n  origin: string;\n  /** The cache namespace (`CacheConfig.prefix`) the invalidation applies to. */\n  prefix: string;\n  op: 'del' | 'pattern' | 'clear';\n  /** Un-prefixed key (`del`) or glob pattern (`pattern`). */\n  key?: string;\n}\n\n/** Transport that fans cache invalidations out to every replica. */\nexport interface CacheInvalidationBus {\n  /** Fire-and-forget broadcast. Never throws. */\n  publish(msg: CacheInvalidationMessage): void;\n  /**\n   * Register handlers. `onMessage` receives every broadcast (including this\n   * process's own); `onResync` fires whenever the subscription is (re)established,\n   * i.e. whenever invalidations may have been missed.\n   */\n  subscribe(onMessage: (msg: CacheInvalidationMessage) => void, onResync: () => void): void;\n}\n\n/** Minimal ioredis pub/sub surface the env bus needs. */\nexport interface RedisInvalidationClient {\n  publish(channel: string, message: string): Promise<number>;\n  subscribe(...channels: string[]): Promise<unknown>;\n  on(event: string, cb: (...args: any[]) => void): unknown;\n  duplicate(): RedisInvalidationClient;\n  status?: string;\n}\n\nconst CACHE_INVALIDATION_CHANNEL = 'cache:invalidate';\n\n/**\n * Redis pub/sub invalidation bus. PUBLISH on the given client; SUBSCRIBE on a\n * `duplicate()` (a subscribed ioredis connection can't run other commands).\n *\n * The SUBSCRIBE is issued on every `ready` (initial connect AND each reconnect)\n * rather than once at construction: the env client runs without an offline\n * queue, so a subscribe issued before the connection is up is rejected and would\n * never be retried. Each `ready` also triggers `onResync` so every cache flushes\n * whatever it may have missed while disconnected.\n */\nexport function createRedisCacheInvalidationBus(publisher: RedisInvalidationClient): CacheInvalidationBus {\n  const subscriber = publisher.duplicate();\n  const messageHandlers: Array<(msg: CacheInvalidationMessage) => void> = [];\n  const resyncHandlers: Array<() => void> = [];\n\n  const resync = (): void => {\n    for (const h of resyncHandlers) {\n      try { h(); } catch { /* isolated */ }\n    }\n  };\n  const doSubscribe = (): void => {\n    void Promise.resolve(subscriber.subscribe(CACHE_INVALIDATION_CHANNEL))\n      .then(() => resync())\n      .catch((err: unknown) => {\n        emitCounter('cache_invalidation_subscribe_failed_total', {});\n        logger.warn('Cache invalidation subscribe failed; will retry on next reconnect', {\n          error: err instanceof Error ? err.message : String(err),\n        });\n      });\n  };\n\n  subscriber.on('message', (channel: string, raw: string) => {\n    if (channel !== CACHE_INVALIDATION_CHANNEL) return;\n    let msg: CacheInvalidationMessage;\n    try {\n      msg = JSON.parse(raw) as CacheInvalidationMessage;\n    } catch {\n      return;\n    }\n    for (const h of messageHandlers) {\n      try { h(msg); } catch { /* one cache can't break the others */ }\n    }\n  });\n  subscriber.on('ready', doSubscribe);\n  subscriber.on('error', (e: unknown) =>\n    logger.warn('Cache invalidation subscriber error', { error: e instanceof Error ? e.message : String(e) }));\n  if (subscriber.status === 'ready') doSubscribe();\n\n  return {\n    publish(msg) {\n      void Promise.resolve()\n        .then(() => publisher.publish(CACHE_INVALIDATION_CHANNEL, JSON.stringify(msg)))\n        .catch((err: unknown) => {\n          emitCounter('cache_invalidation_publish_failed_total', { prefix: msg.prefix });\n          logger.warn('Cache invalidation publish failed (other replicas keep the entry until TTL)', {\n            prefix: msg.prefix, op: msg.op, error: err instanceof Error ? err.message : String(err),\n          });\n        });\n    },\n    subscribe(onMessage, onResync) {\n      messageHandlers.push(onMessage);\n      resyncHandlers.push(onResync);\n    },\n  };\n}\n\n// undefined = not yet attempted; null = attempted, Redis not configured.\nlet envInvalidationBus: CacheInvalidationBus | null | undefined;\n\n/** Process-wide invalidation bus from the ambient Redis env (null without Redis). */\nfunction getEnvCacheInvalidationBus(): CacheInvalidationBus | null {\n  if (envInvalidationBus === undefined) {\n    const client = createEnvRedisClient<RedisInvalidationClient>('cache-invalidation');\n    envInvalidationBus = client ? createRedisCacheInvalidationBus(client) : null;\n  }\n  return envInvalidationBus;\n}\n\n/**\n * Cache service with get/set/del operations and automatic TTL expiry.\n *\n * @example\n * ```typescript\n * const cache = new CacheService({ prefix: 'plugin:', defaultTtlSeconds: 300 });\n *\n * // Set with default TTL\n * await cache.set('org123:list', plugins);\n *\n * // Get (returns null on miss)\n * const cached = await cache.get<Plugin[]>('org123:list');\n *\n * // Invalidate\n * await cache.del('org123:list');\n *\n * // Invalidate by pattern\n * await cache.invalidatePattern('org123:*');\n * ```\n */\nexport class CacheService {\n  private memory = new Map<string, CacheEntry<unknown>>();\n  /**\n   * In-flight `getOrSet` factory promises, keyed by full cache key. Coalesces\n   * concurrent cold callers onto a single `factory()` invocation (single-flight\n   * / stampede protection); entries are cleared once the promise settles.\n   */\n  private inflight = new Map<string, Promise<unknown>>();\n  private readonly prefix: string;\n  private readonly defaultTtlMs: number;\n  private readonly maxEntries: number;\n  private readonly redis?: RedisCacheClient;\n  private readonly bus: CacheInvalidationBus | null;\n  private readonly instanceId = randomUUID();\n  /**\n   * Bumped on EVERY invalidation (local or remote). `getOrSet` only caches a\n   * factory result if no invalidation happened while the factory ran — otherwise\n   * it could re-cache a value read before the write that invalidated it.\n   */\n  private generation = 0;\n\n  /** Cache metrics — tracks hits, misses, and invalidations. */\n  readonly metrics = { hits: 0, misses: 0, sets: 0, invalidations: 0 };\n\n  constructor(config: CacheConfig) {\n    this.prefix = config.prefix;\n    this.defaultTtlMs = config.defaultTtlSeconds * 1000;\n    this.maxEntries = config.maxEntries ?? 1000;\n    this.redis = config.redis;\n    this.bus = this.redis ? null : (config.invalidationBus === undefined ? getEnvCacheInvalidationBus() : config.invalidationBus);\n    this.bus?.subscribe(\n      (msg) => {\n        if (msg.origin === this.instanceId || msg.prefix !== this.prefix) return;\n        this.applyLocalInvalidation(msg.op, msg.key);\n      },\n      () => this.applyLocalInvalidation('clear'),\n    );\n  }\n\n  /** Broadcast an invalidation to the other replicas (in-memory backend only). */\n  private broadcast(op: CacheInvalidationMessage['op'], key?: string): void {\n    this.bus?.publish({ origin: this.instanceId, prefix: this.prefix, op, ...(key !== undefined && { key }) });\n  }\n\n  /** Apply an invalidation to THIS process's in-memory entries. Returns the count removed. */\n  private applyLocalInvalidation(op: CacheInvalidationMessage['op'], key?: string): number {\n    this.generation++;\n    if (op === 'clear') {\n      const n = this.memory.size;\n      this.memory.clear();\n      return n;\n    }\n    if (op === 'del') {\n      return this.memory.delete(this.fullKey(key ?? '')) ? 1 : 0;\n    }\n    // Glob pattern. Escape regex metacharacters first so a literal `.`/`(`/`[`\n    // in a key prefix (e.g. `org:v1.2:*`) can't over-match or throw (a throw\n    // here would leave entries stale); only `*` is treated as a wildcard.\n    const fp = this.fullKey(key ?? '');\n    const regex = new RegExp('^' + fp.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&').replace(/\\\\\\*/g, '.*') + '$');\n    let deleted = 0;\n    for (const k of this.memory.keys()) {\n      if (regex.test(k)) {\n        this.memory.delete(k);\n        deleted++;\n      }\n    }\n    return deleted;\n  }\n\n  private fullKey(key: string): string {\n    return `${this.prefix}${key}`;\n  }\n\n  /**\n   * Get a cached value. Returns null on miss or error.\n   *\n   * The returned value is an INDEPENDENT deep copy — mutating it never affects\n   * the cached entry (the in-memory backend clones on read for parity with\n   * Redis, which returns a fresh JSON clone). Callers may still treat results as\n   * immutable, but doing so is no longer load-bearing for cache integrity.\n   */\n  async get<T>(key: string): Promise<T | null> {\n    const fk = this.fullKey(key);\n\n    try {\n      if (this.redis) {\n        const raw = await this.redis.get(fk);\n        if (!raw) { this.metrics.misses++; return null; }\n        this.metrics.hits++;\n        return JSON.parse(raw) as T;\n      }\n\n      // In-memory\n      const entry = this.memory.get(fk);\n      if (!entry) { this.metrics.misses++; return null; }\n      if (Date.now() > entry.expiresAt) {\n        this.memory.delete(fk);\n        this.metrics.misses++;\n        return null;\n      }\n      // LRU touch: delete + re-insert moves this key to the newest position\n      // (Map preserves insertion order), so `set`'s oldest-first eviction is a\n      // true least-recently-USED eviction rather than first-inserted (FIFO).\n      this.memory.delete(fk);\n      this.memory.set(fk, entry);\n      this.metrics.hits++;\n      // Clone so a caller mutating the result can't corrupt the shared entry.\n      return cloneValue(entry.value) as T;\n    } catch {\n      this.metrics.misses++;\n      return null;\n    }\n  }\n\n  /**\n   * Set a cached value with optional TTL override.\n   *\n   * @param key - Cache key (prefix is added automatically)\n   * @param value - Value to cache (must be JSON-serializable for Redis)\n   * @param ttlSeconds - TTL override (uses default if not provided)\n   */\n  async set<T>(key: string, value: T, ttlSeconds?: number): Promise<void> {\n    const fk = this.fullKey(key);\n    const ttl = ttlSeconds ?? this.defaultTtlMs / 1000;\n\n    try {\n      this.metrics.sets++;\n      if (this.redis) {\n        await this.redis.set(fk, JSON.stringify(value), 'EX', ttl);\n        return;\n      }\n\n      // In-memory — a write counts as a use, so drop any existing entry first\n      // and re-insert below as the newest (Map preserves insertion order). This\n      // keeps the Map ordered oldest-USED → newest-USED so the eviction below is\n      // true LRU, and avoids evicting a victim when merely updating a key.\n      this.memory.delete(fk);\n      if (this.memory.size >= this.maxEntries) {\n        const firstKey = this.memory.keys().next().value;\n        if (firstKey) this.memory.delete(firstKey);\n      }\n\n      this.memory.set(fk, {\n        value,\n        expiresAt: Date.now() + ttl * 1000,\n      });\n    } catch {\n      // Cache set failure is non-fatal\n    }\n  }\n\n  /**\n   * Delete a cached value.\n   */\n  async del(key: string): Promise<void> {\n    const fk = this.fullKey(key);\n\n    try {\n      if (this.redis) {\n        await this.redis.del(fk);\n        return;\n      }\n      this.applyLocalInvalidation('del', key);\n      this.broadcast('del', key);\n    } catch {\n      // Cache delete failure is non-fatal\n    }\n  }\n\n  /**\n   * Invalidate all keys matching a pattern (e.g., 'org123:*').\n   * Uses SCAN for Redis (non-blocking) with KEYS fallback, or regex for in-memory.\n   */\n  async invalidatePattern(pattern: string): Promise<number> {\n    const fp = this.fullKey(pattern);\n\n    try {\n      if (this.redis) {\n        const keys = this.redis.scanStream\n          ? await this.scanKeys(fp)\n          : await this.redis.keys(fp);\n        if (keys.length > 0) {\n          await this.redis.del(...keys);\n          this.metrics.invalidations += keys.length;\n        }\n        return keys.length;\n      }\n\n      // In-memory — apply locally, then fan out to the other replicas.\n      const deleted = this.applyLocalInvalidation('pattern', pattern);\n      this.broadcast('pattern', pattern);\n      this.metrics.invalidations += deleted;\n      return deleted;\n    } catch {\n      return 0;\n    }\n  }\n\n  /** Collect keys via Redis SCAN (non-blocking alternative to KEYS). */\n  private scanKeys(pattern: string): Promise<string[]> {\n    return new Promise((resolve, reject) => {\n      const stream = this.redis!.scanStream!({ match: pattern, count: 100 });\n      const keys: string[] = [];\n      stream.on('data', (batch: string[]) => keys.push(...batch));\n      stream.once('end', () => resolve(keys));\n      stream.once('error', reject);\n    });\n  }\n\n  /**\n   * Get or compute: returns cached value if available, otherwise calls the\n   * factory function, caches the result, and returns it.\n   *\n   * Single-flight / stampede protection: when N callers miss concurrently for\n   * the same key, only ONE `factory()` runs — the rest await its shared promise.\n   * The in-flight entry is cleared once it settles (success or failure), so a\n   * failed factory doesn't poison later calls.\n   *\n   * @param key - Cache key\n   * @param factory - Async function to compute the value on cache miss\n   * @param ttlSeconds - Optional TTL override\n   * @returns The cached or computed value\n   */\n  async getOrSet<T>(key: string, factory: () => Promise<T>, ttlSeconds?: number): Promise<T> {\n    const cached = await this.get<T>(key);\n    if (cached !== null) return cached;\n\n    const fk = this.fullKey(key);\n    // Coalesce concurrent cold callers onto a single factory() invocation. The\n    // in-flight promise resolves to the RAW value; each awaiter (the primary\n    // caller below AND every coalesced caller here) clones it INDEPENDENTLY.\n    // Cloning inside the flight instead would hand one shared clone to all N\n    // coalesced callers, so one caller mutating its \"independent\" result would\n    // corrupt what the others read — the exact footgun get()'s clone-on-read\n    // prevents. (Redis backend is unaffected: set serializes, get JSON.parses.)\n    const existing = this.inflight.get(fk) as Promise<T> | undefined;\n    if (existing) return cloneValue(await existing);\n\n    const generationAtStart = this.generation;\n    const flight = (async () => {\n      const value = await factory();\n      // An invalidation (here or on another replica) landed while the factory\n      // ran: its read may predate that write, so don't cache it.\n      if (this.generation === generationAtStart) await this.set(key, value, ttlSeconds);\n      return value;\n    })();\n    this.inflight.set(fk, flight);\n    try {\n      return cloneValue(await flight);\n    } finally {\n      this.inflight.delete(fk);\n    }\n  }\n\n  /**\n   * Clear all entries (useful for testing).\n   */\n  async clear(): Promise<void> {\n    if (this.redis) {\n      await this.invalidatePattern('*');\n    } else {\n      this.applyLocalInvalidation('clear');\n      this.broadcast('clear');\n    }\n  }\n\n  /** Current in-memory cache size (for diagnostics). */\n  get size(): number {\n    return this.memory.size;\n  }\n}\n\n/**\n * Create a cache service instance.\n *\n * @param prefix - Namespace prefix (e.g., 'compliance:', 'plugin:')\n * @param defaultTtlSeconds - Default TTL in seconds (default 300 = 5 min)\n * @param redis - Optional Redis client for cross-process caching\n */\nexport function createCacheService(\n  prefix: string,\n  defaultTtlSeconds = 300,\n  redis?: RedisCacheClient,\n): CacheService {\n  return new CacheService({ prefix, defaultTtlSeconds, redis });\n}\n"]}

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

@@ -104,21 +104,28 @@ export function createRedisDurableEventBus(redis, opts = {}) {
                     }
                 }
             };
+            // 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');
+                    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 {
+                        if (!groupReady)
+                            await ensureGroup();
                         // 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]
@@ -137,6 +144,9 @@ 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));
@@ -201,4 +211,4 @@ export function createEntityEventBusPublisher(bus) {
         },
     };
 }
-//# 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 *    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      // 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 redis.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) 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            // 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      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"]}