@pipeline-builder/api-core 4.1.2 → 4.1.4

package/lib/services/audit-spool.js

@@ -156,10 +156,9 @@ export function createRedisAuditSpool(redis, opts = {}) {
     };
 }
 /**
- * Build a Redis-backed audit spool from the ambient `REDIS_URL` / `REDIS_HOST`
+ * Build a Redis-backed audit spool from the ambient `REDIS_URL` / `REDIS_SENTINELS`
  * env via the shared `createEnvRedisClient`. Returns `null` when Redis is not
- * configured or the client can't be constructed — the caller then runs without a
- * spool (pre-spool best-effort behavior), never crashing. The shared helper loads
+ * configured — the caller then runs without a spool (best-effort behavior). The shared helper loads
  * ioredis via `createRequire`, so this stays importable where Redis isn't present.
  */
 export function createEnvRedisAuditSpool(opts = {}) {
@@ -169,4 +168,4 @@ export function createEnvRedisAuditSpool(opts = {}) {
     logger.info('Redis audit spool initialized');
     return createRedisAuditSpool(inst, opts);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"audit-spool.js","sourceRoot":"","sources":["../../src/services/audit-spool.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createEnvRedisClient } from './env-redis.js';\nimport type { RemoteAuditEvent } from './remote-audit-client.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('audit-spool');\n\n/** A buffered emission: the event plus which service must re-deliver it. */\nexport interface AuditSpoolEntry {\n  event: RemoteAuditEvent;\n  serviceName: string;\n}\n\n/**\n * Durable buffer for audit events that failed LIVE delivery to the platform\n * (retries exhausted during a sustained outage). Without this, the audit trail —\n * a security log — is silently lost the moment the platform is down for longer\n * than the client's small retry budget.\n *\n * Contract:\n * - BOUNDED. A security log must degrade to \"dropped the oldest, loudly\" (a\n *   metric) rather than grow without limit and OOM the emitter.\n * - FAIL-SAFE. Every method swallows its own errors — a broken/unreachable spool\n *   must never break or block the audit emission path (which is itself\n *   fire-and-forget). A spool problem degrades to the pre-spool behavior.\n * - Ordering is best-effort. Re-delivered events chain at re-delivery time\n *   (that's when the platform inserts them), so each event also carries an\n *   `occurredAt` stamped at emission for reviewers — see RemoteAuditEvent.\n */\nexport interface AuditSpool {\n  /** Buffer an event that failed live delivery. */\n  enqueue(entry: AuditSpoolEntry): Promise<void>;\n  /**\n   * Atomically MOVE up to `max` buffered entries onto an in-progress list and\n   * return them. Because the entries are moved (not popped-and-dropped), a crash\n   * mid-drain leaves them recoverable on the in-progress list — see `recover`.\n   * Each taken entry MUST be resolved with exactly one of `ack` (delivered) or\n   * `requeue` (still failing), or it lingers on the in-progress list until the\n   * next `recover`.\n   */\n  take(max: number): Promise<AuditSpoolEntry[]>;\n  /** Acknowledge successfully re-delivered entries — removes them from the\n   *  in-progress list so they are not recovered again. */\n  ack(entries: AuditSpoolEntry[]): Promise<void>;\n  /** Return entries whose re-delivery failed to the HEAD of the buffer (retried\n   *  first) and clear them from the in-progress list. Best-effort. */\n  requeue(entries: AuditSpoolEntry[]): Promise<void>;\n  /** Reclaim any entries stranded on the in-progress list by a prior crash,\n   *  moving them back to the head of the main buffer. Call once at startup.\n   *  Returns the number reclaimed. */\n  recover(): Promise<number>;\n  /** Approximate current depth (for metrics / drain decisions). */\n  depth(): Promise<number>;\n}\n\n/** Minimal Redis LIST surface the spool needs (a subset of ioredis). */\ninterface RedisListClient {\n  rpush(key: string, ...values: string[]): Promise<number>;\n  lpush(key: string, ...values: string[]): Promise<number>;\n  lpop(key: string, count: number): Promise<string[] | null>;\n  ltrim(key: string, start: number, stop: number): Promise<unknown>;\n  llen(key: string): Promise<number>;\n  /** Atomically pop from one list end and push to another (Redis ≥ 6.2). */\n  lmove(source: string, destination: string, from: 'LEFT' | 'RIGHT', to: 'LEFT' | 'RIGHT'): Promise<string | null>;\n  /** Remove `count` occurrences of `value` from a list. */\n  lrem(key: string, count: number, value: string): Promise<number>;\n}\n\nconst DEFAULT_SPOOL_KEY = 'audit:spool';\nconst DEFAULT_MAX_DEPTH = 10_000;\n/** Guard so a pathological in-progress list can't spin `recover`/`take` forever. */\nconst MAX_MOVE_ITERATIONS = 100_000;\n\nfunction errMsg(err: unknown): string {\n  return err instanceof Error ? err.message : String(err);\n}\n\nfunction safeParse(raw: string): AuditSpoolEntry | null {\n  try {\n    const parsed = JSON.parse(raw) as AuditSpoolEntry;\n    return parsed && parsed.event && parsed.serviceName ? parsed : null;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Redis-LIST-backed spool. Durable across process restarts (unlike an in-memory\n * or per-pod-disk buffer), shared by all replicas of a service, and bounded via\n * a trim-to-tail on overflow (drops the OLDEST, emitting `audit_spool_dropped_total`).\n */\nexport function createRedisAuditSpool(\n  redis: RedisListClient,\n  opts: { maxDepth?: number; key?: string } = {},\n): AuditSpool {\n  const key = opts.key ?? DEFAULT_SPOOL_KEY;\n  // The in-progress \"processing\" list — a taken batch lives here until it is\n  // acked (delivered) or requeued (still failing). It is a security log's\n  // durability net: a crash between take and ack/requeue leaves the batch here,\n  // and `recover` reclaims it on restart instead of silently losing it.\n  const inProgressKey = `${key}:inflight`;\n  const maxDepth = Math.max(1, opts.maxDepth ?? DEFAULT_MAX_DEPTH);\n\n  // The EXACT serialized string each returned entry was parsed from, so `ack` /\n  // `requeue` can LREM the precise value off the in-progress list. Keyed by the\n  // returned object identity (the drain consumer passes the SAME objects back),\n  // so it needs no stable re-serialization. WeakMap → entries GC naturally.\n  const rawByEntry = new WeakMap<AuditSpoolEntry, string>();\n  const rawOf = (entry: AuditSpoolEntry): string => rawByEntry.get(entry) ?? JSON.stringify(entry);\n\n  return {\n    async enqueue(entry) {\n      try {\n        const len = await redis.rpush(key, JSON.stringify(entry));\n        emitCounter('audit_spool_enqueued_total', { service: entry.serviceName });\n        if (len > maxDepth) {\n          // Keep only the newest `maxDepth`; drop the overflow at the head.\n          const dropped = len - maxDepth;\n          await redis.ltrim(key, dropped, -1);\n          emitCounter('audit_spool_dropped_total', { service: entry.serviceName }, dropped);\n          logger.warn('Audit spool overflow — dropped oldest buffered events', { dropped, maxDepth });\n        }\n      } catch (err) {\n        logger.warn('Audit spool enqueue failed (event lost)', { error: errMsg(err) });\n      }\n    },\n\n    async take(max) {\n      try {\n        const out: AuditSpoolEntry[] = [];\n        const limit = Math.max(1, max);\n        for (let i = 0; i < limit; i++) {\n          // Atomically MOVE head→in-progress-tail so the entry is never in limbo:\n          // it is on exactly one list at all times, recoverable after a crash.\n          const raw = await redis.lmove(key, inProgressKey, 'LEFT', 'RIGHT');\n          if (raw === null || raw === undefined) break;\n          const parsed = safeParse(raw);\n          if (parsed) {\n            rawByEntry.set(parsed, raw);\n            out.push(parsed);\n          } else {\n            // Corrupt payload — drop it off the in-progress list so it can't wedge\n            // the drain, and account for it.\n            await redis.lrem(inProgressKey, 1, raw);\n            emitCounter('audit_spool_dropped_total', { service: 'unknown' });\n          }\n        }\n        return out;\n      } catch (err) {\n        logger.warn('Audit spool take failed', { error: errMsg(err) });\n        return [];\n      }\n    },\n\n    async ack(entries) {\n      if (entries.length === 0) return;\n      try {\n        for (const entry of entries) {\n          await redis.lrem(inProgressKey, 1, rawOf(entry));\n          rawByEntry.delete(entry);\n        }\n      } catch (err) {\n        logger.warn('Audit spool ack failed (may re-deliver on recover)', { error: errMsg(err) });\n      }\n    },\n\n    async requeue(entries) {\n      if (entries.length === 0) return;\n      try {\n        // Put failed re-deliveries back at the HEAD so they're retried first and\n        // rough emission order is preserved across the outage — and clear them\n        // from the in-progress list so `recover` doesn't double them. Iterate in\n        // reverse so lpush restores the batch's original order at the head.\n        //\n        // ORDERING INVARIANT (at-least-once): lpush to the main list FIRST, THEN\n        // lrem from in-progress. A crash between the two leaves the entry on BOTH\n        // lists → harmless double-delivery (deduped downstream by idempotency\n        // reuse), never a LOSS. The reverse order (lrem then lpush) would drop the\n        // event outright on a crash in the gap, which a security log must not do.\n        for (let i = entries.length - 1; i >= 0; i--) {\n          const raw = rawOf(entries[i]);\n          await redis.lpush(key, raw);\n          await redis.lrem(inProgressKey, 1, raw);\n          rawByEntry.delete(entries[i]);\n        }\n      } catch (err) {\n        logger.warn('Audit spool requeue failed (events lost)', { error: errMsg(err) });\n      }\n    },\n\n    async recover() {\n      try {\n        let reclaimed = 0;\n        for (let i = 0; i < MAX_MOVE_ITERATIONS; i++) {\n          // Move in-progress-tail → main-head: an older stranded entry (nearer the\n          // in-progress head) ends up ahead of a newer one, preserving order.\n          const raw = await redis.lmove(inProgressKey, key, 'RIGHT', 'LEFT');\n          if (raw === null || raw === undefined) break;\n          reclaimed++;\n        }\n        if (reclaimed > 0) {\n          emitCounter('audit_spool_recovered_total', {}, reclaimed);\n          logger.warn('Audit spool recovered stranded in-progress events', { reclaimed });\n        }\n        return reclaimed;\n      } catch (err) {\n        logger.warn('Audit spool recover failed', { error: errMsg(err) });\n        return 0;\n      }\n    },\n\n    async depth() {\n      try {\n        return await redis.llen(key);\n      } catch {\n        return 0;\n      }\n    },\n  };\n}\n\n/**\n * Build a Redis-backed audit spool from the ambient `REDIS_URL` / `REDIS_HOST`\n * env via the shared `createEnvRedisClient`. Returns `null` when Redis is not\n * configured or the client can't be constructed — the caller then runs without a\n * spool (pre-spool best-effort behavior), never crashing. The shared helper loads\n * ioredis via `createRequire`, so this stays importable where Redis isn't present.\n */\nexport function createEnvRedisAuditSpool(opts: { maxDepth?: number; key?: string } = {}): AuditSpool | null {\n  const inst = createEnvRedisClient<RedisListClient>('audit-spool');\n  if (!inst) return null;\n  logger.info('Redis audit spool initialized');\n  return createRedisAuditSpool(inst, opts);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"audit-spool.js","sourceRoot":"","sources":["../../src/services/audit-spool.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createEnvRedisClient } from './env-redis.js';\nimport type { RemoteAuditEvent } from './remote-audit-client.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('audit-spool');\n\n/** A buffered emission: the event plus which service must re-deliver it. */\nexport interface AuditSpoolEntry {\n  event: RemoteAuditEvent;\n  serviceName: string;\n}\n\n/**\n * Durable buffer for audit events that failed LIVE delivery to the platform\n * (retries exhausted during a sustained outage). Without this, the audit trail —\n * a security log — is silently lost the moment the platform is down for longer\n * than the client's small retry budget.\n *\n * Contract:\n * - BOUNDED. A security log must degrade to \"dropped the oldest, loudly\" (a\n *   metric) rather than grow without limit and OOM the emitter.\n * - FAIL-SAFE. Every method swallows its own errors — a broken/unreachable spool\n *   must never break or block the audit emission path (which is itself\n *   fire-and-forget). A spool problem degrades to the pre-spool behavior.\n * - Ordering is best-effort. Re-delivered events chain at re-delivery time\n *   (that's when the platform inserts them), so each event also carries an\n *   `occurredAt` stamped at emission for reviewers — see RemoteAuditEvent.\n */\nexport interface AuditSpool {\n  /** Buffer an event that failed live delivery. */\n  enqueue(entry: AuditSpoolEntry): Promise<void>;\n  /**\n   * Atomically MOVE up to `max` buffered entries onto an in-progress list and\n   * return them. Because the entries are moved (not popped-and-dropped), a crash\n   * mid-drain leaves them recoverable on the in-progress list — see `recover`.\n   * Each taken entry MUST be resolved with exactly one of `ack` (delivered) or\n   * `requeue` (still failing), or it lingers on the in-progress list until the\n   * next `recover`.\n   */\n  take(max: number): Promise<AuditSpoolEntry[]>;\n  /** Acknowledge successfully re-delivered entries — removes them from the\n   *  in-progress list so they are not recovered again. */\n  ack(entries: AuditSpoolEntry[]): Promise<void>;\n  /** Return entries whose re-delivery failed to the HEAD of the buffer (retried\n   *  first) and clear them from the in-progress list. Best-effort. */\n  requeue(entries: AuditSpoolEntry[]): Promise<void>;\n  /** Reclaim any entries stranded on the in-progress list by a prior crash,\n   *  moving them back to the head of the main buffer. Call once at startup.\n   *  Returns the number reclaimed. */\n  recover(): Promise<number>;\n  /** Approximate current depth (for metrics / drain decisions). */\n  depth(): Promise<number>;\n}\n\n/** Minimal Redis LIST surface the spool needs (a subset of ioredis). */\ninterface RedisListClient {\n  rpush(key: string, ...values: string[]): Promise<number>;\n  lpush(key: string, ...values: string[]): Promise<number>;\n  lpop(key: string, count: number): Promise<string[] | null>;\n  ltrim(key: string, start: number, stop: number): Promise<unknown>;\n  llen(key: string): Promise<number>;\n  /** Atomically pop from one list end and push to another (Redis ≥ 6.2). */\n  lmove(source: string, destination: string, from: 'LEFT' | 'RIGHT', to: 'LEFT' | 'RIGHT'): Promise<string | null>;\n  /** Remove `count` occurrences of `value` from a list. */\n  lrem(key: string, count: number, value: string): Promise<number>;\n}\n\nconst DEFAULT_SPOOL_KEY = 'audit:spool';\nconst DEFAULT_MAX_DEPTH = 10_000;\n/** Guard so a pathological in-progress list can't spin `recover`/`take` forever. */\nconst MAX_MOVE_ITERATIONS = 100_000;\n\nfunction errMsg(err: unknown): string {\n  return err instanceof Error ? err.message : String(err);\n}\n\nfunction safeParse(raw: string): AuditSpoolEntry | null {\n  try {\n    const parsed = JSON.parse(raw) as AuditSpoolEntry;\n    return parsed && parsed.event && parsed.serviceName ? parsed : null;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Redis-LIST-backed spool. Durable across process restarts (unlike an in-memory\n * or per-pod-disk buffer), shared by all replicas of a service, and bounded via\n * a trim-to-tail on overflow (drops the OLDEST, emitting `audit_spool_dropped_total`).\n */\nexport function createRedisAuditSpool(\n  redis: RedisListClient,\n  opts: { maxDepth?: number; key?: string } = {},\n): AuditSpool {\n  const key = opts.key ?? DEFAULT_SPOOL_KEY;\n  // The in-progress \"processing\" list — a taken batch lives here until it is\n  // acked (delivered) or requeued (still failing). It is a security log's\n  // durability net: a crash between take and ack/requeue leaves the batch here,\n  // and `recover` reclaims it on restart instead of silently losing it.\n  const inProgressKey = `${key}:inflight`;\n  const maxDepth = Math.max(1, opts.maxDepth ?? DEFAULT_MAX_DEPTH);\n\n  // The EXACT serialized string each returned entry was parsed from, so `ack` /\n  // `requeue` can LREM the precise value off the in-progress list. Keyed by the\n  // returned object identity (the drain consumer passes the SAME objects back),\n  // so it needs no stable re-serialization. WeakMap → entries GC naturally.\n  const rawByEntry = new WeakMap<AuditSpoolEntry, string>();\n  const rawOf = (entry: AuditSpoolEntry): string => rawByEntry.get(entry) ?? JSON.stringify(entry);\n\n  return {\n    async enqueue(entry) {\n      try {\n        const len = await redis.rpush(key, JSON.stringify(entry));\n        emitCounter('audit_spool_enqueued_total', { service: entry.serviceName });\n        if (len > maxDepth) {\n          // Keep only the newest `maxDepth`; drop the overflow at the head.\n          const dropped = len - maxDepth;\n          await redis.ltrim(key, dropped, -1);\n          emitCounter('audit_spool_dropped_total', { service: entry.serviceName }, dropped);\n          logger.warn('Audit spool overflow — dropped oldest buffered events', { dropped, maxDepth });\n        }\n      } catch (err) {\n        logger.warn('Audit spool enqueue failed (event lost)', { error: errMsg(err) });\n      }\n    },\n\n    async take(max) {\n      try {\n        const out: AuditSpoolEntry[] = [];\n        const limit = Math.max(1, max);\n        for (let i = 0; i < limit; i++) {\n          // Atomically MOVE head→in-progress-tail so the entry is never in limbo:\n          // it is on exactly one list at all times, recoverable after a crash.\n          const raw = await redis.lmove(key, inProgressKey, 'LEFT', 'RIGHT');\n          if (raw === null || raw === undefined) break;\n          const parsed = safeParse(raw);\n          if (parsed) {\n            rawByEntry.set(parsed, raw);\n            out.push(parsed);\n          } else {\n            // Corrupt payload — drop it off the in-progress list so it can't wedge\n            // the drain, and account for it.\n            await redis.lrem(inProgressKey, 1, raw);\n            emitCounter('audit_spool_dropped_total', { service: 'unknown' });\n          }\n        }\n        return out;\n      } catch (err) {\n        logger.warn('Audit spool take failed', { error: errMsg(err) });\n        return [];\n      }\n    },\n\n    async ack(entries) {\n      if (entries.length === 0) return;\n      try {\n        for (const entry of entries) {\n          await redis.lrem(inProgressKey, 1, rawOf(entry));\n          rawByEntry.delete(entry);\n        }\n      } catch (err) {\n        logger.warn('Audit spool ack failed (may re-deliver on recover)', { error: errMsg(err) });\n      }\n    },\n\n    async requeue(entries) {\n      if (entries.length === 0) return;\n      try {\n        // Put failed re-deliveries back at the HEAD so they're retried first and\n        // rough emission order is preserved across the outage — and clear them\n        // from the in-progress list so `recover` doesn't double them. Iterate in\n        // reverse so lpush restores the batch's original order at the head.\n        //\n        // ORDERING INVARIANT (at-least-once): lpush to the main list FIRST, THEN\n        // lrem from in-progress. A crash between the two leaves the entry on BOTH\n        // lists → harmless double-delivery (deduped downstream by idempotency\n        // reuse), never a LOSS. The reverse order (lrem then lpush) would drop the\n        // event outright on a crash in the gap, which a security log must not do.\n        for (let i = entries.length - 1; i >= 0; i--) {\n          const raw = rawOf(entries[i]);\n          await redis.lpush(key, raw);\n          await redis.lrem(inProgressKey, 1, raw);\n          rawByEntry.delete(entries[i]);\n        }\n      } catch (err) {\n        logger.warn('Audit spool requeue failed (events lost)', { error: errMsg(err) });\n      }\n    },\n\n    async recover() {\n      try {\n        let reclaimed = 0;\n        for (let i = 0; i < MAX_MOVE_ITERATIONS; i++) {\n          // Move in-progress-tail → main-head: an older stranded entry (nearer the\n          // in-progress head) ends up ahead of a newer one, preserving order.\n          const raw = await redis.lmove(inProgressKey, key, 'RIGHT', 'LEFT');\n          if (raw === null || raw === undefined) break;\n          reclaimed++;\n        }\n        if (reclaimed > 0) {\n          emitCounter('audit_spool_recovered_total', {}, reclaimed);\n          logger.warn('Audit spool recovered stranded in-progress events', { reclaimed });\n        }\n        return reclaimed;\n      } catch (err) {\n        logger.warn('Audit spool recover failed', { error: errMsg(err) });\n        return 0;\n      }\n    },\n\n    async depth() {\n      try {\n        return await redis.llen(key);\n      } catch {\n        return 0;\n      }\n    },\n  };\n}\n\n/**\n * Build a Redis-backed audit spool from the ambient `REDIS_URL` / `REDIS_SENTINELS`\n * env via the shared `createEnvRedisClient`. Returns `null` when Redis is not\n * configured — the caller then runs without a spool (best-effort behavior). The shared helper loads\n * ioredis via `createRequire`, so this stays importable where Redis isn't present.\n */\nexport function createEnvRedisAuditSpool(opts: { maxDepth?: number; key?: string } = {}): AuditSpool | null {\n  const inst = createEnvRedisClient<RedisListClient>('audit-spool');\n  if (!inst) return null;\n  logger.info('Redis audit spool initialized');\n  return createRedisAuditSpool(inst, opts);\n}\n"]}

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

@@ -1,28 +1,66 @@
 /**
- * Minimal Redis-like client interface (subset of ioredis).
- * Services pass their own Redis client instance.
+ * Minimal Redis key/value client surface (subset of ioredis) shared by the
+ * token-revocation publisher/reader and platform's Redis helpers.
  */
 export interface RedisCacheClient {
     get(key: string): Promise<string | null>;
     set(key: string, value: string, ...args: unknown[]): Promise<unknown>;
     del(...keys: string[]): Promise<number>;
-    keys(pattern: string): Promise<string[]>;
-    /** SCAN-based iteration (preferred over KEYS for production). */
-    scanStream?(options: {
-        match: string;
-        count?: number;
-    }): NodeJS.ReadableStream;
 }
 export interface CacheConfig {
     /** Key prefix for namespace isolation (e.g., 'plugin:', 'compliance:') */
     prefix: string;
     /** Default TTL in seconds */
     defaultTtlSeconds: number;
-    /** Max entries for in-memory cache (default 1000) */
+    /** Max entries for the cache (default 1000) */
     maxEntries?: number;
-    /** Optional Redis client — uses in-memory cache if not provided */
-    redis?: RedisCacheClient;
+    /**
+     * Cross-replica invalidation bus. Omit to use the shared env-Redis bus (null
+     * when Redis isn't configured → single-process semantics); pass `null` to
+     * disable explicitly.
+     */
+    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.
  *
@@ -54,7 +92,14 @@ export declare class CacheService {
     private readonly prefix;
     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,21 +108,23 @@ export declare class CacheService {
         invalidations: number;
     };
     constructor(config: CacheConfig);
+    /** Broadcast an invalidation to the other replicas. */
+    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.
      *
      * The returned value is an INDEPENDENT deep copy — mutating it never affects
-     * the cached entry (the in-memory backend clones on read for parity with
-     * Redis, which returns a fresh JSON clone). Callers may still treat results as
-     * immutable, but doing so is no longer load-bearing for cache integrity.
+     * the cached entry.
      */
     get<T>(key: string): Promise<T | null>;
     /**
      * Set a cached value with optional TTL override.
      *
      * @param key - Cache key (prefix is added automatically)
-     * @param value - Value to cache (must be JSON-serializable for Redis)
+     * @param value - Value to cache
      * @param ttlSeconds - TTL override (uses default if not provided)
      */
     set<T>(key: string, value: T, ttlSeconds?: number): Promise<void>;
@@ -87,11 +134,9 @@ export declare class CacheService {
     del(key: string): Promise<void>;
     /**
      * Invalidate all keys matching a pattern (e.g., 'org123:*').
-     * Uses SCAN for Redis (non-blocking) with KEYS fallback, or regex for in-memory.
+     * Only `*` is a wildcard.
      */
     invalidatePattern(pattern: string): Promise<number>;
-    /** Collect keys via Redis SCAN (non-blocking alternative to KEYS). */
-    private scanKeys;
     /**
      * Get or compute: returns cached value if available, otherwise calls the
      * factory function, caches the result, and returns it.
@@ -119,6 +164,5 @@ export declare class CacheService {
  *
  * @param prefix - Namespace prefix (e.g., 'compliance:', 'plugin:')
  * @param defaultTtlSeconds - Default TTL in seconds (default 300 = 5 min)
- * @param redis - Optional Redis client for cross-process caching
  */
-export declare function createCacheService(prefix: string, defaultTtlSeconds?: number, redis?: RedisCacheClient): CacheService;
+export declare function createCacheService(prefix: string, defaultTtlSeconds?: number): CacheService;