@pipeline-builder/api-core 4.1.12 → 4.1.14

package/lib/services/audit-spool.d.ts

@@ -38,10 +38,17 @@ export interface AuditSpool {
     /** Return entries whose re-delivery failed to the HEAD of the buffer (retried
      *  first) and clear them from the in-progress list. Best-effort. */
     requeue(entries: AuditSpoolEntry[]): Promise<void>;
-    /** Reclaim any entries stranded on the in-progress list by a prior crash,
-     *  moving them back to the head of the main buffer. Call once at startup.
-     *  Returns the number reclaimed. */
+    /**
+     * Reclaim entries stranded on ABANDONED in-progress lists — those of owners
+     * (spool instances, i.e. pods) whose heartbeat is older than the stale
+     * threshold — moving them back to the head of the main buffer. A LIVE owner's
+     * in-flight batch is never touched, so a peer's recover can't duplicate work
+     * that owner is still delivering. Safe to call periodically; returns the
+     * number reclaimed.
+     */
     recover(): Promise<number>;
+    /** Mark this owner alive (so no peer reclaims its in-flight batch). */
+    heartbeat(): Promise<void>;
     /** Approximate current depth (for metrics / drain decisions). */
     depth(): Promise<number>;
 }
@@ -56,24 +63,41 @@ interface RedisListClient {
     lmove(source: string, destination: string, from: 'LEFT' | 'RIGHT', to: 'LEFT' | 'RIGHT'): Promise<string | null>;
     /** Remove `count` occurrences of `value` from a list. */
     lrem(key: string, count: number, value: string): Promise<number>;
+    /** Owner heartbeats: a sorted set of owner id → last-seen epoch ms. */
+    zadd(key: string, score: number, member: string): Promise<unknown>;
+    zrangebyscore(key: string, min: number | string, max: number | string): Promise<string[]>;
+    zrem(key: string, member: string): Promise<number>;
 }
+/**
+ * The spool key for one service's buffered audit events. Per SERVICE on
+ * purpose: re-delivery mints a service token as `entry.serviceName`, which only
+ * that service's pods can sign (per-service keys). A shared key let a pod of
+ * one service take another's entries, fail to sign for them, and requeue them
+ * forever — while that service's own pods never saw them.
+ */
+export declare function auditSpoolKey(serviceName: string): string;
 /**
  * Redis-LIST-backed spool. Durable across process restarts (unlike an in-memory
  * or per-pod-disk buffer), shared by all replicas of a service, and bounded via
  * a trim-to-tail on overflow (drops the OLDEST, emitting `audit_spool_dropped_total`).
  */
-export declare function createRedisAuditSpool(redis: RedisListClient, opts?: {
+export interface RedisAuditSpoolOptions {
+    /** The buffer's Redis key — one per service ({@link auditSpoolKey}). */
+    key: string;
     maxDepth?: number;
-    key?: string;
-}): AuditSpool;
+    /** This instance's owner id (default: random per instance). */
+    ownerId?: string;
+    /** Heartbeat age after which an owner's in-flight batch is reclaimable. */
+    staleOwnerMs?: number;
+    /** Awaited before each command — e.g. a readiness gate for a lazily connecting client. */
+    ready?: () => Promise<void>;
+}
+export declare function createRedisAuditSpool(redis: RedisListClient, opts: RedisAuditSpoolOptions): AuditSpool;
 /**
  * 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 — 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 declare function createEnvRedisAuditSpool(opts?: {
-    maxDepth?: number;
-    key?: string;
-}): AuditSpool | null;
+export declare function createEnvRedisAuditSpool(opts: Omit<RedisAuditSpoolOptions, 'ready'>): AuditSpool | null;
 export {};

package/lib/services/audit-spool.js

@@ -1,17 +1,26 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
-import { createEnvRedisClient } from './env-redis.js';
+import { randomUUID } from 'crypto';
+import { createEnvRedisClient, createRedisReadyGate } from './env-redis.js';
 import { createLogger } from '../utils/logger.js';
 import { emitCounter } from '../utils/metric-emitter.js';
 import { errorMessage } from '../utils/response.js';
 const logger = createLogger('audit-spool');
-const DEFAULT_SPOOL_KEY = 'audit:spool';
+/**
+ * The spool key for one service's buffered audit events. Per SERVICE on
+ * purpose: re-delivery mints a service token as `entry.serviceName`, which only
+ * that service's pods can sign (per-service keys). A shared key let a pod of
+ * one service take another's entries, fail to sign for them, and requeue them
+ * forever — while that service's own pods never saw them.
+ */
+export function auditSpoolKey(serviceName) {
+    return `audit:spool:${serviceName}`;
+}
 const DEFAULT_MAX_DEPTH = 10_000;
+/** An owner whose heartbeat is older than this is presumed dead (its pod crashed). */
+const DEFAULT_STALE_OWNER_MS = 10 * 60_000;
 /** Guard so a pathological in-progress list can't spin `recover`/`take` forever. */
 const MAX_MOVE_ITERATIONS = 100_000;
-function errMsg(err) {
-    return errorMessage(err);
-}
 function safeParse(raw) {
     try {
         const parsed = JSON.parse(raw);
@@ -21,19 +30,24 @@ function safeParse(raw) {
         return null;
     }
 }
-/**
- * Redis-LIST-backed spool. Durable across process restarts (unlike an in-memory
- * or per-pod-disk buffer), shared by all replicas of a service, and bounded via
- * a trim-to-tail on overflow (drops the OLDEST, emitting `audit_spool_dropped_total`).
- */
-export function createRedisAuditSpool(redis, opts = {}) {
-    const key = opts.key ?? DEFAULT_SPOOL_KEY;
-    // The in-progress "processing" list — a taken batch lives here until it is
-    // acked (delivered) or requeued (still failing). It is a security log's
-    // durability net: a crash between take and ack/requeue leaves the batch here,
-    // and `recover` reclaims it on restart instead of silently losing it.
-    const inProgressKey = `${key}:inflight`;
+export function createRedisAuditSpool(redis, opts) {
+    const key = opts.key;
+    const ownerId = opts.ownerId ?? randomUUID();
+    const staleOwnerMs = Math.max(1, opts.staleOwnerMs ?? DEFAULT_STALE_OWNER_MS);
+    const ready = opts.ready ?? (() => Promise.resolve());
+    // PER-OWNER in-progress list — a taken batch lives here until it is acked
+    // (delivered) or requeued (still failing). It is a security log's durability
+    // net: a crash between take and ack/requeue leaves the batch here, and a peer's
+    // (or this pod's successor's) `recover` reclaims it once the owner's heartbeat
+    // goes stale. One shared in-flight list let any replica's startup recover
+    // steal batches its live siblings were mid-way through delivering.
+    const inflightKeyOf = (owner) => `${key}:inflight:${owner}`;
+    const inProgressKey = inflightKeyOf(ownerId);
+    const ownersKey = `${key}:owners`;
     const maxDepth = Math.max(1, opts.maxDepth ?? DEFAULT_MAX_DEPTH);
+    const beat = async () => {
+        await redis.zadd(ownersKey, Date.now(), ownerId);
+    };
     // The EXACT serialized string each returned entry was parsed from, so `ack` /
     // `requeue` can LREM the precise value off the in-progress list. Keyed by the
     // returned object identity (the drain consumer passes the SAME objects back),
@@ -43,6 +57,7 @@ export function createRedisAuditSpool(redis, opts = {}) {
     return {
         async enqueue(entry) {
             try {
+                await ready();
                 const len = await redis.rpush(key, JSON.stringify(entry));
                 emitCounter('audit_spool_enqueued_total', { service: entry.serviceName });
                 if (len > maxDepth) {
@@ -54,11 +69,13 @@ export function createRedisAuditSpool(redis, opts = {}) {
                 }
             }
             catch (err) {
-                logger.warn('Audit spool enqueue failed (event lost)', { error: errMsg(err) });
+                logger.warn('Audit spool enqueue failed (event lost)', { error: errorMessage(err) });
             }
         },
         async take(max) {
             try {
+                await ready();
+                await beat();
                 const out = [];
                 const limit = Math.max(1, max);
                 for (let i = 0; i < limit; i++) {
@@ -82,7 +99,7 @@ export function createRedisAuditSpool(redis, opts = {}) {
                 return out;
             }
             catch (err) {
-                logger.warn('Audit spool take failed', { error: errMsg(err) });
+                logger.warn('Audit spool take failed', { error: errorMessage(err) });
                 return [];
             }
         },
@@ -90,13 +107,14 @@ export function createRedisAuditSpool(redis, opts = {}) {
             if (entries.length === 0)
                 return;
             try {
+                await ready();
                 for (const entry of entries) {
                     await redis.lrem(inProgressKey, 1, rawOf(entry));
                     rawByEntry.delete(entry);
                 }
             }
             catch (err) {
-                logger.warn('Audit spool ack failed (may re-deliver on recover)', { error: errMsg(err) });
+                logger.warn('Audit spool ack failed (may re-deliver on recover)', { error: errorMessage(err) });
             }
         },
         async requeue(entries) {
@@ -113,6 +131,7 @@ export function createRedisAuditSpool(redis, opts = {}) {
                 // lists → harmless double-delivery (deduped downstream by idempotency
                 // reuse), never a LOSS. The reverse order (lrem then lpush) would drop the
                 // event outright on a crash in the gap, which a security log must not do.
+                await ready();
                 for (let i = entries.length - 1; i >= 0; i--) {
                     const raw = rawOf(entries[i]);
                     await redis.lpush(key, raw);
@@ -121,31 +140,50 @@ export function createRedisAuditSpool(redis, opts = {}) {
                 }
             }
             catch (err) {
-                logger.warn('Audit spool requeue failed (events lost)', { error: errMsg(err) });
+                logger.warn('Audit spool requeue failed (events lost)', { error: errorMessage(err) });
             }
         },
         async recover() {
             try {
+                await ready();
+                await beat();
                 let reclaimed = 0;
-                for (let i = 0; i < MAX_MOVE_ITERATIONS; i++) {
-                    // Move in-progress-tail → main-head: an older stranded entry (nearer the
-                    // in-progress head) ends up ahead of a newer one, preserving order.
-                    const raw = await redis.lmove(inProgressKey, key, 'RIGHT', 'LEFT');
-                    if (raw === null || raw === undefined)
-                        break;
-                    reclaimed++;
+                const stale = await redis.zrangebyscore(ownersKey, '-inf', Date.now() - staleOwnerMs);
+                for (const owner of stale) {
+                    if (owner === ownerId)
+                        continue;
+                    const source = inflightKeyOf(owner);
+                    for (let i = 0; i < MAX_MOVE_ITERATIONS; i++) {
+                        // Move in-progress-tail → main-head: an older stranded entry (nearer
+                        // the in-progress head) ends up ahead of a newer one, preserving order.
+                        const raw = await redis.lmove(source, key, 'RIGHT', 'LEFT');
+                        if (raw === null || raw === undefined)
+                            break;
+                        reclaimed++;
+                    }
+                    // Only forget the owner once its list is empty.
+                    await redis.zrem(ownersKey, owner);
                 }
                 if (reclaimed > 0) {
                     emitCounter('audit_spool_recovered_total', {}, reclaimed);
-                    logger.warn('Audit spool recovered stranded in-progress events', { reclaimed });
+                    logger.warn('Audit spool recovered events stranded by a dead owner', { reclaimed });
                 }
                 return reclaimed;
             }
             catch (err) {
-                logger.warn('Audit spool recover failed', { error: errMsg(err) });
+                logger.warn('Audit spool recover failed', { error: errorMessage(err) });
                 return 0;
             }
         },
+        async heartbeat() {
+            try {
+                await ready();
+                await beat();
+            }
+            catch (err) {
+                logger.debug('Audit spool heartbeat failed', { error: errorMessage(err) });
+            }
+        },
         async depth() {
             try {
                 return await redis.llen(key);
@@ -162,11 +200,14 @@ export function createRedisAuditSpool(redis, opts = {}) {
  * 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 = {}) {
+export function createEnvRedisAuditSpool(opts) {
     const inst = createEnvRedisClient('audit-spool');
     if (!inst)
         return null;
-    logger.info('Redis audit spool initialized');
-    return createRedisAuditSpool(inst, opts);
+    logger.info('Redis audit spool initialized', { key: opts.key });
+    // The env client has no offline queue: a boot-time recover() run before the
+    // connection is up would fail and strand batches until the next restart, so
+    // every command waits (bounded) for readiness.
+    return createRedisAuditSpool(inst, { ...opts, ready: createRedisReadyGate(inst, 10_000) });
 }
-//# 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';\nimport { errorMessage } from '../utils/response.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 errorMessage(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"]}
+//# 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 { randomUUID } from 'crypto';\nimport { createEnvRedisClient, createRedisReadyGate, type ReadyAwareRedis } 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';\nimport { errorMessage } from '../utils/response.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  /**\n   * Reclaim entries stranded on ABANDONED in-progress lists — those of owners\n   * (spool instances, i.e. pods) whose heartbeat is older than the stale\n   * threshold — moving them back to the head of the main buffer. A LIVE owner's\n   * in-flight batch is never touched, so a peer's recover can't duplicate work\n   * that owner is still delivering. Safe to call periodically; returns the\n   * number reclaimed.\n   */\n  recover(): Promise<number>;\n  /** Mark this owner alive (so no peer reclaims its in-flight batch). */\n  heartbeat(): Promise<void>;\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  /** Owner heartbeats: a sorted set of owner id → last-seen epoch ms. */\n  zadd(key: string, score: number, member: string): Promise<unknown>;\n  zrangebyscore(key: string, min: number | string, max: number | string): Promise<string[]>;\n  zrem(key: string, member: string): Promise<number>;\n}\n\n/**\n * The spool key for one service's buffered audit events. Per SERVICE on\n * purpose: re-delivery mints a service token as `entry.serviceName`, which only\n * that service's pods can sign (per-service keys). A shared key let a pod of\n * one service take another's entries, fail to sign for them, and requeue them\n * forever — while that service's own pods never saw them.\n */\nexport function auditSpoolKey(serviceName: string): string {\n  return `audit:spool:${serviceName}`;\n}\n\nconst DEFAULT_MAX_DEPTH = 10_000;\n/** An owner whose heartbeat is older than this is presumed dead (its pod crashed). */\nconst DEFAULT_STALE_OWNER_MS = 10 * 60_000;\n/** Guard so a pathological in-progress list can't spin `recover`/`take` forever. */\nconst MAX_MOVE_ITERATIONS = 100_000;\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 interface RedisAuditSpoolOptions {\n  /** The buffer's Redis key — one per service ({@link auditSpoolKey}). */\n  key: string;\n  maxDepth?: number;\n  /** This instance's owner id (default: random per instance). */\n  ownerId?: string;\n  /** Heartbeat age after which an owner's in-flight batch is reclaimable. */\n  staleOwnerMs?: number;\n  /** Awaited before each command — e.g. a readiness gate for a lazily connecting client. */\n  ready?: () => Promise<void>;\n}\n\nexport function createRedisAuditSpool(redis: RedisListClient, opts: RedisAuditSpoolOptions): AuditSpool {\n  const key = opts.key;\n  const ownerId = opts.ownerId ?? randomUUID();\n  const staleOwnerMs = Math.max(1, opts.staleOwnerMs ?? DEFAULT_STALE_OWNER_MS);\n  const ready = opts.ready ?? (() => Promise.resolve());\n  // PER-OWNER in-progress list — a taken batch lives here until it is acked\n  // (delivered) or requeued (still failing). It is a security log's durability\n  // net: a crash between take and ack/requeue leaves the batch here, and a peer's\n  // (or this pod's successor's) `recover` reclaims it once the owner's heartbeat\n  // goes stale. One shared in-flight list let any replica's startup recover\n  // steal batches its live siblings were mid-way through delivering.\n  const inflightKeyOf = (owner: string) => `${key}:inflight:${owner}`;\n  const inProgressKey = inflightKeyOf(ownerId);\n  const ownersKey = `${key}:owners`;\n  const maxDepth = Math.max(1, opts.maxDepth ?? DEFAULT_MAX_DEPTH);\n\n  const beat = async (): Promise<void> => {\n    await redis.zadd(ownersKey, Date.now(), ownerId);\n  };\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        await ready();\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: errorMessage(err) });\n      }\n    },\n\n    async take(max) {\n      try {\n        await ready();\n        await beat();\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: errorMessage(err) });\n        return [];\n      }\n    },\n\n    async ack(entries) {\n      if (entries.length === 0) return;\n      try {\n        await ready();\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: errorMessage(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        await ready();\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: errorMessage(err) });\n      }\n    },\n\n    async recover() {\n      try {\n        await ready();\n        await beat();\n        let reclaimed = 0;\n        const stale = await redis.zrangebyscore(ownersKey, '-inf', Date.now() - staleOwnerMs);\n        for (const owner of stale) {\n          if (owner === ownerId) continue;\n          const source = inflightKeyOf(owner);\n          for (let i = 0; i < MAX_MOVE_ITERATIONS; i++) {\n            // Move in-progress-tail → main-head: an older stranded entry (nearer\n            // the in-progress head) ends up ahead of a newer one, preserving order.\n            const raw = await redis.lmove(source, key, 'RIGHT', 'LEFT');\n            if (raw === null || raw === undefined) break;\n            reclaimed++;\n          }\n          // Only forget the owner once its list is empty.\n          await redis.zrem(ownersKey, owner);\n        }\n        if (reclaimed > 0) {\n          emitCounter('audit_spool_recovered_total', {}, reclaimed);\n          logger.warn('Audit spool recovered events stranded by a dead owner', { reclaimed });\n        }\n        return reclaimed;\n      } catch (err) {\n        logger.warn('Audit spool recover failed', { error: errorMessage(err) });\n        return 0;\n      }\n    },\n\n    async heartbeat() {\n      try {\n        await ready();\n        await beat();\n      } catch (err) {\n        logger.debug('Audit spool heartbeat failed', { error: errorMessage(err) });\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: Omit<RedisAuditSpoolOptions, 'ready'>): AuditSpool | null {\n  const inst = createEnvRedisClient<RedisListClient & ReadyAwareRedis>('audit-spool');\n  if (!inst) return null;\n  logger.info('Redis audit spool initialized', { key: opts.key });\n  // The env client has no offline queue: a boot-time recover() run before the\n  // connection is up would fail and strand batches until the next restart, so\n  // every command waits (bounded) for readiness.\n  return createRedisAuditSpool(inst, { ...opts, ready: createRedisReadyGate(inst, 10_000) });\n}\n"]}

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

@@ -6,6 +6,13 @@ export interface RedisCacheClient {
     get(key: string): Promise<string | null>;
     set(key: string, value: string, ...args: unknown[]): Promise<unknown>;
     del(...keys: string[]): Promise<number>;
+    /**
+     * Server-side Lua (ioredis `eval(script, numKeys, ...keysAndArgs)`). Optional
+     * so a plain key/value fake still satisfies the interface; the writers that
+     * need atomic compare-and-set (e.g. `publishTokenRevocation`) refuse a client
+     * without it rather than fall back to a racy read-modify-write.
+     */
+    eval?(script: string, numKeys: number, ...args: Array<string | number>): Promise<unknown>;
 }
 export interface CacheConfig {
     /** Key prefix for namespace isolation (e.g., 'plugin:', 'compliance:') */

package/lib/services/cache-service.js

@@ -369,4 +369,4 @@ export class CacheService {
 export function createCacheService(prefix, defaultTtlSeconds = 300) {
     return new CacheService({ prefix, defaultTtlSeconds });
 }
-//# 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 * Storage is a per-process true-LRU Map (no external dependencies).\n *\n * Cross-replica invalidation: 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 * - Reads deep-clone, so every caller gets an independent copy (mutating a\n *   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';\nimport { errorMessage } from '../utils/response.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 cache hands back an INDEPENDENT copy on every read.\n * Without this it returns the same stored object reference, so a consumer\n * mutating a \"cached\" object silently corrupts the shared cache.\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 key/value client surface (subset of ioredis) shared by the\n * token-revocation publisher/reader and platform's Redis helpers.\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}\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 the cache (default 1000) */\n  maxEntries?: number;\n  /**\n   * Cross-replica invalidation bus. Omit to use the shared env-Redis bus (null\n   * when Redis isn't configured → single-process semantics); pass `null` to\n   * disable explicitly.\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: errorMessage(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: errorMessage(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: errorMessage(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 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.bus = 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. */\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.\n   */\n  async get<T>(key: string): Promise<T | null> {\n    const fk = this.fullKey(key);\n\n    try {\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\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      // 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    try {\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   * Only `*` is a wildcard.\n   */\n  async invalidatePattern(pattern: string): Promise<number> {\n    try {\n      // 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  /**\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.\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    this.applyLocalInvalidation('clear');\n    this.broadcast('clear');\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 */\nexport function createCacheService(prefix: string, defaultTtlSeconds = 300): CacheService {\n  return new CacheService({ prefix, defaultTtlSeconds });\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 * Storage is a per-process true-LRU Map (no external dependencies).\n *\n * Cross-replica invalidation: 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 * - Reads deep-clone, so every caller gets an independent copy (mutating a\n *   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';\nimport { errorMessage } from '../utils/response.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 cache hands back an INDEPENDENT copy on every read.\n * Without this it returns the same stored object reference, so a consumer\n * mutating a \"cached\" object silently corrupts the shared cache.\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 key/value client surface (subset of ioredis) shared by the\n * token-revocation publisher/reader and platform's Redis helpers.\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  /**\n   * Server-side Lua (ioredis `eval(script, numKeys, ...keysAndArgs)`). Optional\n   * so a plain key/value fake still satisfies the interface; the writers that\n   * need atomic compare-and-set (e.g. `publishTokenRevocation`) refuse a client\n   * without it rather than fall back to a racy read-modify-write.\n   */\n  eval?(script: string, numKeys: number, ...args: Array<string | number>): Promise<unknown>;\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 the cache (default 1000) */\n  maxEntries?: number;\n  /**\n   * Cross-replica invalidation bus. Omit to use the shared env-Redis bus (null\n   * when Redis isn't configured → single-process semantics); pass `null` to\n   * disable explicitly.\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: errorMessage(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: errorMessage(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: errorMessage(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 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.bus = 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. */\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.\n   */\n  async get<T>(key: string): Promise<T | null> {\n    const fk = this.fullKey(key);\n\n    try {\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\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      // 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    try {\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   * Only `*` is a wildcard.\n   */\n  async invalidatePattern(pattern: string): Promise<number> {\n    try {\n      // 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  /**\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.\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    this.applyLocalInvalidation('clear');\n    this.broadcast('clear');\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 */\nexport function createCacheService(prefix: string, defaultTtlSeconds = 300): CacheService {\n  return new CacheService({ prefix, defaultTtlSeconds });\n}\n"]}

package/lib/services/circuit-breaker.d.ts

@@ -20,6 +20,8 @@ export declare class CircuitBreaker {
     private consecutiveFailures;
     private openedAt;
     private probeInFlight;
+    /** When the current half-open probe was admitted (for expiring a stuck probe). */
+    private probeStartedAt;
     constructor(key: string, config?: CircuitBreakerConfig);
     getState(): CircuitState;
     /**
@@ -28,13 +30,24 @@ export declare class CircuitBreaker {
      * probe is already in flight) — the caller must fast-fail without any network.
      */
     allowRequest(): boolean;
+    private admitProbe;
     /** A logical request succeeded (2xx/3xx/4xx that isn't a downstream fault). */
     recordSuccess(): void;
     /** A logical request failed (connection error, timeout, or 5xx response). */
     recordFailure(): void;
     private open;
 }
-/** Get (or lazily create) the shared breaker for a `host:port` target. */
+/**
+ * The breaker key for a target and a ROUTE CLASS. Breakers are per
+ * `host:port` + class, so one failing surface of a service (say platform's
+ * audit ingest returning 5xx) can't open the breaker for an unrelated one
+ * (platform's JWKS / key exchange). The class is a small, caller-chosen label —
+ * never derived from the path, which carries ids and would explode the registry.
+ */
+export declare function circuitBreakerKey(target: string, routeClass?: string): string;
+/** The route class of a request that names none. */
+export declare const DEFAULT_ROUTE_CLASS = "default";
+/** Get (or lazily create) the shared breaker for a {@link circuitBreakerKey}. */
 export declare function getCircuitBreaker(key: string): CircuitBreaker;
 /** Test helper: clear all breaker state so suites don't leak across each other. */
 export declare function resetCircuitBreakers(): void;