@pipeline-builder/api-core 3.4.126 → 4.0.1

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

@@ -0,0 +1,96 @@
+/**
+ * Durable, at-least-once event backbone (Redis Streams).
+ *
+ * The platform's cross-service signalling today is point-to-point HTTP plus
+ * polling reconcilers plus an IN-PROCESS best-effort emitter ({@link entityEvents}).
+ * There is no durable bus, so a signal produced on one pod is either delivered
+ * synchronously over HTTP (coupling + retry-storm risk) or lost if the consumer
+ * is momentarily down (the reconcilers exist to paper over exactly that).
+ *
+ * This is that missing bus, as a reusable primitive:
+ *  - **publish(topic, payload)** → `XADD` onto a bounded (`MAXLEN ~`) per-topic
+ *    stream. Durable across restarts, shared by all replicas.
+ *  - **subscribe({topic, group, consumer, handler})** → a `XREADGROUP` consumer.
+ *    Consumer GROUPS give at-least-once: each group gets every message once, a
+ *    message stays pending until the handler `XACK`s it, and `XAUTOCLAIM`
+ *    reclaims messages stranded by a crashed consumer. Multiple groups on one
+ *    topic = independent fan-out (e.g. quota-sync AND audit both react).
+ *
+ * FAIL-SAFE + OPT-IN, exactly like the audit spool: {@link createEnvRedisDurableEventBus}
+ * returns `null` when Redis isn't configured, so a service without it simply
+ * doesn't use the bus (keeps today's behavior). A publish failure is dropped-with-
+ * -metric, never thrown; a handler throw leaves the message un-acked for redelivery.
+ *
+ * Migrating a specific reconciler (e.g. billing→quota entitlement sync) onto this
+ * is deliberately follow-on work — this lands the backbone + an additive entity-
+ * event bridge; the reconcilers stay as the belt-and-suspenders backstop until a
+ * flow is fully cut over.
+ */
+import type { EntityEventSubscriber } from './entity-events.js';
+/** A delivered event: its stream id, topic, and decoded payload. */
+export interface EventEnvelope<T = unknown> {
+    /** Redis Stream entry id (`<ms>-<seq>`) — also the idempotency handle. */
+    id: string;
+    topic: string;
+    payload: T;
+}
+export interface SubscribeOptions<T = unknown> {
+    /** Topic (stream) to consume. */
+    topic: string;
+    /** Consumer group — one delivery per group; distinct groups fan out. */
+    group: string;
+    /** This consumer's id within the group (e.g. `${service}-${pid}`). */
+    consumer: string;
+    /** Async handler. Resolves ⇒ the message is acked; throws ⇒ left pending for redelivery. */
+    handler: (env: EventEnvelope<T>) => Promise<void>;
+    /** Max messages per read (default 16). */
+    batchSize?: number;
+    /** XREADGROUP block time in ms (default 5000). */
+    blockMs?: number;
+    /** A pending message idle this long (ms) is reclaimed from a dead consumer (default 60000). */
+    minIdleMs?: number;
+}
+export interface EventSubscription {
+    /** Stop the consumer loop. Resolves once the in-flight read returns. */
+    stop(): Promise<void>;
+}
+export interface DurableEventBus {
+    /** Publish a payload to a topic. Returns the stream id, or null on failure (dropped, never throws). */
+    publish<T>(topic: string, payload: T): Promise<string | null>;
+    /** Start a consumer-group reader for a topic. Fire-and-forget loop; call `stop()` to end it. */
+    subscribe<T>(opts: SubscribeOptions<T>): EventSubscription;
+}
+/**
+ * The subset of ioredis' Stream API the bus uses. Kept minimal so a test can
+ * supply an in-memory fake and so merely importing this never hard-depends on
+ * ioredis (constructed via the shared env helper).
+ */
+export interface RedisStreamClient {
+    xadd(key: string, ...args: (string | number)[]): Promise<string | null>;
+    xgroup(...args: (string | number)[]): Promise<unknown>;
+    xreadgroup(...args: (string | number)[]): Promise<unknown>;
+    xack(key: string, group: string, ...ids: string[]): Promise<number>;
+    xautoclaim(...args: (string | number)[]): Promise<unknown>;
+}
+/** Build a durable event bus over a Redis Streams client. */
+export declare function createRedisDurableEventBus(redis: RedisStreamClient, opts?: {
+    maxLen?: number;
+}): DurableEventBus;
+/**
+ * Build a durable event bus from the ambient Redis env via the shared
+ * `createEnvRedisClient`. Returns `null` when Redis is not configured — the
+ * caller then runs without a bus (today's HTTP/reconciler behavior), never
+ * crashing. Opt in with a single boot line where a service wants durable events.
+ */
+export declare function createEnvRedisDurableEventBus(opts?: {
+    maxLen?: number;
+}): DurableEventBus | null;
+/** Topic the entity-event bridge publishes to. */
+export declare const ENTITY_EVENT_TOPIC = "entity-events";
+/**
+ * An {@link EntityEventSubscriber} that forwards each entity event to the durable
+ * bus. `bus.publish` is fail-safe (drops-with-metric, never throws), matching the
+ * emitter's fire-and-forget contract. Note `EntityEvent.timestamp` (a Date)
+ * serializes to an ISO string on the wire — a consumer re-hydrates as needed.
+ */
+export declare function createEntityEventBusPublisher(bus: DurableEventBus): EntityEventSubscriber;

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

@@ -0,0 +1,204 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { createEnvRedisClient } from './env-redis.js';
+import { createLogger } from '../utils/logger.js';
+import { emitCounter } from '../utils/metric-emitter.js';
+const logger = createLogger('durable-event-bus');
+const DEFAULT_MAXLEN = 10_000;
+const DEFAULT_BATCH = 16;
+const DEFAULT_BLOCK_MS = 5_000;
+const DEFAULT_MIN_IDLE_MS = 60_000;
+function errMsg(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function streamKey(topic) {
+    return `evt:${topic}`;
+}
+/** True when the error is Redis' "group already exists" (idempotent create). */
+function isBusyGroup(err) {
+    return errMsg(err).includes('BUSYGROUP');
+}
+/**
+ * Parse the nested array shape XREADGROUP / XAUTOCLAIM return into flat envelopes.
+ * XREADGROUP: `[[streamKey, [[id, [f, v, ...]], ...]]]`.
+ * XAUTOCLAIM: `[nextCursor, [[id, [f, v, ...]], ...], deletedIds]`.
+ * We store the JSON payload under a single field `d`.
+ */
+function parseEntries(topic, entries) {
+    const out = [];
+    if (!Array.isArray(entries))
+        return out;
+    for (const entry of entries) {
+        if (!Array.isArray(entry) || entry.length < 2)
+            continue;
+        const id = String(entry[0]);
+        const fields = entry[1];
+        if (!Array.isArray(fields))
+            continue;
+        // fields is [name, value, name, value, ...]; find 'd'.
+        let raw;
+        for (let i = 0; i + 1 < fields.length; i += 2) {
+            if (String(fields[i]) === 'd') {
+                raw = String(fields[i + 1]);
+                break;
+            }
+        }
+        // A missing `d` field (an entry not written by publish()) OR a corrupt JSON
+        // payload both yield an undefined-payload envelope so `deliver()` ACKs it —
+        // a poison message must never wedge the group by staying perpetually pending.
+        if (raw === undefined) {
+            out.push({ id, topic, payload: undefined });
+            continue;
+        }
+        try {
+            out.push({ id, topic, payload: JSON.parse(raw) });
+        }
+        catch {
+            out.push({ id, topic, payload: undefined });
+        }
+    }
+    return out;
+}
+/** Build a durable event bus over a Redis Streams client. */
+export function createRedisDurableEventBus(redis, opts = {}) {
+    const maxLen = Math.max(1, opts.maxLen ?? DEFAULT_MAXLEN);
+    return {
+        async publish(topic, payload) {
+            const key = streamKey(topic);
+            try {
+                // MAXLEN ~ <n> bounds the stream approximately (cheap); `*` = server id.
+                const id = await redis.xadd(key, 'MAXLEN', '~', maxLen, '*', 'd', JSON.stringify(payload));
+                emitCounter('event_bus_published_total', { topic });
+                return id;
+            }
+            catch (err) {
+                emitCounter('event_bus_publish_failed_total', { topic });
+                logger.warn('Event bus publish failed (event dropped)', { topic, error: errMsg(err) });
+                return null;
+            }
+        },
+        subscribe(subOpts) {
+            const { topic, group, consumer, handler } = subOpts;
+            const key = streamKey(topic);
+            const batch = Math.max(1, subOpts.batchSize ?? DEFAULT_BATCH);
+            const blockMs = Math.max(0, subOpts.blockMs ?? DEFAULT_BLOCK_MS);
+            const minIdle = Math.max(0, subOpts.minIdleMs ?? DEFAULT_MIN_IDLE_MS);
+            let stopped = false;
+            let started = false;
+            const deliver = async (envs) => {
+                for (const env of envs) {
+                    try {
+                        if (env.payload !== undefined)
+                            await handler(env);
+                        // Ack on success OR on an undefined (corrupt) payload — a poison
+                        // message must not block the group forever.
+                        await redis.xack(key, group, env.id);
+                        emitCounter('event_bus_delivered_total', { topic, group });
+                    }
+                    catch (err) {
+                        // Leave it pending (no XACK) — XAUTOCLAIM redelivers it after minIdle.
+                        emitCounter('event_bus_handler_failed_total', { topic, group });
+                        logger.warn('Event handler failed; leaving message pending for redelivery', {
+                            topic, group, id: env.id, error: errMsg(err),
+                        });
+                    }
+                }
+            };
+            const ensureGroup = async () => {
+                try {
+                    // MKSTREAM so the stream need not exist yet; '$' = only new messages.
+                    await redis.xgroup('CREATE', key, group, '$', 'MKSTREAM');
+                }
+                catch (err) {
+                    if (!isBusyGroup(err)) {
+                        logger.warn('Event bus group create failed', { topic, group, error: errMsg(err) });
+                    }
+                }
+            };
+            const loop = async () => {
+                await ensureGroup();
+                while (!stopped) {
+                    try {
+                        // 1) Reclaim messages stranded by a crashed consumer in this group.
+                        const claimed = await redis.xautoclaim(key, group, consumer, minIdle, '0', 'COUNT', batch);
+                        // XAUTOCLAIM reply: [nextCursor, entries, deletedIds]
+                        if (Array.isArray(claimed) && claimed.length >= 2) {
+                            await deliver(parseEntries(topic, claimed[1]));
+                        }
+                        if (stopped)
+                            break;
+                        // 2) Read new, never-delivered messages for this group ('>').
+                        const res = await redis.xreadgroup('GROUP', group, consumer, 'COUNT', batch, 'BLOCK', blockMs, 'STREAMS', key, '>');
+                        // XREADGROUP reply: [[streamKey, entries]] | null (on block timeout)
+                        if (Array.isArray(res) && res.length > 0 && Array.isArray(res[0]) && res[0].length >= 2) {
+                            await deliver(parseEntries(topic, res[0][1]));
+                        }
+                    }
+                    catch (err) {
+                        if (stopped)
+                            break;
+                        logger.warn('Event bus consumer loop error; backing off', { topic, group, error: errMsg(err) });
+                        // Back off so a persistent Redis error doesn't hot-spin.
+                        await new Promise((r) => setTimeout(r, 1000));
+                    }
+                }
+            };
+            let loopPromise = Promise.resolve();
+            if (!started) {
+                started = true;
+                loopPromise = loop();
+                logger.info('Event bus consumer started', { topic, group, consumer });
+            }
+            return {
+                async stop() {
+                    stopped = true;
+                    // Await the in-flight read/handler so a caller (e.g. a service shutting
+                    // down its DB) doesn't race a message still being processed. Bounded by
+                    // the XREADGROUP BLOCK window. Never rejects — the loop swallows errors.
+                    await loopPromise.catch(() => undefined);
+                },
+            };
+        },
+    };
+}
+/**
+ * Build a durable event bus from the ambient Redis env via the shared
+ * `createEnvRedisClient`. Returns `null` when Redis is not configured — the
+ * caller then runs without a bus (today's HTTP/reconciler behavior), never
+ * crashing. Opt in with a single boot line where a service wants durable events.
+ */
+export function createEnvRedisDurableEventBus(opts = {}) {
+    const inst = createEnvRedisClient('event-bus');
+    if (!inst)
+        return null;
+    logger.info('Redis durable event bus initialized');
+    return createRedisDurableEventBus(inst, opts);
+}
+// ---------------------------------------------------------------------------
+// Entity-event bridge (additive, opt-in)
+//
+// Lets a service give its in-process {@link entityEvents} emitter a DURABLE,
+// cross-pod delivery leg WITHOUT changing existing behavior: register the
+// returned subscriber and every entity mutation is ALSO published to the bus.
+// A consumer elsewhere (`bus.subscribe`) then reacts at-least-once across pods
+// and restarts. The in-process subscribers keep firing exactly as before, so
+// this is purely additive — no double-processing unless a service intentionally
+// runs a bus consumer for the same reaction. Kept here (not in entity-events.ts)
+// so that module stays infrastructure-free per its own contract.
+// ---------------------------------------------------------------------------
+/** Topic the entity-event bridge publishes to. */
+export const ENTITY_EVENT_TOPIC = 'entity-events';
+/**
+ * An {@link EntityEventSubscriber} that forwards each entity event to the durable
+ * bus. `bus.publish` is fail-safe (drops-with-metric, never throws), matching the
+ * emitter's fire-and-forget contract. Note `EntityEvent.timestamp` (a Date)
+ * serializes to an ISO string on the wire — a consumer re-hydrates as needed.
+ */
+export function createEntityEventBusPublisher(bus) {
+    return {
+        async onEntityEvent(event) {
+            await bus.publish(ENTITY_EVENT_TOPIC, event);
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"durable-event-bus.js","sourceRoot":"","sources":["../../src/services/durable-event-bus.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAgCtC,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEzD,MAAM,MAAM,GAAG,YAAY,CAAC,mBAAmB,CAAC,CAAC;AAoDjD,MAAM,cAAc,GAAG,MAAM,CAAC;AAC9B,MAAM,aAAa,GAAG,EAAE,CAAC;AACzB,MAAM,gBAAgB,GAAG,KAAK,CAAC;AAC/B,MAAM,mBAAmB,GAAG,MAAM,CAAC;AAEnC,SAAS,MAAM,CAAC,GAAY;IAC1B,OAAO,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AAC1D,CAAC;AAED,SAAS,SAAS,CAAC,KAAa;IAC9B,OAAO,OAAO,KAAK,EAAE,CAAC;AACxB,CAAC;AAED,gFAAgF;AAChF,SAAS,WAAW,CAAC,GAAY;IAC/B,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;AAC3C,CAAC;AAED;;;;;GAKG;AACH,SAAS,YAAY,CAAI,KAAa,EAAE,OAAgB;IACtD,MAAM,GAAG,GAAuB,EAAE,CAAC;IACnC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;QAAE,OAAO,GAAG,CAAC;IACxC,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;YAAE,SAAS;QACxD,MAAM,EAAE,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAC5B,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACxB,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC;YAAE,SAAS;QACrC,uDAAuD;QACvD,IAAI,GAAuB,CAAC;QAC5B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;YAC9C,IAAI,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;gBAAC,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;gBAAC,MAAM;YAAC,CAAC;QACxE,CAAC;QACD,4EAA4E;QAC5E,4EAA4E;QAC5E,8EAA8E;QAC9E,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;YACtB,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,SAAyB,EAAE,CAAC,CAAC;YAC5D,SAAS;QACX,CAAC;QACD,IAAI,CAAC;YACH,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAM,EAAE,CAAC,CAAC;QACzD,CAAC;QAAC,MAAM,CAAC;YACP,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,SAAyB,EAAE,CAAC,CAAC;QAC9D,CAAC;IACH,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,6DAA6D;AAC7D,MAAM,UAAU,0BAA0B,CACxC,KAAwB,EACxB,IAAI,GAAwB,EAAE;IAE9B,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,IAAI,cAAc,CAAC,CAAC;IAE1D,OAAO;QACL,KAAK,CAAC,OAAO,CAAI,KAAa,EAAE,OAAU;YACxC,MAAM,GAAG,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;YAC7B,IAAI,CAAC;gBACH,yEAAyE;gBACzE,MAAM,EAAE,GAAG,MAAM,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC;gBAC3F,WAAW,CAAC,2BAA2B,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;gBACpD,OAAO,EAAE,CAAC;YACZ,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,WAAW,CAAC,gCAAgC,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;gBACzD,MAAM,CAAC,IAAI,CAAC,0CAA0C,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBACvF,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;QAED,SAAS,CAAI,OAA4B;YACvC,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;YACpD,MAAM,GAAG,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;YAC7B,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,SAAS,IAAI,aAAa,CAAC,CAAC;YAC9D,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,OAAO,IAAI,gBAAgB,CAAC,CAAC;YACjE,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,SAAS,IAAI,mBAAmB,CAAC,CAAC;YAEtE,IAAI,OAAO,GAAG,KAAK,CAAC;YACpB,IAAI,OAAO,GAAG,KAAK,CAAC;YAEpB,MAAM,OAAO,GAAG,KAAK,EAAE,IAAwB,EAAiB,EAAE;gBAChE,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;oBACvB,IAAI,CAAC;wBACH,IAAI,GAAG,CAAC,OAAO,KAAK,SAAS;4BAAE,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;wBAClD,iEAAiE;wBACjE,4CAA4C;wBAC5C,MAAM,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;wBACrC,WAAW,CAAC,2BAA2B,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;oBAC7D,CAAC;oBAAC,OAAO,GAAG,EAAE,CAAC;wBACb,uEAAuE;wBACvE,WAAW,CAAC,gCAAgC,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;wBAChE,MAAM,CAAC,IAAI,CAAC,8DAA8D,EAAE;4BAC1E,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC;yBAC7C,CAAC,CAAC;oBACL,CAAC;gBACH,CAAC;YACH,CAAC,CAAC;YAEF,MAAM,WAAW,GAAG,KAAK,IAAmB,EAAE;gBAC5C,IAAI,CAAC;oBACH,sEAAsE;oBACtE,MAAM,KAAK,CAAC,MAAM,CAAC,QAAQ,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC;gBAC5D,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC;wBACtB,MAAM,CAAC,IAAI,CAAC,+BAA+B,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;oBACrF,CAAC;gBACH,CAAC;YACH,CAAC,CAAC;YAEF,MAAM,IAAI,GAAG,KAAK,IAAmB,EAAE;gBACrC,MAAM,WAAW,EAAE,CAAC;gBACpB,OAAO,CAAC,OAAO,EAAE,CAAC;oBAChB,IAAI,CAAC;wBACH,oEAAoE;wBACpE,MAAM,OAAO,GAAG,MAAM,KAAK,CAAC,UAAU,CAAC,GAAG,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;wBAC3F,sDAAsD;wBACtD,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;4BAClD,MAAM,OAAO,CAAC,YAAY,CAAI,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;wBACpD,CAAC;wBACD,IAAI,OAAO;4BAAE,MAAM;wBAEnB,8DAA8D;wBAC9D,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,UAAU,CAChC,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,GAAG,EAAE,GAAG,CAChF,CAAC;wBACF,qEAAqE;wBACrE,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;4BACxF,MAAM,OAAO,CAAC,YAAY,CAAI,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;wBACnD,CAAC;oBACH,CAAC;oBAAC,OAAO,GAAG,EAAE,CAAC;wBACb,IAAI,OAAO;4BAAE,MAAM;wBACnB,MAAM,CAAC,IAAI,CAAC,4CAA4C,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;wBAChG,yDAAyD;wBACzD,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;oBAChD,CAAC;gBACH,CAAC;YACH,CAAC,CAAC;YAEF,IAAI,WAAW,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;YACpC,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,OAAO,GAAG,IAAI,CAAC;gBACf,WAAW,GAAG,IAAI,EAAE,CAAC;gBACrB,MAAM,CAAC,IAAI,CAAC,4BAA4B,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;YACxE,CAAC;YAED,OAAO;gBACL,KAAK,CAAC,IAAI;oBACR,OAAO,GAAG,IAAI,CAAC;oBACf,wEAAwE;oBACxE,wEAAwE;oBACxE,yEAAyE;oBACzE,MAAM,WAAW,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;gBAC3C,CAAC;aACF,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,6BAA6B,CAAC,IAAI,GAAwB,EAAE;IAC1E,MAAM,IAAI,GAAG,oBAAoB,CAAoB,WAAW,CAAC,CAAC;IAClE,IAAI,CAAC,IAAI;QAAE,OAAO,IAAI,CAAC;IACvB,MAAM,CAAC,IAAI,CAAC,qCAAqC,CAAC,CAAC;IACnD,OAAO,0BAA0B,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AAChD,CAAC;AAED,8EAA8E;AAC9E,yCAAyC;AACzC,EAAE;AACF,6EAA6E;AAC7E,0EAA0E;AAC1E,8EAA8E;AAC9E,+EAA+E;AAC/E,6EAA6E;AAC7E,gFAAgF;AAChF,iFAAiF;AACjF,iEAAiE;AACjE,8EAA8E;AAE9E,kDAAkD;AAClD,MAAM,CAAC,MAAM,kBAAkB,GAAG,eAAe,CAAC;AAElD;;;;;GAKG;AACH,MAAM,UAAU,6BAA6B,CAAC,GAAoB;IAChE,OAAO;QACL,KAAK,CAAC,aAAa,CAAC,KAAkB;YACpC,MAAM,GAAG,CAAC,OAAO,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;QAC/C,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Durable, at-least-once event backbone (Redis Streams).\n *\n * The platform's cross-service signalling today is point-to-point HTTP plus\n * polling reconcilers plus an IN-PROCESS best-effort emitter ({@link entityEvents}).\n * There is no durable bus, so a signal produced on one pod is either delivered\n * synchronously over HTTP (coupling + retry-storm risk) or lost if the consumer\n * is momentarily down (the reconcilers exist to paper over exactly that).\n *\n * This is that missing bus, as a reusable primitive:\n *  - **publish(topic, payload)** → `XADD` onto a bounded (`MAXLEN ~`) per-topic\n *    stream. Durable across restarts, shared by all replicas.\n *  - **subscribe({topic, group, consumer, handler})** → a `XREADGROUP` consumer.\n *    Consumer GROUPS give at-least-once: each group gets every message once, a\n *    message stays pending until the handler `XACK`s it, and `XAUTOCLAIM`\n *    reclaims messages stranded by a crashed consumer. Multiple groups on one\n *    topic = independent fan-out (e.g. quota-sync AND audit both react).\n *\n * FAIL-SAFE + OPT-IN, exactly like the audit spool: {@link createEnvRedisDurableEventBus}\n * returns `null` when Redis isn't configured, so a service without it simply\n * doesn't use the bus (keeps today's behavior). A publish failure is dropped-with-\n * -metric, never thrown; a handler throw leaves the message un-acked for redelivery.\n *\n * Migrating a specific reconciler (e.g. billing→quota entitlement sync) onto this\n * is deliberately follow-on work — this lands the backbone + an additive entity-\n * event bridge; the reconcilers stay as the belt-and-suspenders backstop until a\n * flow is fully cut over.\n */\n\nimport type { EntityEvent, EntityEventSubscriber } from './entity-events.js';\nimport { createEnvRedisClient } from './env-redis.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('durable-event-bus');\n\n/** A delivered event: its stream id, topic, and decoded payload. */\nexport interface EventEnvelope<T = unknown> {\n  /** Redis Stream entry id (`<ms>-<seq>`) — also the idempotency handle. */\n  id: string;\n  topic: string;\n  payload: T;\n}\n\nexport interface SubscribeOptions<T = unknown> {\n  /** Topic (stream) to consume. */\n  topic: string;\n  /** Consumer group — one delivery per group; distinct groups fan out. */\n  group: string;\n  /** This consumer's id within the group (e.g. `${service}-${pid}`). */\n  consumer: string;\n  /** Async handler. Resolves ⇒ the message is acked; throws ⇒ left pending for redelivery. */\n  handler: (env: EventEnvelope<T>) => Promise<void>;\n  /** Max messages per read (default 16). */\n  batchSize?: number;\n  /** XREADGROUP block time in ms (default 5000). */\n  blockMs?: number;\n  /** A pending message idle this long (ms) is reclaimed from a dead consumer (default 60000). */\n  minIdleMs?: number;\n}\n\nexport interface EventSubscription {\n  /** Stop the consumer loop. Resolves once the in-flight read returns. */\n  stop(): Promise<void>;\n}\n\nexport interface DurableEventBus {\n  /** Publish a payload to a topic. Returns the stream id, or null on failure (dropped, never throws). */\n  publish<T>(topic: string, payload: T): Promise<string | null>;\n  /** Start a consumer-group reader for a topic. Fire-and-forget loop; call `stop()` to end it. */\n  subscribe<T>(opts: SubscribeOptions<T>): EventSubscription;\n}\n\n/**\n * The subset of ioredis' Stream API the bus uses. Kept minimal so a test can\n * supply an in-memory fake and so merely importing this never hard-depends on\n * ioredis (constructed via the shared env helper).\n */\nexport interface RedisStreamClient {\n  xadd(key: string, ...args: (string | number)[]): Promise<string | null>;\n  xgroup(...args: (string | number)[]): Promise<unknown>;\n  xreadgroup(...args: (string | number)[]): Promise<unknown>;\n  xack(key: string, group: string, ...ids: string[]): Promise<number>;\n  xautoclaim(...args: (string | number)[]): Promise<unknown>;\n}\n\nconst DEFAULT_MAXLEN = 10_000;\nconst DEFAULT_BATCH = 16;\nconst DEFAULT_BLOCK_MS = 5_000;\nconst DEFAULT_MIN_IDLE_MS = 60_000;\n\nfunction errMsg(err: unknown): string {\n  return err instanceof Error ? err.message : String(err);\n}\n\nfunction streamKey(topic: string): string {\n  return `evt:${topic}`;\n}\n\n/** True when the error is Redis' \"group already exists\" (idempotent create). */\nfunction isBusyGroup(err: unknown): boolean {\n  return errMsg(err).includes('BUSYGROUP');\n}\n\n/**\n * Parse the nested array shape XREADGROUP / XAUTOCLAIM return into flat envelopes.\n * XREADGROUP: `[[streamKey, [[id, [f, v, ...]], ...]]]`.\n * XAUTOCLAIM: `[nextCursor, [[id, [f, v, ...]], ...], deletedIds]`.\n * We store the JSON payload under a single field `d`.\n */\nfunction parseEntries<T>(topic: string, entries: unknown): EventEnvelope<T>[] {\n  const out: EventEnvelope<T>[] = [];\n  if (!Array.isArray(entries)) return out;\n  for (const entry of entries) {\n    if (!Array.isArray(entry) || entry.length < 2) continue;\n    const id = String(entry[0]);\n    const fields = entry[1];\n    if (!Array.isArray(fields)) continue;\n    // fields is [name, value, name, value, ...]; find 'd'.\n    let raw: string | undefined;\n    for (let i = 0; i + 1 < fields.length; i += 2) {\n      if (String(fields[i]) === 'd') { raw = String(fields[i + 1]); break; }\n    }\n    // A missing `d` field (an entry not written by publish()) OR a corrupt JSON\n    // payload both yield an undefined-payload envelope so `deliver()` ACKs it —\n    // a poison message must never wedge the group by staying perpetually pending.\n    if (raw === undefined) {\n      out.push({ id, topic, payload: undefined as unknown as T });\n      continue;\n    }\n    try {\n      out.push({ id, topic, payload: JSON.parse(raw) as T });\n    } catch {\n      out.push({ id, topic, payload: undefined as unknown as T });\n    }\n  }\n  return out;\n}\n\n/** Build a durable event bus over a Redis Streams client. */\nexport function createRedisDurableEventBus(\n  redis: RedisStreamClient,\n  opts: { maxLen?: number } = {},\n): DurableEventBus {\n  const maxLen = Math.max(1, opts.maxLen ?? DEFAULT_MAXLEN);\n\n  return {\n    async publish<T>(topic: string, payload: T): Promise<string | null> {\n      const key = streamKey(topic);\n      try {\n        // MAXLEN ~ <n> bounds the stream approximately (cheap); `*` = server id.\n        const id = await redis.xadd(key, 'MAXLEN', '~', maxLen, '*', 'd', JSON.stringify(payload));\n        emitCounter('event_bus_published_total', { topic });\n        return id;\n      } catch (err) {\n        emitCounter('event_bus_publish_failed_total', { topic });\n        logger.warn('Event bus publish failed (event dropped)', { topic, error: errMsg(err) });\n        return null;\n      }\n    },\n\n    subscribe<T>(subOpts: SubscribeOptions<T>): EventSubscription {\n      const { topic, group, consumer, handler } = subOpts;\n      const key = streamKey(topic);\n      const batch = Math.max(1, subOpts.batchSize ?? DEFAULT_BATCH);\n      const blockMs = Math.max(0, subOpts.blockMs ?? DEFAULT_BLOCK_MS);\n      const minIdle = Math.max(0, subOpts.minIdleMs ?? DEFAULT_MIN_IDLE_MS);\n\n      let stopped = false;\n      let started = false;\n\n      const deliver = async (envs: EventEnvelope<T>[]): Promise<void> => {\n        for (const env of envs) {\n          try {\n            if (env.payload !== undefined) await handler(env);\n            // Ack on success OR on an undefined (corrupt) payload — a poison\n            // message must not block the group forever.\n            await redis.xack(key, group, env.id);\n            emitCounter('event_bus_delivered_total', { topic, group });\n          } catch (err) {\n            // Leave it pending (no XACK) — XAUTOCLAIM redelivers it after minIdle.\n            emitCounter('event_bus_handler_failed_total', { topic, group });\n            logger.warn('Event handler failed; leaving message pending for redelivery', {\n              topic, group, id: env.id, error: errMsg(err),\n            });\n          }\n        }\n      };\n\n      const ensureGroup = async (): Promise<void> => {\n        try {\n          // MKSTREAM so the stream need not exist yet; '$' = only new messages.\n          await redis.xgroup('CREATE', key, group, '$', 'MKSTREAM');\n        } catch (err) {\n          if (!isBusyGroup(err)) {\n            logger.warn('Event bus group create failed', { topic, group, error: errMsg(err) });\n          }\n        }\n      };\n\n      const loop = async (): Promise<void> => {\n        await ensureGroup();\n        while (!stopped) {\n          try {\n            // 1) Reclaim messages stranded by a crashed consumer in this group.\n            const claimed = await redis.xautoclaim(key, group, consumer, minIdle, '0', 'COUNT', batch);\n            // XAUTOCLAIM reply: [nextCursor, entries, deletedIds]\n            if (Array.isArray(claimed) && claimed.length >= 2) {\n              await deliver(parseEntries<T>(topic, claimed[1]));\n            }\n            if (stopped) break;\n\n            // 2) Read new, never-delivered messages for this group ('>').\n            const res = await redis.xreadgroup(\n              'GROUP', group, consumer, 'COUNT', batch, 'BLOCK', blockMs, 'STREAMS', key, '>',\n            );\n            // XREADGROUP reply: [[streamKey, entries]] | null (on block timeout)\n            if (Array.isArray(res) && res.length > 0 && Array.isArray(res[0]) && res[0].length >= 2) {\n              await deliver(parseEntries<T>(topic, res[0][1]));\n            }\n          } catch (err) {\n            if (stopped) break;\n            logger.warn('Event bus consumer loop error; backing off', { topic, group, error: errMsg(err) });\n            // Back off so a persistent Redis error doesn't hot-spin.\n            await new Promise((r) => setTimeout(r, 1000));\n          }\n        }\n      };\n\n      let loopPromise = Promise.resolve();\n      if (!started) {\n        started = true;\n        loopPromise = loop();\n        logger.info('Event bus consumer started', { topic, group, consumer });\n      }\n\n      return {\n        async stop(): Promise<void> {\n          stopped = true;\n          // Await the in-flight read/handler so a caller (e.g. a service shutting\n          // down its DB) doesn't race a message still being processed. Bounded by\n          // the XREADGROUP BLOCK window. Never rejects — the loop swallows errors.\n          await loopPromise.catch(() => undefined);\n        },\n      };\n    },\n  };\n}\n\n/**\n * Build a durable event bus from the ambient Redis env via the shared\n * `createEnvRedisClient`. Returns `null` when Redis is not configured — the\n * caller then runs without a bus (today's HTTP/reconciler behavior), never\n * crashing. Opt in with a single boot line where a service wants durable events.\n */\nexport function createEnvRedisDurableEventBus(opts: { maxLen?: number } = {}): DurableEventBus | null {\n  const inst = createEnvRedisClient<RedisStreamClient>('event-bus');\n  if (!inst) return null;\n  logger.info('Redis durable event bus initialized');\n  return createRedisDurableEventBus(inst, opts);\n}\n\n// ---------------------------------------------------------------------------\n// Entity-event bridge (additive, opt-in)\n//\n// Lets a service give its in-process {@link entityEvents} emitter a DURABLE,\n// cross-pod delivery leg WITHOUT changing existing behavior: register the\n// returned subscriber and every entity mutation is ALSO published to the bus.\n// A consumer elsewhere (`bus.subscribe`) then reacts at-least-once across pods\n// and restarts. The in-process subscribers keep firing exactly as before, so\n// this is purely additive — no double-processing unless a service intentionally\n// runs a bus consumer for the same reaction. Kept here (not in entity-events.ts)\n// so that module stays infrastructure-free per its own contract.\n// ---------------------------------------------------------------------------\n\n/** Topic the entity-event bridge publishes to. */\nexport const ENTITY_EVENT_TOPIC = 'entity-events';\n\n/**\n * An {@link EntityEventSubscriber} that forwards each entity event to the durable\n * bus. `bus.publish` is fail-safe (drops-with-metric, never throws), matching the\n * emitter's fire-and-forget contract. Note `EntityEvent.timestamp` (a Date)\n * serializes to an ISO string on the wire — a consumer re-hydrates as needed.\n */\nexport function createEntityEventBusPublisher(bus: DurableEventBus): EntityEventSubscriber {\n  return {\n    async onEntityEvent(event: EntityEvent): Promise<void> {\n      await bus.publish(ENTITY_EVENT_TOPIC, event);\n    },\n  };\n}\n"]}

package/lib/services/http-client.js

@@ -1,9 +1,11 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import * as http from 'http';
+import { getCircuitBreaker, CircuitOpenError } from './circuit-breaker.js';
 import { DEFAULT_MAX_RETRIES, DEFAULT_RETRY_DELAY_MS, DEFAULT_MAX_RATE_LIMIT_RETRIES, getRetryDecision, getErrorRetryDecision, } from './retry-strategy.js';
 import { HttpStatus } from '../constants/http-status.js';
 import { createLogger } from '../utils/logger.js';
+import { emitCounter } from '../utils/metric-emitter.js';
 const logger = createLogger('http-client');
 /**
  * Default request timeout in milliseconds (env: `HTTP_CLIENT_TIMEOUT`).
@@ -91,6 +93,13 @@ export class InternalHttpClient {
      * - All delays include ±25% jitter to prevent thundering herd.
      */
     async requestWithRetry(method, path, body, options) {
+        // A malformed path is a CLIENT bug, not a downstream fault — reject it up
+        // front so it never burns retries or feeds the circuit breaker (which would
+        // otherwise shed traffic to a perfectly healthy downstream). request() keeps
+        // the same guard as defence-in-depth.
+        if (path.includes('://') || path.startsWith('//') || /[\r\n\0]/.test(path)) {
+            throw new Error(`Invalid request path: ${path}`);
+        }
         const retryConfig = {
             maxRetries: options?.maxRetries ?? DEFAULT_MAX_RETRIES,
             maxRateLimitRetries: options?.maxRateLimitRetries ?? DEFAULT_MAX_RATE_LIMIT_RETRIES,
@@ -106,6 +115,17 @@ export class InternalHttpClient {
         const retrySafe = IDEMPOTENT_METHODS.has(method.toUpperCase()) ||
             options?.idempotent === true ||
             !!(options?.headers && (options.headers['Idempotency-Key'] || options.headers['idempotency-key']));
+        // Per-target circuit breaker + S2S request metrics. `target` is the shared
+        // breaker/metric key so one bad downstream trips once (not once-per-client)
+        // and dashboards can see S2S health per callee.
+        const target = `${this.config.host}:${this.config.port}`;
+        const breaker = getCircuitBreaker(target);
+        if (!breaker.allowRequest()) {
+            // Fast-fail without touching the network — this is the load-shedding that
+            // prevents a downstream brownout from cascading via retry storms.
+            emitCounter('s2s_requests_total', { target, method, outcome: 'circuit_open' });
+            throw new CircuitOpenError(target);
+        }
         let lastError;
         for (let attempt = 0; attempt <= totalMaxAttempts; attempt++) {
             try {
@@ -115,9 +135,22 @@ export class InternalHttpClient {
                 // 5xx/gateway error is only retried when the request is retry-safe.
                 if (decision.shouldRetry && (response.statusCode === 429 || retrySafe)) {
                     logger.debug(decision.reason + ', retrying', { method, path, attempt: attempt + 1, delayMs: decision.delayMs });
+                    emitCounter('s2s_request_retries_total', { target, method });
                     await this.sleep(decision.delayMs);
                     continue;
                 }
+                // Terminal response. A 5xx is a downstream fault (feeds the breaker); a
+                // 429 is backpressure, not a fault — the service answered, so it counts
+                // as success for breaker purposes (never trip the breaker on rate limits).
+                const isServerFault = response.statusCode >= 500 && response.statusCode <= 599;
+                if (isServerFault) {
+                    breaker.recordFailure();
+                    emitCounter('s2s_requests_total', { target, method, outcome: 'server_error' });
+                }
+                else {
+                    breaker.recordSuccess();
+                    emitCounter('s2s_requests_total', { target, method, outcome: 'success' });
+                }
                 return response;
             }
             catch (error) {
@@ -125,13 +158,20 @@ export class InternalHttpClient {
                 const decision = getErrorRetryDecision(attempt, retryConfig);
                 if (decision.shouldRetry && retrySafe) {
                     logger.debug('Retrying after error', { method, path, error: lastError.message, attempt: attempt + 1 });
+                    emitCounter('s2s_request_retries_total', { target, method });
                     await this.sleep(decision.delayMs);
                     continue;
                 }
-                // Not retrying (non-idempotent, or attempts exhausted) — fail now.
+                // Not retrying (non-idempotent, or attempts exhausted) — a connection
+                // error/timeout is a downstream fault: feed the breaker and fail now.
+                breaker.recordFailure();
+                emitCounter('s2s_requests_total', { target, method, outcome: 'error' });
                 throw lastError;
             }
         }
+        // Loop exhausted without returning (all attempts retried then ran out).
+        breaker.recordFailure();
+        emitCounter('s2s_requests_total', { target, method, outcome: 'error' });
         throw lastError;
     }
     sleep(ms) {
@@ -292,4 +332,4 @@ export function createSafeClient(config, options) {
         },
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-client.js","sourceRoot":"","sources":["../../src/services/http-client.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport * as http from 'http';\nimport {\n  DEFAULT_MAX_RETRIES,\n  DEFAULT_RETRY_DELAY_MS,\n  DEFAULT_MAX_RATE_LIMIT_RETRIES,\n  getRetryDecision,\n  getErrorRetryDecision,\n  type RetryConfig,\n} from './retry-strategy.js';\nimport { HttpStatus } from '../constants/http-status.js';\nimport type { ServiceConfig } from '../types/common.js';\nimport { createLogger } from '../utils/logger.js';\n\nconst logger = createLogger('http-client');\n\n/**\n * Default request timeout in milliseconds (env: `HTTP_CLIENT_TIMEOUT`).\n */\nconst DEFAULT_TIMEOUT = parseInt(process.env.HTTP_CLIENT_TIMEOUT || '5000', 10);\n\n/**\n * Default cap on concurrent keep-alive sockets per client agent\n * (env: `HTTP_CLIENT_MAX_SOCKETS`). Node's default is `Infinity`, which lets a\n * burst of concurrent calls open unbounded sockets against a downstream service\n * (fd exhaustion + connection-storm on the callee). 64 is ample for\n * service-to-service fan-out while staying bounded.\n */\nconst DEFAULT_MAX_SOCKETS = parseInt(process.env.HTTP_CLIENT_MAX_SOCKETS || '64', 10);\n\n// HTTP methods that are idempotent by definition — safe to auto-retry on a\n// 5xx/connection/timeout without risking a duplicate side effect.\nconst IDEMPOTENT_METHODS = new Set(['GET', 'HEAD', 'OPTIONS']);\n\n/**\n * HTTP request options.\n */\nexport interface RequestOptions {\n  /** Request headers */\n  headers?: Record<string, string>;\n  /** Request timeout in milliseconds */\n  timeout?: number;\n  /** Maximum retry attempts for transient failures (default: 2) */\n  maxRetries?: number;\n  /** Base delay between retries in ms — doubles each attempt (default: 200) */\n  retryDelayMs?: number;\n  /** Maximum retry attempts specifically for 429 rate limiting (default: 4) */\n  maxRateLimitRetries?: number;\n  /** Optional request ID for distributed tracing (added as X-Request-Id header) */\n  requestId?: string;\n  /**\n   * Treat this request as safe to auto-retry on 5xx/connection/timeout even\n   * though the method is non-idempotent (e.g. the endpoint is idempotent by an\n   * Idempotency-Key, or the operation is naturally idempotent). Default false:\n   * non-idempotent methods are NOT retried on those failures, only on 429.\n   */\n  idempotent?: boolean;\n}\n\n/**\n * HTTP client response wrapper.\n */\nexport interface HttpClientResponse<T = unknown> {\n  /** HTTP status code */\n  statusCode: number;\n  /** Response body (parsed JSON) */\n  body: T;\n  /** Response headers */\n  headers: http.IncomingHttpHeaders;\n}\n\n/**\n * Internal HTTP client for service-to-service communication.\n *\n * @example\n * ```typescript\n * const client = new InternalHttpClient({\n *   host: 'quota',\n *   port: 3000,\n *   timeout: 5000,\n * });\n *\n * const response = await client.get('/org123/apiCalls');\n * const result = await client.post('/org123/increment', { quotaType: 'apiCalls' });\n * ```\n */\n/**\n * Options controlling the client's connection pool.\n */\nexport interface HttpClientOptions {\n  /**\n   * A shared `http.Agent` to reuse across clients (pools sockets to the same\n   * host). When supplied, the client does NOT own it — {@link InternalHttpClient.destroy}\n   * leaves a borrowed agent untouched so other clients keep working.\n   */\n  agent?: http.Agent;\n  /** Cap on concurrent keep-alive sockets when minting an agent (default 64). */\n  maxSockets?: number;\n}\n\nexport class InternalHttpClient {\n  private config: Required<ServiceConfig>;\n  private agent: http.Agent;\n  /** True only when this client MINTED its agent (so destroy() may tear it down). */\n  private readonly ownsAgent: boolean;\n\n  /**\n   * Create a new HTTP client instance.\n   *\n   * @param config - Service configuration\n   * @param options - Optional connection-pool controls (shared agent / socket cap)\n   */\n  constructor(config: ServiceConfig, options?: HttpClientOptions) {\n    this.config = {\n      host: config.host,\n      port: config.port,\n      timeout: config.timeout ?? DEFAULT_TIMEOUT,\n    };\n    if (options?.agent) {\n      // Borrowed, caller-owned agent — pooled across clients, not ours to destroy.\n      this.agent = options.agent;\n      this.ownsAgent = false;\n    } else {\n      // Own a keep-alive agent with a BOUNDED socket pool (no more Infinity).\n      this.agent = new http.Agent({ keepAlive: true, maxSockets: options?.maxSockets ?? DEFAULT_MAX_SOCKETS });\n      this.ownsAgent = true;\n    }\n  }\n\n  /**\n   * Release the keep-alive socket pool. Idempotent and safe to call on shutdown.\n   * A borrowed (caller-supplied) agent is left intact — only an agent this client\n   * created is destroyed, so tearing down one client can't sever another's pool.\n   */\n  destroy(): void {\n    if (this.ownsAgent) this.agent.destroy();\n  }\n\n  /**\n   * Make a GET request.\n   */\n  async get<T = unknown>(path: string, options?: RequestOptions): Promise<HttpClientResponse<T>> {\n    return this.requestWithRetry<T>('GET', path, undefined, options);\n  }\n\n  /**\n   * Make a POST request.\n   */\n  async post<T = unknown>(\n    path: string,\n    body?: unknown,\n    options?: RequestOptions,\n  ): Promise<HttpClientResponse<T>> {\n    return this.requestWithRetry<T>('POST', path, body, options);\n  }\n\n  /**\n   * Make a PUT request.\n   */\n  async put<T = unknown>(\n    path: string,\n    body?: unknown,\n    options?: RequestOptions,\n  ): Promise<HttpClientResponse<T>> {\n    return this.requestWithRetry<T>('PUT', path, body, options);\n  }\n\n  /**\n   * Make a DELETE request.\n   */\n  async delete<T = unknown>(path: string, options?: RequestOptions): Promise<HttpClientResponse<T>> {\n    return this.requestWithRetry<T>('DELETE', path, undefined, options);\n  }\n\n  /**\n   * Request with retry logic for transient failures.\n   *\n   * - 429 (rate limit): respects `Retry-After` header, uses longer base delay (4x),\n   *   retries up to `maxRateLimitRetries` times (default 4).\n   * - 502/503/504 (server errors): standard exponential backoff, up to `maxRetries` (default 2).\n   * - Connection errors / timeouts: retries up to `maxRetries`.\n   * - All delays include ±25% jitter to prevent thundering herd.\n   */\n  private async requestWithRetry<T>(\n    method: string,\n    path: string,\n    body?: unknown,\n    options?: RequestOptions,\n  ): Promise<HttpClientResponse<T>> {\n    const retryConfig: RetryConfig = {\n      maxRetries: options?.maxRetries ?? DEFAULT_MAX_RETRIES,\n      maxRateLimitRetries: options?.maxRateLimitRetries ?? DEFAULT_MAX_RATE_LIMIT_RETRIES,\n      retryDelayMs: options?.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS,\n    };\n    const totalMaxAttempts = Math.max(retryConfig.maxRetries, retryConfig.maxRateLimitRetries);\n\n    // Whether it's safe to auto-retry this request on a 5xx/connection/timeout.\n    // A timed-out POST may have already been processed server-side, so retrying\n    // a non-idempotent request risks a DUPLICATE side effect (double-charge,\n    // double-create). Only GET/HEAD/OPTIONS, an explicit `idempotent` opt-in, or\n    // a request carrying an Idempotency-Key are auto-retried on those failures.\n    // (429 is always retried — see below — since it was rejected, not processed.)\n    const retrySafe =\n      IDEMPOTENT_METHODS.has(method.toUpperCase()) ||\n      options?.idempotent === true ||\n      !!(options?.headers && (options.headers['Idempotency-Key'] || options.headers['idempotency-key']));\n\n    let lastError: Error | undefined;\n\n    for (let attempt = 0; attempt <= totalMaxAttempts; attempt++) {\n      try {\n        const response = await this.request<T>(method, path, body, options);\n\n        const decision = getRetryDecision(response.statusCode, response.headers, attempt, retryConfig);\n        // 429 is safe to retry for ANY method (rate-limited → not processed); a\n        // 5xx/gateway error is only retried when the request is retry-safe.\n        if (decision.shouldRetry && (response.statusCode === 429 || retrySafe)) {\n          logger.debug(decision.reason + ', retrying', { method, path, attempt: attempt + 1, delayMs: decision.delayMs });\n          await this.sleep(decision.delayMs);\n          continue;\n        }\n\n        return response;\n      } catch (error) {\n        lastError = error instanceof Error ? error : new Error(String(error));\n\n        const decision = getErrorRetryDecision(attempt, retryConfig);\n        if (decision.shouldRetry && retrySafe) {\n          logger.debug('Retrying after error', { method, path, error: lastError.message, attempt: attempt + 1 });\n          await this.sleep(decision.delayMs);\n          continue;\n        }\n        // Not retrying (non-idempotent, or attempts exhausted) — fail now.\n        throw lastError;\n      }\n    }\n\n    throw lastError!;\n  }\n\n  private sleep(ms: number): Promise<void> {\n    return new Promise(resolve => setTimeout(resolve, ms));\n  }\n\n  /**\n   * Internal request method.\n   */\n  private request<T>(\n    method: string,\n    path: string,\n    body?: unknown,\n    options?: RequestOptions,\n  ): Promise<HttpClientResponse<T>> {\n    return new Promise((resolve, reject) => {\n      // Serialize when body is defined (including 0/false/'' which are valid JSON values).\n      const bodyStr = body !== undefined ? JSON.stringify(body) : undefined;\n\n      const headers: http.OutgoingHttpHeaders = {\n        'Content-Type': 'application/json',\n        ...options?.headers,\n      };\n\n      // Propagate request ID for distributed tracing\n      if (options?.requestId) {\n        headers['X-Request-Id'] = options.requestId;\n      }\n\n      if (bodyStr) {\n        headers['Content-Length'] = Buffer.byteLength(bodyStr);\n      }\n\n      // Validate path to prevent protocol injection / request smuggling\n      if (path.includes('://') || path.startsWith('//') || /[\\r\\n\\0]/.test(path)) {\n        throw new Error(`Invalid request path: ${path}`);\n      }\n\n      const requestOptions: http.RequestOptions = {\n        hostname: this.config.host,\n        port: this.config.port,\n        path: path.startsWith('/') ? path : `/${path}`,\n        method,\n        headers,\n        timeout: options?.timeout ?? this.config.timeout,\n        agent: this.agent,\n      };\n\n      const req = http.request(requestOptions, (res) => {\n        let data = '';\n\n        res.on('data', (chunk) => {\n          data += chunk;\n        });\n\n        res.on('end', () => {\n          try {\n            const parsedBody = data ? JSON.parse(data) : {};\n            resolve({\n              statusCode: res.statusCode || HttpStatus.INTERNAL_SERVER_ERROR,\n              body: parsedBody as T,\n              headers: res.headers,\n            });\n          } catch (parseError) {\n            logger.warn('Failed to parse response body', {\n              host: this.config.host,\n              path,\n              error: parseError instanceof Error ? parseError.message : String(parseError),\n            });\n            resolve({\n              statusCode: res.statusCode || HttpStatus.INTERNAL_SERVER_ERROR,\n              body: {} as T,\n              headers: res.headers,\n            });\n          }\n        });\n      });\n\n      req.on('error', (error) => {\n        // Node dual-stack connect failures are an AggregateError with an empty\n        // `.message`; the cause is in `.code` (ECONNREFUSED/ETIMEDOUT). Fall\n        // back so the log isn't a blank `error:\"\"`.\n        const detail = error.message || (error as NodeJS.ErrnoException).code || error.name;\n        logger.error('HTTP request failed', {\n          host: this.config.host,\n          port: this.config.port,\n          path,\n          method,\n          error: detail,\n        });\n        reject(error);\n      });\n\n      req.on('timeout', () => {\n        req.destroy();\n        const error = new Error(`Request timeout after ${this.config.timeout}ms`);\n        logger.warn('HTTP request timeout', {\n          host: this.config.host,\n          path,\n          timeout: this.config.timeout,\n        });\n        reject(error);\n      });\n\n      if (bodyStr) {\n        req.write(bodyStr);\n      }\n\n      req.end();\n    });\n  }\n}\n\n/**\n * Create an HTTP client with error handling that returns null on failure.\n * Useful for fail-open scenarios.\n *\n * @param config - Service configuration\n * @returns Client wrapper with safe methods\n */\nexport function createSafeClient(config: ServiceConfig, options?: HttpClientOptions) {\n  const client = new InternalHttpClient(config, options);\n\n  return {\n    /** Release the underlying keep-alive socket pool (no-op on a borrowed agent). */\n    destroy(): void {\n      client.destroy();\n    },\n\n    /**\n     * Safe GET request - returns null on error.\n     */\n    async get<T>(path: string, options?: RequestOptions): Promise<HttpClientResponse<T> | null> {\n      try {\n        return await client.get<T>(path, options);\n      } catch (err) {\n        logger.debug('Safe GET failed, returning null', { path, error: err instanceof Error ? err.message : String(err) });\n        return null;\n      }\n    },\n\n    /**\n     * Safe POST request - returns null on error.\n     */\n    async post<T>(\n      path: string,\n      body?: unknown,\n      options?: RequestOptions,\n    ): Promise<HttpClientResponse<T> | null> {\n      try {\n        return await client.post<T>(path, body, options);\n      } catch (err) {\n        logger.debug('Safe POST failed, returning null', { path, error: err instanceof Error ? err.message : String(err) });\n        return null;\n      }\n    },\n\n    /**\n     * Safe PUT request - returns null on error.\n     */\n    async put<T>(\n      path: string,\n      body?: unknown,\n      options?: RequestOptions,\n    ): Promise<HttpClientResponse<T> | null> {\n      try {\n        return await client.put<T>(path, body, options);\n      } catch (err) {\n        logger.debug('Safe PUT failed, returning null', { path, error: err instanceof Error ? err.message : String(err) });\n        return null;\n      }\n    },\n\n    /**\n     * Safe DELETE request - returns null on error. Used by destructive\n     * cross-service operations (e.g. org-cascade delete in platform).\n     */\n    async delete<T>(\n      path: string,\n      options?: RequestOptions,\n    ): Promise<HttpClientResponse<T> | null> {\n      try {\n        return await client.delete<T>(path, options);\n      } catch (err) {\n        logger.debug('Safe DELETE failed, returning null', { path, error: err instanceof Error ? err.message : String(err) });\n        return null;\n      }\n    },\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-client.js","sourceRoot":"","sources":["../../src/services/http-client.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC3E,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,8BAA8B,EAC9B,gBAAgB,EAChB,qBAAqB,GAEtB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEzD,MAAM,MAAM,GAAG,YAAY,CAAC,aAAa,CAAC,CAAC;AAE3C;;GAEG;AACH,MAAM,eAAe,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,mBAAmB,IAAI,MAAM,EAAE,EAAE,CAAC,CAAC;AAEhF;;;;;;GAMG;AACH,MAAM,mBAAmB,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,uBAAuB,IAAI,IAAI,EAAE,EAAE,CAAC,CAAC;AAEtF,2EAA2E;AAC3E,kEAAkE;AAClE,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;AAoE/D,MAAM,OAAO,kBAAkB;IACrB,MAAM,CAA0B;IAChC,KAAK,CAAa;IAC1B,mFAAmF;IAClE,SAAS,CAAU;IAEpC;;;;;OAKG;IACH,YAAY,MAAqB,EAAE,OAA2B;QAC5D,IAAI,CAAC,MAAM,GAAG;YACZ,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,eAAe;SAC3C,CAAC;QACF,IAAI,OAAO,EAAE,KAAK,EAAE,CAAC;YACnB,6EAA6E;YAC7E,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;YAC3B,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACzB,CAAC;aAAM,CAAC;YACN,wEAAwE;YACxE,IAAI,CAAC,KAAK,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,IAAI,mBAAmB,EAAE,CAAC,CAAC;YACzG,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACxB,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,OAAO;QACL,IAAI,IAAI,CAAC,SAAS;YAAE,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;IAC3C,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,GAAG,CAAc,IAAY,EAAE,OAAwB;QAC3D,OAAO,IAAI,CAAC,gBAAgB,CAAI,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;IACnE,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,IAAI,CACR,IAAY,EACZ,IAAc,EACd,OAAwB;QAExB,OAAO,IAAI,CAAC,gBAAgB,CAAI,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAC/D,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,GAAG,CACP,IAAY,EACZ,IAAc,EACd,OAAwB;QAExB,OAAO,IAAI,CAAC,gBAAgB,CAAI,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAC9D,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,CAAc,IAAY,EAAE,OAAwB;QAC9D,OAAO,IAAI,CAAC,gBAAgB,CAAI,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;IACtE,CAAC;IAED;;;;;;;;OAQG;IACK,KAAK,CAAC,gBAAgB,CAC5B,MAAc,EACd,IAAY,EACZ,IAAc,EACd,OAAwB;QAExB,0EAA0E;QAC1E,4EAA4E;QAC5E,6EAA6E;QAC7E,sCAAsC;QACtC,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YAC3E,MAAM,IAAI,KAAK,CAAC,yBAAyB,IAAI,EAAE,CAAC,CAAC;QACnD,CAAC;QAED,MAAM,WAAW,GAAgB;YAC/B,UAAU,EAAE,OAAO,EAAE,UAAU,IAAI,mBAAmB;YACtD,mBAAmB,EAAE,OAAO,EAAE,mBAAmB,IAAI,8BAA8B;YACnF,YAAY,EAAE,OAAO,EAAE,YAAY,IAAI,sBAAsB;SAC9D,CAAC;QACF,MAAM,gBAAgB,GAAG,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,UAAU,EAAE,WAAW,CAAC,mBAAmB,CAAC,CAAC;QAE3F,4EAA4E;QAC5E,4EAA4E;QAC5E,yEAAyE;QACzE,6EAA6E;QAC7E,4EAA4E;QAC5E,8EAA8E;QAC9E,MAAM,SAAS,GACb,kBAAkB,CAAC,GAAG,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;YAC5C,OAAO,EAAE,UAAU,KAAK,IAAI;YAC5B,CAAC,CAAC,CAAC,OAAO,EAAE,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;QAErG,2EAA2E;QAC3E,4EAA4E;QAC5E,gDAAgD;QAChD,MAAM,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QACzD,MAAM,OAAO,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;QAC1C,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,CAAC;YAC5B,0EAA0E;YAC1E,kEAAkE;YAClE,WAAW,CAAC,oBAAoB,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC,CAAC;YAC/E,MAAM,IAAI,gBAAgB,CAAC,MAAM,CAAC,CAAC;QACrC,CAAC;QAED,IAAI,SAA4B,CAAC;QAEjC,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,gBAAgB,EAAE,OAAO,EAAE,EAAE,CAAC;YAC7D,IAAI,CAAC;gBACH,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAI,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;gBAEpE,MAAM,QAAQ,GAAG,gBAAgB,CAAC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC;gBAC/F,wEAAwE;gBACxE,oEAAoE;gBACpE,IAAI,QAAQ,CAAC,WAAW,IAAI,CAAC,QAAQ,CAAC,UAAU,KAAK,GAAG,IAAI,SAAS,CAAC,EAAE,CAAC;oBACvE,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,GAAG,YAAY,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,GAAG,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;oBAChH,WAAW,CAAC,2BAA2B,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;oBAC7D,MAAM,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;oBACnC,SAAS;gBACX,CAAC;gBAED,wEAAwE;gBACxE,wEAAwE;gBACxE,2EAA2E;gBAC3E,MAAM,aAAa,GAAG,QAAQ,CAAC,UAAU,IAAI,GAAG,IAAI,QAAQ,CAAC,UAAU,IAAI,GAAG,CAAC;gBAC/E,IAAI,aAAa,EAAE,CAAC;oBAClB,OAAO,CAAC,aAAa,EAAE,CAAC;oBACxB,WAAW,CAAC,oBAAoB,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC,CAAC;gBACjF,CAAC;qBAAM,CAAC;oBACN,OAAO,CAAC,aAAa,EAAE,CAAC;oBACxB,WAAW,CAAC,oBAAoB,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC;gBAC5E,CAAC;gBACD,OAAO,QAAQ,CAAC;YAClB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,SAAS,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;gBAEtE,MAAM,QAAQ,GAAG,qBAAqB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;gBAC7D,IAAI,QAAQ,CAAC,WAAW,IAAI,SAAS,EAAE,CAAC;oBACtC,MAAM,CAAC,KAAK,CAAC,sBAAsB,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,CAAC,EAAE,CAAC,CAAC;oBACvG,WAAW,CAAC,2BAA2B,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;oBAC7D,MAAM,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;oBACnC,SAAS;gBACX,CAAC;gBACD,sEAAsE;gBACtE,sEAAsE;gBACtE,OAAO,CAAC,aAAa,EAAE,CAAC;gBACxB,WAAW,CAAC,oBAAoB,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;gBACxE,MAAM,SAAS,CAAC;YAClB,CAAC;QACH,CAAC;QAED,wEAAwE;QACxE,OAAO,CAAC,aAAa,EAAE,CAAC;QACxB,WAAW,CAAC,oBAAoB,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;QACxE,MAAM,SAAU,CAAC;IACnB,CAAC;IAEO,KAAK,CAAC,EAAU;QACtB,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;IACzD,CAAC;IAED;;OAEG;IACK,OAAO,CACb,MAAc,EACd,IAAY,EACZ,IAAc,EACd,OAAwB;QAExB,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,qFAAqF;YACrF,MAAM,OAAO,GAAG,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YAEtE,MAAM,OAAO,GAA6B;gBACxC,cAAc,EAAE,kBAAkB;gBAClC,GAAG,OAAO,EAAE,OAAO;aACpB,CAAC;YAEF,+CAA+C;YAC/C,IAAI,OAAO,EAAE,SAAS,EAAE,CAAC;gBACvB,OAAO,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,SAAS,CAAC;YAC9C,CAAC;YAED,IAAI,OAAO,EAAE,CAAC;gBACZ,OAAO,CAAC,gBAAgB,CAAC,GAAG,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;YACzD,CAAC;YAED,kEAAkE;YAClE,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC3E,MAAM,IAAI,KAAK,CAAC,yBAAyB,IAAI,EAAE,CAAC,CAAC;YACnD,CAAC;YAED,MAAM,cAAc,GAAwB;gBAC1C,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI;gBAC1B,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI;gBACtB,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE;gBAC9C,MAAM;gBACN,OAAO;gBACP,OAAO,EAAE,OAAO,EAAE,OAAO,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO;gBAChD,KAAK,EAAE,IAAI,CAAC,KAAK;aAClB,CAAC;YAEF,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC,GAAG,EAAE,EAAE;gBAC/C,IAAI,IAAI,GAAG,EAAE,CAAC;gBAEd,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE;oBACvB,IAAI,IAAI,KAAK,CAAC;gBAChB,CAAC,CAAC,CAAC;gBAEH,GAAG,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE;oBACjB,IAAI,CAAC;wBACH,MAAM,UAAU,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;wBAChD,OAAO,CAAC;4BACN,UAAU,EAAE,GAAG,CAAC,UAAU,IAAI,UAAU,CAAC,qBAAqB;4BAC9D,IAAI,EAAE,UAAe;4BACrB,OAAO,EAAE,GAAG,CAAC,OAAO;yBACrB,CAAC,CAAC;oBACL,CAAC;oBAAC,OAAO,UAAU,EAAE,CAAC;wBACpB,MAAM,CAAC,IAAI,CAAC,+BAA+B,EAAE;4BAC3C,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI;4BACtB,IAAI;4BACJ,KAAK,EAAE,UAAU,YAAY,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC;yBAC7E,CAAC,CAAC;wBACH,OAAO,CAAC;4BACN,UAAU,EAAE,GAAG,CAAC,UAAU,IAAI,UAAU,CAAC,qBAAqB;4BAC9D,IAAI,EAAE,EAAO;4BACb,OAAO,EAAE,GAAG,CAAC,OAAO;yBACrB,CAAC,CAAC;oBACL,CAAC;gBACH,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;YAEH,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE;gBACxB,uEAAuE;gBACvE,qEAAqE;gBACrE,4CAA4C;gBAC5C,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,IAAK,KAA+B,CAAC,IAAI,IAAI,KAAK,CAAC,IAAI,CAAC;gBACpF,MAAM,CAAC,KAAK,CAAC,qBAAqB,EAAE;oBAClC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI;oBACtB,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI;oBACtB,IAAI;oBACJ,MAAM;oBACN,KAAK,EAAE,MAAM;iBACd,CAAC,CAAC;gBACH,MAAM,CAAC,KAAK,CAAC,CAAC;YAChB,CAAC,CAAC,CAAC;YAEH,GAAG,CAAC,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE;gBACrB,GAAG,CAAC,OAAO,EAAE,CAAC;gBACd,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,yBAAyB,IAAI,CAAC,MAAM,CAAC,OAAO,IAAI,CAAC,CAAC;gBAC1E,MAAM,CAAC,IAAI,CAAC,sBAAsB,EAAE;oBAClC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI;oBACtB,IAAI;oBACJ,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO;iBAC7B,CAAC,CAAC;gBACH,MAAM,CAAC,KAAK,CAAC,CAAC;YAChB,CAAC,CAAC,CAAC;YAEH,IAAI,OAAO,EAAE,CAAC;gBACZ,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YACrB,CAAC;YAED,GAAG,CAAC,GAAG,EAAE,CAAC;QACZ,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AAED;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAqB,EAAE,OAA2B;IACjF,MAAM,MAAM,GAAG,IAAI,kBAAkB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEvD,OAAO;QACL,iFAAiF;QACjF,OAAO;YACL,MAAM,CAAC,OAAO,EAAE,CAAC;QACnB,CAAC;QAED;;WAEG;QACH,KAAK,CAAC,GAAG,CAAI,IAAY,EAAE,OAAwB;YACjD,IAAI,CAAC;gBACH,OAAO,MAAM,MAAM,CAAC,GAAG,CAAI,IAAI,EAAE,OAAO,CAAC,CAAC;YAC5C,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,MAAM,CAAC,KAAK,CAAC,iCAAiC,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBACnH,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;QAED;;WAEG;QACH,KAAK,CAAC,IAAI,CACR,IAAY,EACZ,IAAc,EACd,OAAwB;YAExB,IAAI,CAAC;gBACH,OAAO,MAAM,MAAM,CAAC,IAAI,CAAI,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;YACnD,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,MAAM,CAAC,KAAK,CAAC,kCAAkC,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBACpH,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;QAED;;WAEG;QACH,KAAK,CAAC,GAAG,CACP,IAAY,EACZ,IAAc,EACd,OAAwB;YAExB,IAAI,CAAC;gBACH,OAAO,MAAM,MAAM,CAAC,GAAG,CAAI,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;YAClD,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,MAAM,CAAC,KAAK,CAAC,iCAAiC,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBACnH,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;QAED;;;WAGG;QACH,KAAK,CAAC,MAAM,CACV,IAAY,EACZ,OAAwB;YAExB,IAAI,CAAC;gBACH,OAAO,MAAM,MAAM,CAAC,MAAM,CAAI,IAAI,EAAE,OAAO,CAAC,CAAC;YAC/C,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,MAAM,CAAC,KAAK,CAAC,oCAAoC,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBACtH,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport * as http from 'http';\nimport { getCircuitBreaker, CircuitOpenError } from './circuit-breaker.js';\nimport {\n  DEFAULT_MAX_RETRIES,\n  DEFAULT_RETRY_DELAY_MS,\n  DEFAULT_MAX_RATE_LIMIT_RETRIES,\n  getRetryDecision,\n  getErrorRetryDecision,\n  type RetryConfig,\n} from './retry-strategy.js';\nimport { HttpStatus } from '../constants/http-status.js';\nimport type { ServiceConfig } from '../types/common.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('http-client');\n\n/**\n * Default request timeout in milliseconds (env: `HTTP_CLIENT_TIMEOUT`).\n */\nconst DEFAULT_TIMEOUT = parseInt(process.env.HTTP_CLIENT_TIMEOUT || '5000', 10);\n\n/**\n * Default cap on concurrent keep-alive sockets per client agent\n * (env: `HTTP_CLIENT_MAX_SOCKETS`). Node's default is `Infinity`, which lets a\n * burst of concurrent calls open unbounded sockets against a downstream service\n * (fd exhaustion + connection-storm on the callee). 64 is ample for\n * service-to-service fan-out while staying bounded.\n */\nconst DEFAULT_MAX_SOCKETS = parseInt(process.env.HTTP_CLIENT_MAX_SOCKETS || '64', 10);\n\n// HTTP methods that are idempotent by definition — safe to auto-retry on a\n// 5xx/connection/timeout without risking a duplicate side effect.\nconst IDEMPOTENT_METHODS = new Set(['GET', 'HEAD', 'OPTIONS']);\n\n/**\n * HTTP request options.\n */\nexport interface RequestOptions {\n  /** Request headers */\n  headers?: Record<string, string>;\n  /** Request timeout in milliseconds */\n  timeout?: number;\n  /** Maximum retry attempts for transient failures (default: 2) */\n  maxRetries?: number;\n  /** Base delay between retries in ms — doubles each attempt (default: 200) */\n  retryDelayMs?: number;\n  /** Maximum retry attempts specifically for 429 rate limiting (default: 4) */\n  maxRateLimitRetries?: number;\n  /** Optional request ID for distributed tracing (added as X-Request-Id header) */\n  requestId?: string;\n  /**\n   * Treat this request as safe to auto-retry on 5xx/connection/timeout even\n   * though the method is non-idempotent (e.g. the endpoint is idempotent by an\n   * Idempotency-Key, or the operation is naturally idempotent). Default false:\n   * non-idempotent methods are NOT retried on those failures, only on 429.\n   */\n  idempotent?: boolean;\n}\n\n/**\n * HTTP client response wrapper.\n */\nexport interface HttpClientResponse<T = unknown> {\n  /** HTTP status code */\n  statusCode: number;\n  /** Response body (parsed JSON) */\n  body: T;\n  /** Response headers */\n  headers: http.IncomingHttpHeaders;\n}\n\n/**\n * Internal HTTP client for service-to-service communication.\n *\n * @example\n * ```typescript\n * const client = new InternalHttpClient({\n *   host: 'quota',\n *   port: 3000,\n *   timeout: 5000,\n * });\n *\n * const response = await client.get('/org123/apiCalls');\n * const result = await client.post('/org123/increment', { quotaType: 'apiCalls' });\n * ```\n */\n/**\n * Options controlling the client's connection pool.\n */\nexport interface HttpClientOptions {\n  /**\n   * A shared `http.Agent` to reuse across clients (pools sockets to the same\n   * host). When supplied, the client does NOT own it — {@link InternalHttpClient.destroy}\n   * leaves a borrowed agent untouched so other clients keep working.\n   */\n  agent?: http.Agent;\n  /** Cap on concurrent keep-alive sockets when minting an agent (default 64). */\n  maxSockets?: number;\n}\n\nexport class InternalHttpClient {\n  private config: Required<ServiceConfig>;\n  private agent: http.Agent;\n  /** True only when this client MINTED its agent (so destroy() may tear it down). */\n  private readonly ownsAgent: boolean;\n\n  /**\n   * Create a new HTTP client instance.\n   *\n   * @param config - Service configuration\n   * @param options - Optional connection-pool controls (shared agent / socket cap)\n   */\n  constructor(config: ServiceConfig, options?: HttpClientOptions) {\n    this.config = {\n      host: config.host,\n      port: config.port,\n      timeout: config.timeout ?? DEFAULT_TIMEOUT,\n    };\n    if (options?.agent) {\n      // Borrowed, caller-owned agent — pooled across clients, not ours to destroy.\n      this.agent = options.agent;\n      this.ownsAgent = false;\n    } else {\n      // Own a keep-alive agent with a BOUNDED socket pool (no more Infinity).\n      this.agent = new http.Agent({ keepAlive: true, maxSockets: options?.maxSockets ?? DEFAULT_MAX_SOCKETS });\n      this.ownsAgent = true;\n    }\n  }\n\n  /**\n   * Release the keep-alive socket pool. Idempotent and safe to call on shutdown.\n   * A borrowed (caller-supplied) agent is left intact — only an agent this client\n   * created is destroyed, so tearing down one client can't sever another's pool.\n   */\n  destroy(): void {\n    if (this.ownsAgent) this.agent.destroy();\n  }\n\n  /**\n   * Make a GET request.\n   */\n  async get<T = unknown>(path: string, options?: RequestOptions): Promise<HttpClientResponse<T>> {\n    return this.requestWithRetry<T>('GET', path, undefined, options);\n  }\n\n  /**\n   * Make a POST request.\n   */\n  async post<T = unknown>(\n    path: string,\n    body?: unknown,\n    options?: RequestOptions,\n  ): Promise<HttpClientResponse<T>> {\n    return this.requestWithRetry<T>('POST', path, body, options);\n  }\n\n  /**\n   * Make a PUT request.\n   */\n  async put<T = unknown>(\n    path: string,\n    body?: unknown,\n    options?: RequestOptions,\n  ): Promise<HttpClientResponse<T>> {\n    return this.requestWithRetry<T>('PUT', path, body, options);\n  }\n\n  /**\n   * Make a DELETE request.\n   */\n  async delete<T = unknown>(path: string, options?: RequestOptions): Promise<HttpClientResponse<T>> {\n    return this.requestWithRetry<T>('DELETE', path, undefined, options);\n  }\n\n  /**\n   * Request with retry logic for transient failures.\n   *\n   * - 429 (rate limit): respects `Retry-After` header, uses longer base delay (4x),\n   *   retries up to `maxRateLimitRetries` times (default 4).\n   * - 502/503/504 (server errors): standard exponential backoff, up to `maxRetries` (default 2).\n   * - Connection errors / timeouts: retries up to `maxRetries`.\n   * - All delays include ±25% jitter to prevent thundering herd.\n   */\n  private async requestWithRetry<T>(\n    method: string,\n    path: string,\n    body?: unknown,\n    options?: RequestOptions,\n  ): Promise<HttpClientResponse<T>> {\n    // A malformed path is a CLIENT bug, not a downstream fault — reject it up\n    // front so it never burns retries or feeds the circuit breaker (which would\n    // otherwise shed traffic to a perfectly healthy downstream). request() keeps\n    // the same guard as defence-in-depth.\n    if (path.includes('://') || path.startsWith('//') || /[\\r\\n\\0]/.test(path)) {\n      throw new Error(`Invalid request path: ${path}`);\n    }\n\n    const retryConfig: RetryConfig = {\n      maxRetries: options?.maxRetries ?? DEFAULT_MAX_RETRIES,\n      maxRateLimitRetries: options?.maxRateLimitRetries ?? DEFAULT_MAX_RATE_LIMIT_RETRIES,\n      retryDelayMs: options?.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS,\n    };\n    const totalMaxAttempts = Math.max(retryConfig.maxRetries, retryConfig.maxRateLimitRetries);\n\n    // Whether it's safe to auto-retry this request on a 5xx/connection/timeout.\n    // A timed-out POST may have already been processed server-side, so retrying\n    // a non-idempotent request risks a DUPLICATE side effect (double-charge,\n    // double-create). Only GET/HEAD/OPTIONS, an explicit `idempotent` opt-in, or\n    // a request carrying an Idempotency-Key are auto-retried on those failures.\n    // (429 is always retried — see below — since it was rejected, not processed.)\n    const retrySafe =\n      IDEMPOTENT_METHODS.has(method.toUpperCase()) ||\n      options?.idempotent === true ||\n      !!(options?.headers && (options.headers['Idempotency-Key'] || options.headers['idempotency-key']));\n\n    // Per-target circuit breaker + S2S request metrics. `target` is the shared\n    // breaker/metric key so one bad downstream trips once (not once-per-client)\n    // and dashboards can see S2S health per callee.\n    const target = `${this.config.host}:${this.config.port}`;\n    const breaker = getCircuitBreaker(target);\n    if (!breaker.allowRequest()) {\n      // Fast-fail without touching the network — this is the load-shedding that\n      // prevents a downstream brownout from cascading via retry storms.\n      emitCounter('s2s_requests_total', { target, method, outcome: 'circuit_open' });\n      throw new CircuitOpenError(target);\n    }\n\n    let lastError: Error | undefined;\n\n    for (let attempt = 0; attempt <= totalMaxAttempts; attempt++) {\n      try {\n        const response = await this.request<T>(method, path, body, options);\n\n        const decision = getRetryDecision(response.statusCode, response.headers, attempt, retryConfig);\n        // 429 is safe to retry for ANY method (rate-limited → not processed); a\n        // 5xx/gateway error is only retried when the request is retry-safe.\n        if (decision.shouldRetry && (response.statusCode === 429 || retrySafe)) {\n          logger.debug(decision.reason + ', retrying', { method, path, attempt: attempt + 1, delayMs: decision.delayMs });\n          emitCounter('s2s_request_retries_total', { target, method });\n          await this.sleep(decision.delayMs);\n          continue;\n        }\n\n        // Terminal response. A 5xx is a downstream fault (feeds the breaker); a\n        // 429 is backpressure, not a fault — the service answered, so it counts\n        // as success for breaker purposes (never trip the breaker on rate limits).\n        const isServerFault = response.statusCode >= 500 && response.statusCode <= 599;\n        if (isServerFault) {\n          breaker.recordFailure();\n          emitCounter('s2s_requests_total', { target, method, outcome: 'server_error' });\n        } else {\n          breaker.recordSuccess();\n          emitCounter('s2s_requests_total', { target, method, outcome: 'success' });\n        }\n        return response;\n      } catch (error) {\n        lastError = error instanceof Error ? error : new Error(String(error));\n\n        const decision = getErrorRetryDecision(attempt, retryConfig);\n        if (decision.shouldRetry && retrySafe) {\n          logger.debug('Retrying after error', { method, path, error: lastError.message, attempt: attempt + 1 });\n          emitCounter('s2s_request_retries_total', { target, method });\n          await this.sleep(decision.delayMs);\n          continue;\n        }\n        // Not retrying (non-idempotent, or attempts exhausted) — a connection\n        // error/timeout is a downstream fault: feed the breaker and fail now.\n        breaker.recordFailure();\n        emitCounter('s2s_requests_total', { target, method, outcome: 'error' });\n        throw lastError;\n      }\n    }\n\n    // Loop exhausted without returning (all attempts retried then ran out).\n    breaker.recordFailure();\n    emitCounter('s2s_requests_total', { target, method, outcome: 'error' });\n    throw lastError!;\n  }\n\n  private sleep(ms: number): Promise<void> {\n    return new Promise(resolve => setTimeout(resolve, ms));\n  }\n\n  /**\n   * Internal request method.\n   */\n  private request<T>(\n    method: string,\n    path: string,\n    body?: unknown,\n    options?: RequestOptions,\n  ): Promise<HttpClientResponse<T>> {\n    return new Promise((resolve, reject) => {\n      // Serialize when body is defined (including 0/false/'' which are valid JSON values).\n      const bodyStr = body !== undefined ? JSON.stringify(body) : undefined;\n\n      const headers: http.OutgoingHttpHeaders = {\n        'Content-Type': 'application/json',\n        ...options?.headers,\n      };\n\n      // Propagate request ID for distributed tracing\n      if (options?.requestId) {\n        headers['X-Request-Id'] = options.requestId;\n      }\n\n      if (bodyStr) {\n        headers['Content-Length'] = Buffer.byteLength(bodyStr);\n      }\n\n      // Validate path to prevent protocol injection / request smuggling\n      if (path.includes('://') || path.startsWith('//') || /[\\r\\n\\0]/.test(path)) {\n        throw new Error(`Invalid request path: ${path}`);\n      }\n\n      const requestOptions: http.RequestOptions = {\n        hostname: this.config.host,\n        port: this.config.port,\n        path: path.startsWith('/') ? path : `/${path}`,\n        method,\n        headers,\n        timeout: options?.timeout ?? this.config.timeout,\n        agent: this.agent,\n      };\n\n      const req = http.request(requestOptions, (res) => {\n        let data = '';\n\n        res.on('data', (chunk) => {\n          data += chunk;\n        });\n\n        res.on('end', () => {\n          try {\n            const parsedBody = data ? JSON.parse(data) : {};\n            resolve({\n              statusCode: res.statusCode || HttpStatus.INTERNAL_SERVER_ERROR,\n              body: parsedBody as T,\n              headers: res.headers,\n            });\n          } catch (parseError) {\n            logger.warn('Failed to parse response body', {\n              host: this.config.host,\n              path,\n              error: parseError instanceof Error ? parseError.message : String(parseError),\n            });\n            resolve({\n              statusCode: res.statusCode || HttpStatus.INTERNAL_SERVER_ERROR,\n              body: {} as T,\n              headers: res.headers,\n            });\n          }\n        });\n      });\n\n      req.on('error', (error) => {\n        // Node dual-stack connect failures are an AggregateError with an empty\n        // `.message`; the cause is in `.code` (ECONNREFUSED/ETIMEDOUT). Fall\n        // back so the log isn't a blank `error:\"\"`.\n        const detail = error.message || (error as NodeJS.ErrnoException).code || error.name;\n        logger.error('HTTP request failed', {\n          host: this.config.host,\n          port: this.config.port,\n          path,\n          method,\n          error: detail,\n        });\n        reject(error);\n      });\n\n      req.on('timeout', () => {\n        req.destroy();\n        const error = new Error(`Request timeout after ${this.config.timeout}ms`);\n        logger.warn('HTTP request timeout', {\n          host: this.config.host,\n          path,\n          timeout: this.config.timeout,\n        });\n        reject(error);\n      });\n\n      if (bodyStr) {\n        req.write(bodyStr);\n      }\n\n      req.end();\n    });\n  }\n}\n\n/**\n * Create an HTTP client with error handling that returns null on failure.\n * Useful for fail-open scenarios.\n *\n * @param config - Service configuration\n * @returns Client wrapper with safe methods\n */\nexport function createSafeClient(config: ServiceConfig, options?: HttpClientOptions) {\n  const client = new InternalHttpClient(config, options);\n\n  return {\n    /** Release the underlying keep-alive socket pool (no-op on a borrowed agent). */\n    destroy(): void {\n      client.destroy();\n    },\n\n    /**\n     * Safe GET request - returns null on error.\n     */\n    async get<T>(path: string, options?: RequestOptions): Promise<HttpClientResponse<T> | null> {\n      try {\n        return await client.get<T>(path, options);\n      } catch (err) {\n        logger.debug('Safe GET failed, returning null', { path, error: err instanceof Error ? err.message : String(err) });\n        return null;\n      }\n    },\n\n    /**\n     * Safe POST request - returns null on error.\n     */\n    async post<T>(\n      path: string,\n      body?: unknown,\n      options?: RequestOptions,\n    ): Promise<HttpClientResponse<T> | null> {\n      try {\n        return await client.post<T>(path, body, options);\n      } catch (err) {\n        logger.debug('Safe POST failed, returning null', { path, error: err instanceof Error ? err.message : String(err) });\n        return null;\n      }\n    },\n\n    /**\n     * Safe PUT request - returns null on error.\n     */\n    async put<T>(\n      path: string,\n      body?: unknown,\n      options?: RequestOptions,\n    ): Promise<HttpClientResponse<T> | null> {\n      try {\n        return await client.put<T>(path, body, options);\n      } catch (err) {\n        logger.debug('Safe PUT failed, returning null', { path, error: err instanceof Error ? err.message : String(err) });\n        return null;\n      }\n    },\n\n    /**\n     * Safe DELETE request - returns null on error. Used by destructive\n     * cross-service operations (e.g. org-cascade delete in platform).\n     */\n    async delete<T>(\n      path: string,\n      options?: RequestOptions,\n    ): Promise<HttpClientResponse<T> | null> {\n      try {\n        return await client.delete<T>(path, options);\n      } catch (err) {\n        logger.debug('Safe DELETE failed, returning null', { path, error: err instanceof Error ? err.message : String(err) });\n        return null;\n      }\n    },\n  };\n}\n"]}

package/lib/services/index.d.ts

@@ -5,6 +5,8 @@ export * from './compliance-client.js';
 export * from './compliance-event-subscriber.js';
 export * from './entity-events.js';
 export * from './http-client.js';
+export * from './circuit-breaker.js';
+export * from './durable-event-bus.js';
 export { DEFAULT_MAX_RETRIES, DEFAULT_RETRY_DELAY_MS, DEFAULT_MAX_RATE_LIMIT_RETRIES, calculateBackoff, getRetryDecision, getErrorRetryDecision, } from './retry-strategy.js';
 export type { RetryConfig, RetryDecision } from './retry-strategy.js';
 export * from './quota.js';