@pipeline-builder/api-core 3.1.0

package/lib/services/compliance-queue.js

@@ -0,0 +1,38 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerComplianceQueueBackend = registerComplianceQueueBackend;
+exports.enqueueComplianceEvent = enqueueComplianceEvent;
+const logger_1 = require("../utils/logger");
+const logger = (0, logger_1.createLogger)('compliance-queue');
+/**
+ * Pluggable compliance event queue.
+ * Services register a backend (BullMQ, SQS, or in-memory) at startup.
+ * If no backend is registered, events are logged and discarded.
+ */
+let enqueueFn = null;
+function registerComplianceQueueBackend(fn) {
+    enqueueFn = fn;
+    logger.info('Compliance queue backend registered');
+}
+async function enqueueComplianceEvent(event) {
+    if (!enqueueFn) {
+        logger.debug('Compliance event discarded (no queue backend registered)', {
+            eventType: event.eventType, target: event.target, entityId: event.entityId,
+        });
+        return;
+    }
+    try {
+        await enqueueFn(event);
+        logger.debug('Compliance event enqueued', { eventType: event.eventType, target: event.target, entityId: event.entityId });
+    }
+    catch (err) {
+        logger.warn('Failed to enqueue compliance event', {
+            eventType: event.eventType,
+            entityId: event.entityId,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/lib/services/entity-events.js

@@ -0,0 +1,63 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.entityEvents = void 0;
+/**
+ * Lightweight in-process event emitter for entity lifecycle events.
+ *
+ * Services emit events after mutations (create/update/delete) via CrudService hooks.
+ * Subscribers react asynchronously to entity changes.
+ *
+ * Active subscribers:
+ * - **Compliance event subscriber** (`registerComplianceEventSubscriber()`) — forwards
+ *   entity events to the compliance service for post-mutation rule evaluation.
+ *   Registered at startup in plugin and pipeline service index.ts.
+ *
+ * Design:
+ * - Fire-and-forget: emit() never throws, subscriber errors are logged
+ * - In-process only: no network, no Redis, no infrastructure
+ * - Subscribers run async: never block the original request
+ */
+const logger_1 = require("../utils/logger");
+const logger = (0, logger_1.createLogger)('entity-events');
+class EntityEventEmitter {
+    subscribers = [];
+    /**
+     * Register a subscriber to receive entity events.
+     */
+    subscribe(subscriber) {
+        this.subscribers.push(subscriber);
+    }
+    /**
+     * Remove a subscriber.
+     */
+    unsubscribe(subscriber) {
+        this.subscribers = this.subscribers.filter((s) => s !== subscriber);
+    }
+    /**
+     * Emit an entity event to all subscribers.
+     * Fire-and-forget: errors are caught and logged, never thrown.
+     */
+    emit(event) {
+        for (const subscriber of this.subscribers) {
+            subscriber.onEntityEvent(event).catch((err) => {
+                logger.debug('Entity event subscriber failed', {
+                    target: event.target,
+                    eventType: event.eventType,
+                    entityId: event.entityId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            });
+        }
+    }
+    /**
+     * Get the current subscriber count (for testing/diagnostics).
+     */
+    get subscriberCount() {
+        return this.subscribers.length;
+    }
+}
+/** Singleton entity event emitter — shared across the process */
+exports.entityEvents = new EntityEventEmitter();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50aXR5LWV2ZW50cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zZXJ2aWNlcy9lbnRpdHktZXZlbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDOzs7QUFFdEM7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsNENBQStDO0FBRS9DLE1BQU0sTUFBTSxHQUFHLElBQUEscUJBQVksRUFBQyxlQUFlLENBQUMsQ0FBQztBQTBCN0MsTUFBTSxrQkFBa0I7SUFDZCxXQUFXLEdBQTRCLEVBQUUsQ0FBQztJQUVsRDs7T0FFRztJQUNILFNBQVMsQ0FBQyxVQUFpQztRQUN6QyxJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQztJQUNwQyxDQUFDO0lBRUQ7O09BRUc7SUFDSCxXQUFXLENBQUMsVUFBaUM7UUFDM0MsSUFBSSxDQUFDLFdBQVcsR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxLQUFLLFVBQVUsQ0FBQyxDQUFDO0lBQ3RFLENBQUM7SUFFRDs7O09BR0c7SUFDSCxJQUFJLENBQUMsS0FBa0I7UUFDckIsS0FBSyxNQUFNLFVBQVUsSUFBSSxJQUFJLENBQUMsV0FBVyxFQUFFLENBQUM7WUFDMUMsVUFBVSxDQUFDLGFBQWEsQ0FBQyxLQUFLLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRTtnQkFDNUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxnQ0FBZ0MsRUFBRTtvQkFDN0MsTUFBTSxFQUFFLEtBQUssQ0FBQyxNQUFNO29CQUNwQixTQUFTLEVBQUUsS0FBSyxDQUFDLFNBQVM7b0JBQzFCLFFBQVEsRUFBRSxLQUFLLENBQUMsUUFBUTtvQkFDeEIsS0FBSyxFQUFFLEdBQUcsWUFBWSxLQUFLLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUM7aUJBQ3hELENBQUMsQ0FBQztZQUNMLENBQUMsQ0FBQyxDQUFDO1FBQ0wsQ0FBQztJQUNILENBQUM7SUFFRDs7T0FFRztJQUNILElBQUksZUFBZTtRQUNqQixPQUFPLElBQUksQ0FBQyxXQUFXLENBQUMsTUFBTSxDQUFDO0lBQ2pDLENBQUM7Q0FDRjtBQUVELGlFQUFpRTtBQUNwRCxRQUFBLFlBQVksR0FBRyxJQUFJLGtCQUFrQixFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuLyoqXG4gKiBMaWdodHdlaWdodCBpbi1wcm9jZXNzIGV2ZW50IGVtaXR0ZXIgZm9yIGVudGl0eSBsaWZlY3ljbGUgZXZlbnRzLlxuICpcbiAqIFNlcnZpY2VzIGVtaXQgZXZlbnRzIGFmdGVyIG11dGF0aW9ucyAoY3JlYXRlL3VwZGF0ZS9kZWxldGUpIHZpYSBDcnVkU2VydmljZSBob29rcy5cbiAqIFN1YnNjcmliZXJzIHJlYWN0IGFzeW5jaHJvbm91c2x5IHRvIGVudGl0eSBjaGFuZ2VzLlxuICpcbiAqIEFjdGl2ZSBzdWJzY3JpYmVyczpcbiAqIC0gKipDb21wbGlhbmNlIGV2ZW50IHN1YnNjcmliZXIqKiAoYHJlZ2lzdGVyQ29tcGxpYW5jZUV2ZW50U3Vic2NyaWJlcigpYCkg4oCUIGZvcndhcmRzXG4gKiAgIGVudGl0eSBldmVudHMgdG8gdGhlIGNvbXBsaWFuY2Ugc2VydmljZSBmb3IgcG9zdC1tdXRhdGlvbiBydWxlIGV2YWx1YXRpb24uXG4gKiAgIFJlZ2lzdGVyZWQgYXQgc3RhcnR1cCBpbiBwbHVnaW4gYW5kIHBpcGVsaW5lIHNlcnZpY2UgaW5kZXgudHMuXG4gKlxuICogRGVzaWduOlxuICogLSBGaXJlLWFuZC1mb3JnZXQ6IGVtaXQoKSBuZXZlciB0aHJvd3MsIHN1YnNjcmliZXIgZXJyb3JzIGFyZSBsb2dnZWRcbiAqIC0gSW4tcHJvY2VzcyBvbmx5OiBubyBuZXR3b3JrLCBubyBSZWRpcywgbm8gaW5mcmFzdHJ1Y3R1cmVcbiAqIC0gU3Vic2NyaWJlcnMgcnVuIGFzeW5jOiBuZXZlciBibG9jayB0aGUgb3JpZ2luYWwgcmVxdWVzdFxuICovXG5cbmltcG9ydCB7IGNyZWF0ZUxvZ2dlciB9IGZyb20gJy4uL3V0aWxzL2xvZ2dlcic7XG5cbmNvbnN0IGxvZ2dlciA9IGNyZWF0ZUxvZ2dlcignZW50aXR5LWV2ZW50cycpO1xuXG5leHBvcnQgdHlwZSBFbnRpdHlFdmVudFR5cGUgPSAnY3JlYXRlZCcgfCAndXBkYXRlZCcgfCAnZGVsZXRlZCc7XG5leHBvcnQgdHlwZSBFbnRpdHlUYXJnZXQgPSAncGx1Z2luJyB8ICdwaXBlbGluZScgfCAnbWVzc2FnZScgfCAnb3JnYW5pemF0aW9uJyB8ICd1c2VyJztcblxuZXhwb3J0IGludGVyZmFjZSBFbnRpdHlFdmVudCB7XG4gIC8qKiBUaGUgdHlwZSBvZiBtdXRhdGlvbiB0aGF0IG9jY3VycmVkICovXG4gIGV2ZW50VHlwZTogRW50aXR5RXZlbnRUeXBlO1xuICAvKiogVGhlIGVudGl0eSB0eXBlIHRoYXQgd2FzIG11dGF0ZWQgKi9cbiAgdGFyZ2V0OiBFbnRpdHlUYXJnZXQ7XG4gIC8qKiBUaGUgZW50aXR5J3MgdW5pcXVlIElEICovXG4gIGVudGl0eUlkOiBzdHJpbmc7XG4gIC8qKiBUaGUgb3JnYW5pemF0aW9uIHRoYXQgb3ducyB0aGlzIGVudGl0eSAqL1xuICBvcmdJZDogc3RyaW5nO1xuICAvKiogVGhlIHVzZXIgd2hvIHBlcmZvcm1lZCB0aGUgbXV0YXRpb24gKi9cbiAgdXNlcklkOiBzdHJpbmc7XG4gIC8qKiBXaGVuIHRoZSBldmVudCBvY2N1cnJlZCAqL1xuICB0aW1lc3RhbXA6IERhdGU7XG4gIC8qKiBTbmFwc2hvdCBvZiBlbnRpdHkgYXR0cmlidXRlcyAoZm9yIGNvbXBsaWFuY2UgZXZhbHVhdGlvbikgKi9cbiAgYXR0cmlidXRlczogUmVjb3JkPHN0cmluZywgdW5rbm93bj47XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRW50aXR5RXZlbnRTdWJzY3JpYmVyIHtcbiAgb25FbnRpdHlFdmVudChldmVudDogRW50aXR5RXZlbnQpOiBQcm9taXNlPHZvaWQ+O1xufVxuXG5jbGFzcyBFbnRpdHlFdmVudEVtaXR0ZXIge1xuICBwcml2YXRlIHN1YnNjcmliZXJzOiBFbnRpdHlFdmVudFN1YnNjcmliZXJbXSA9IFtdO1xuXG4gIC8qKlxuICAgKiBSZWdpc3RlciBhIHN1YnNjcmliZXIgdG8gcmVjZWl2ZSBlbnRpdHkgZXZlbnRzLlxuICAgKi9cbiAgc3Vic2NyaWJlKHN1YnNjcmliZXI6IEVudGl0eUV2ZW50U3Vic2NyaWJlcik6IHZvaWQge1xuICAgIHRoaXMuc3Vic2NyaWJlcnMucHVzaChzdWJzY3JpYmVyKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBSZW1vdmUgYSBzdWJzY3JpYmVyLlxuICAgKi9cbiAgdW5zdWJzY3JpYmUoc3Vic2NyaWJlcjogRW50aXR5RXZlbnRTdWJzY3JpYmVyKTogdm9pZCB7XG4gICAgdGhpcy5zdWJzY3JpYmVycyA9IHRoaXMuc3Vic2NyaWJlcnMuZmlsdGVyKChzKSA9PiBzICE9PSBzdWJzY3JpYmVyKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBFbWl0IGFuIGVudGl0eSBldmVudCB0byBhbGwgc3Vic2NyaWJlcnMuXG4gICAqIEZpcmUtYW5kLWZvcmdldDogZXJyb3JzIGFyZSBjYXVnaHQgYW5kIGxvZ2dlZCwgbmV2ZXIgdGhyb3duLlxuICAgKi9cbiAgZW1pdChldmVudDogRW50aXR5RXZlbnQpOiB2b2lkIHtcbiAgICBmb3IgKGNvbnN0IHN1YnNjcmliZXIgb2YgdGhpcy5zdWJzY3JpYmVycykge1xuICAgICAgc3Vic2NyaWJlci5vbkVudGl0eUV2ZW50KGV2ZW50KS5jYXRjaCgoZXJyKSA9PiB7XG4gICAgICAgIGxvZ2dlci5kZWJ1ZygnRW50aXR5IGV2ZW50IHN1YnNjcmliZXIgZmFpbGVkJywge1xuICAgICAgICAgIHRhcmdldDogZXZlbnQudGFyZ2V0LFxuICAgICAgICAgIGV2ZW50VHlwZTogZXZlbnQuZXZlbnRUeXBlLFxuICAgICAgICAgIGVudGl0eUlkOiBldmVudC5lbnRpdHlJZCxcbiAgICAgICAgICBlcnJvcjogZXJyIGluc3RhbmNlb2YgRXJyb3IgPyBlcnIubWVzc2FnZSA6IFN0cmluZyhlcnIpLFxuICAgICAgICB9KTtcbiAgICAgIH0pO1xuICAgIH1cbiAgfVxuXG4gIC8qKlxuICAgKiBHZXQgdGhlIGN1cnJlbnQgc3Vic2NyaWJlciBjb3VudCAoZm9yIHRlc3RpbmcvZGlhZ25vc3RpY3MpLlxuICAgKi9cbiAgZ2V0IHN1YnNjcmliZXJDb3VudCgpOiBudW1iZXIge1xuICAgIHJldHVybiB0aGlzLnN1YnNjcmliZXJzLmxlbmd0aDtcbiAgfVxufVxuXG4vKiogU2luZ2xldG9uIGVudGl0eSBldmVudCBlbWl0dGVyIOKAlCBzaGFyZWQgYWNyb3NzIHRoZSBwcm9jZXNzICovXG5leHBvcnQgY29uc3QgZW50aXR5RXZlbnRzID0gbmV3IEVudGl0eUV2ZW50RW1pdHRlcigpO1xuIl19

package/lib/services/http-client.d.ts

@@ -0,0 +1,108 @@
+import * as http from 'http';
+import { ServiceConfig } from '../types/common';
+export { parseRetryAfter, addJitter } from './retry-strategy';
+/**
+ * HTTP request options.
+ */
+export interface RequestOptions {
+    /** Request headers */
+    headers?: Record<string, string>;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Maximum retry attempts for transient failures (default: 2) */
+    maxRetries?: number;
+    /** Base delay between retries in ms — doubles each attempt (default: 200) */
+    retryDelayMs?: number;
+    /** Maximum retry attempts specifically for 429 rate limiting (default: 4) */
+    maxRateLimitRetries?: number;
+    /** Optional request ID for distributed tracing (added as X-Request-Id header) */
+    requestId?: string;
+}
+/**
+ * HTTP client response wrapper.
+ */
+export interface HttpClientResponse<T = unknown> {
+    /** HTTP status code */
+    statusCode: number;
+    /** Response body (parsed JSON) */
+    body: T;
+    /** Response headers */
+    headers: http.IncomingHttpHeaders;
+}
+/**
+ * Internal HTTP client for service-to-service communication.
+ *
+ * @example
+ * ```typescript
+ * const client = new InternalHttpClient({
+ *   host: 'quota',
+ *   port: 3000,
+ *   timeout: 5000,
+ * });
+ *
+ * const response = await client.get('/org123/apiCalls');
+ * const result = await client.post('/org123/increment', { quotaType: 'apiCalls' });
+ * ```
+ */
+export declare class InternalHttpClient {
+    private config;
+    private agent;
+    /**
+     * Create a new HTTP client instance.
+     *
+     * @param config - Service configuration
+     */
+    constructor(config: ServiceConfig);
+    /**
+     * Make a GET request.
+     */
+    get<T = unknown>(path: string, options?: RequestOptions): Promise<HttpClientResponse<T>>;
+    /**
+     * Make a POST request.
+     */
+    post<T = unknown>(path: string, body?: unknown, options?: RequestOptions): Promise<HttpClientResponse<T>>;
+    /**
+     * Make a PUT request.
+     */
+    put<T = unknown>(path: string, body?: unknown, options?: RequestOptions): Promise<HttpClientResponse<T>>;
+    /**
+     * Make a DELETE request.
+     */
+    delete<T = unknown>(path: string, options?: RequestOptions): Promise<HttpClientResponse<T>>;
+    /**
+     * Request with retry logic for transient failures.
+     *
+     * - 429 (rate limit): respects `Retry-After` header, uses longer base delay (4x),
+     *   retries up to `maxRateLimitRetries` times (default 4).
+     * - 502/503/504 (server errors): standard exponential backoff, up to `maxRetries` (default 2).
+     * - Connection errors / timeouts: retries up to `maxRetries`.
+     * - All delays include ±25% jitter to prevent thundering herd.
+     */
+    private requestWithRetry;
+    private sleep;
+    /**
+     * Internal request method.
+     */
+    private request;
+}
+/**
+ * Create an HTTP client with error handling that returns null on failure.
+ * Useful for fail-open scenarios.
+ *
+ * @param config - Service configuration
+ * @returns Client wrapper with safe methods
+ */
+export declare function createSafeClient(config: ServiceConfig): {
+    /**
+     * Safe GET request - returns null on error.
+     */
+    get<T>(path: string, options?: RequestOptions): Promise<HttpClientResponse<T> | null>;
+    /**
+     * Safe POST request - returns null on error.
+     */
+    post<T>(path: string, body?: unknown, options?: RequestOptions): Promise<HttpClientResponse<T> | null>;
+    /**
+     * Safe PUT request - returns null on error.
+     */
+    put<T>(path: string, body?: unknown, options?: RequestOptions): Promise<HttpClientResponse<T> | null>;
+};

package/lib/services/http-client.js

@@ -0,0 +1,285 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalHttpClient = exports.addJitter = exports.parseRetryAfter = void 0;
+exports.createSafeClient = createSafeClient;
+const http = __importStar(require("http"));
+const retry_strategy_1 = require("./retry-strategy");
+const http_status_1 = require("../constants/http-status");
+const logger_1 = require("../utils/logger");
+// Re-export retry utilities for backward compatibility
+var retry_strategy_2 = require("./retry-strategy");
+Object.defineProperty(exports, "parseRetryAfter", { enumerable: true, get: function () { return retry_strategy_2.parseRetryAfter; } });
+Object.defineProperty(exports, "addJitter", { enumerable: true, get: function () { return retry_strategy_2.addJitter; } });
+const logger = (0, logger_1.createLogger)('http-client');
+/**
+ * Default request timeout in milliseconds (env: `HTTP_CLIENT_TIMEOUT`).
+ */
+const DEFAULT_TIMEOUT = parseInt(process.env.HTTP_CLIENT_TIMEOUT || '5000', 10);
+/**
+ * Internal HTTP client for service-to-service communication.
+ *
+ * @example
+ * ```typescript
+ * const client = new InternalHttpClient({
+ *   host: 'quota',
+ *   port: 3000,
+ *   timeout: 5000,
+ * });
+ *
+ * const response = await client.get('/org123/apiCalls');
+ * const result = await client.post('/org123/increment', { quotaType: 'apiCalls' });
+ * ```
+ */
+class InternalHttpClient {
+    config;
+    agent;
+    /**
+     * Create a new HTTP client instance.
+     *
+     * @param config - Service configuration
+     */
+    constructor(config) {
+        this.config = {
+            host: config.host,
+            port: config.port,
+            timeout: config.timeout ?? DEFAULT_TIMEOUT,
+        };
+        this.agent = new http.Agent({ keepAlive: true });
+    }
+    /**
+     * Make a GET request.
+     */
+    async get(path, options) {
+        return this.requestWithRetry('GET', path, undefined, options);
+    }
+    /**
+     * Make a POST request.
+     */
+    async post(path, body, options) {
+        return this.requestWithRetry('POST', path, body, options);
+    }
+    /**
+     * Make a PUT request.
+     */
+    async put(path, body, options) {
+        return this.requestWithRetry('PUT', path, body, options);
+    }
+    /**
+     * Make a DELETE request.
+     */
+    async delete(path, options) {
+        return this.requestWithRetry('DELETE', path, undefined, options);
+    }
+    /**
+     * Request with retry logic for transient failures.
+     *
+     * - 429 (rate limit): respects `Retry-After` header, uses longer base delay (4x),
+     *   retries up to `maxRateLimitRetries` times (default 4).
+     * - 502/503/504 (server errors): standard exponential backoff, up to `maxRetries` (default 2).
+     * - Connection errors / timeouts: retries up to `maxRetries`.
+     * - All delays include ±25% jitter to prevent thundering herd.
+     */
+    async requestWithRetry(method, path, body, options) {
+        const retryConfig = {
+            maxRetries: options?.maxRetries ?? retry_strategy_1.DEFAULT_MAX_RETRIES,
+            maxRateLimitRetries: options?.maxRateLimitRetries ?? retry_strategy_1.DEFAULT_MAX_RATE_LIMIT_RETRIES,
+            retryDelayMs: options?.retryDelayMs ?? retry_strategy_1.DEFAULT_RETRY_DELAY_MS,
+        };
+        const totalMaxAttempts = Math.max(retryConfig.maxRetries, retryConfig.maxRateLimitRetries);
+        let lastError;
+        for (let attempt = 0; attempt <= totalMaxAttempts; attempt++) {
+            try {
+                const response = await this.request(method, path, body, options);
+                const decision = (0, retry_strategy_1.getRetryDecision)(response.statusCode, response.headers, attempt, retryConfig);
+                if (decision.shouldRetry) {
+                    logger.debug(decision.reason + ', retrying', { method, path, attempt: attempt + 1, delayMs: decision.delayMs });
+                    await this.sleep(decision.delayMs);
+                    continue;
+                }
+                return response;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                const decision = (0, retry_strategy_1.getErrorRetryDecision)(attempt, retryConfig);
+                if (decision.shouldRetry) {
+                    logger.debug('Retrying after error', { method, path, error: lastError.message, attempt: attempt + 1 });
+                    await this.sleep(decision.delayMs);
+                    continue;
+                }
+            }
+        }
+        throw lastError;
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Internal request method.
+     */
+    request(method, path, body, options) {
+        return new Promise((resolve, reject) => {
+            const bodyStr = body ? JSON.stringify(body) : undefined;
+            const headers = {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+            };
+            // Propagate request ID for distributed tracing
+            if (options?.requestId) {
+                headers['X-Request-Id'] = options.requestId;
+            }
+            if (bodyStr) {
+                headers['Content-Length'] = Buffer.byteLength(bodyStr);
+            }
+            // Validate path to prevent protocol injection / request smuggling
+            if (path.includes('://') || path.startsWith('//') || /[\r\n\0]/.test(path)) {
+                throw new Error(`Invalid request path: ${path}`);
+            }
+            const requestOptions = {
+                hostname: this.config.host,
+                port: this.config.port,
+                path: path.startsWith('/') ? path : `/${path}`,
+                method,
+                headers,
+                timeout: options?.timeout ?? this.config.timeout,
+                agent: this.agent,
+            };
+            const req = http.request(requestOptions, (res) => {
+                let data = '';
+                res.on('data', (chunk) => {
+                    data += chunk;
+                });
+                res.on('end', () => {
+                    try {
+                        const parsedBody = data ? JSON.parse(data) : {};
+                        resolve({
+                            statusCode: res.statusCode || http_status_1.HttpStatus.INTERNAL_SERVER_ERROR,
+                            body: parsedBody,
+                            headers: res.headers,
+                        });
+                    }
+                    catch (parseError) {
+                        logger.warn('Failed to parse response body', {
+                            host: this.config.host,
+                            path,
+                            error: parseError instanceof Error ? parseError.message : String(parseError),
+                        });
+                        resolve({
+                            statusCode: res.statusCode || http_status_1.HttpStatus.INTERNAL_SERVER_ERROR,
+                            body: {},
+                            headers: res.headers,
+                        });
+                    }
+                });
+            });
+            req.on('error', (error) => {
+                logger.error('HTTP request failed', {
+                    host: this.config.host,
+                    port: this.config.port,
+                    path,
+                    method,
+                    error: error.message,
+                });
+                reject(error);
+            });
+            req.on('timeout', () => {
+                req.destroy();
+                const error = new Error(`Request timeout after ${this.config.timeout}ms`);
+                logger.warn('HTTP request timeout', {
+                    host: this.config.host,
+                    path,
+                    timeout: this.config.timeout,
+                });
+                reject(error);
+            });
+            if (bodyStr) {
+                req.write(bodyStr);
+            }
+            req.end();
+        });
+    }
+}
+exports.InternalHttpClient = InternalHttpClient;
+/**
+ * Create an HTTP client with error handling that returns null on failure.
+ * Useful for fail-open scenarios.
+ *
+ * @param config - Service configuration
+ * @returns Client wrapper with safe methods
+ */
+function createSafeClient(config) {
+    const client = new InternalHttpClient(config);
+    return {
+        /**
+         * Safe GET request - returns null on error.
+         */
+        async get(path, options) {
+            try {
+                return await client.get(path, options);
+            }
+            catch (err) {
+                logger.debug('Safe GET failed, returning null', { path, error: err instanceof Error ? err.message : String(err) });
+                return null;
+            }
+        },
+        /**
+         * Safe POST request - returns null on error.
+         */
+        async post(path, body, options) {
+            try {
+                return await client.post(path, body, options);
+            }
+            catch (err) {
+                logger.debug('Safe POST failed, returning null', { path, error: err instanceof Error ? err.message : String(err) });
+                return null;
+            }
+        },
+        /**
+         * Safe PUT request - returns null on error.
+         */
+        async put(path, body, options) {
+            try {
+                return await client.put(path, body, options);
+            }
+            catch (err) {
+                logger.debug('Safe PUT failed, returning null', { path, error: err instanceof Error ? err.message : String(err) });
+                return null;
+            }
+        },
+    };
+}
+//# 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  RetryConfig,\n} from './retry-strategy';\nimport { HttpStatus } from '../constants/http-status';\nimport { ServiceConfig } from '../types/common';\nimport { createLogger } from '../utils/logger';\n\n// Re-export retry utilities for backward compatibility\nexport { parseRetryAfter, addJitter } from './retry-strategy';\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 * 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\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 */\nexport class InternalHttpClient {\n  private config: Required<ServiceConfig>;\n  private agent: http.Agent;\n\n  /**\n   * Create a new HTTP client instance.\n   *\n   * @param config - Service configuration\n   */\n  constructor(config: ServiceConfig) {\n    this.config = {\n      host: config.host,\n      port: config.port,\n      timeout: config.timeout ?? DEFAULT_TIMEOUT,\n    };\n    this.agent = new http.Agent({ keepAlive: true });\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    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        if (decision.shouldRetry) {\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) {\n          logger.debug('Retrying after error', { method, path, error: lastError.message, attempt: attempt + 1 });\n          await this.sleep(decision.delayMs);\n          continue;\n        }\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      const bodyStr = body ? 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        logger.error('HTTP request failed', {\n          host: this.config.host,\n          port: this.config.port,\n          path,\n          method,\n          error: error.message,\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) {\n  const client = new InternalHttpClient(config);\n\n  return {\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"]}

package/lib/services/index.d.ts

@@ -0,0 +1,10 @@
+export * from './cache-service';
+export * from './compliance-client';
+export * from './compliance-event-subscriber';
+export * from './entity-events';
+export * from './http-client';
+export { DEFAULT_MAX_RETRIES, DEFAULT_RETRY_DELAY_MS, DEFAULT_MAX_RATE_LIMIT_RETRIES, calculateBackoff, isTransientStatusCode, isRateLimited, getRetryDecision, getErrorRetryDecision, } from './retry-strategy';
+export type { RetryConfig, RetryDecision } from './retry-strategy';
+export * from './quota';
+export { logAdminAction, type AuditEntry } from './admin-audit';
+export { enqueueComplianceEvent, registerComplianceQueueBackend, type ComplianceEvent } from './compliance-queue';

package/lib/services/index.js

@@ -0,0 +1,40 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerComplianceQueueBackend = exports.enqueueComplianceEvent = exports.logAdminAction = exports.getErrorRetryDecision = exports.getRetryDecision = exports.isRateLimited = exports.isTransientStatusCode = exports.calculateBackoff = exports.DEFAULT_MAX_RATE_LIMIT_RETRIES = exports.DEFAULT_RETRY_DELAY_MS = exports.DEFAULT_MAX_RETRIES = void 0;
+__exportStar(require("./cache-service"), exports);
+__exportStar(require("./compliance-client"), exports);
+__exportStar(require("./compliance-event-subscriber"), exports);
+__exportStar(require("./entity-events"), exports);
+__exportStar(require("./http-client"), exports);
+var retry_strategy_1 = require("./retry-strategy");
+Object.defineProperty(exports, "DEFAULT_MAX_RETRIES", { enumerable: true, get: function () { return retry_strategy_1.DEFAULT_MAX_RETRIES; } });
+Object.defineProperty(exports, "DEFAULT_RETRY_DELAY_MS", { enumerable: true, get: function () { return retry_strategy_1.DEFAULT_RETRY_DELAY_MS; } });
+Object.defineProperty(exports, "DEFAULT_MAX_RATE_LIMIT_RETRIES", { enumerable: true, get: function () { return retry_strategy_1.DEFAULT_MAX_RATE_LIMIT_RETRIES; } });
+Object.defineProperty(exports, "calculateBackoff", { enumerable: true, get: function () { return retry_strategy_1.calculateBackoff; } });
+Object.defineProperty(exports, "isTransientStatusCode", { enumerable: true, get: function () { return retry_strategy_1.isTransientStatusCode; } });
+Object.defineProperty(exports, "isRateLimited", { enumerable: true, get: function () { return retry_strategy_1.isRateLimited; } });
+Object.defineProperty(exports, "getRetryDecision", { enumerable: true, get: function () { return retry_strategy_1.getRetryDecision; } });
+Object.defineProperty(exports, "getErrorRetryDecision", { enumerable: true, get: function () { return retry_strategy_1.getErrorRetryDecision; } });
+__exportStar(require("./quota"), exports);
+var admin_audit_1 = require("./admin-audit");
+Object.defineProperty(exports, "logAdminAction", { enumerable: true, get: function () { return admin_audit_1.logAdminAction; } });
+var compliance_queue_1 = require("./compliance-queue");
+Object.defineProperty(exports, "enqueueComplianceEvent", { enumerable: true, get: function () { return compliance_queue_1.enqueueComplianceEvent; } });
+Object.defineProperty(exports, "registerComplianceQueueBackend", { enumerable: true, get: function () { return compliance_queue_1.registerComplianceQueueBackend; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VydmljZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLCtDQUErQztBQUMvQyxzQ0FBc0M7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBRXRDLGtEQUFnQztBQUNoQyxzREFBb0M7QUFDcEMsZ0VBQThDO0FBQzlDLGtEQUFnQztBQUNoQyxnREFBOEI7QUFDOUIsbURBUzBCO0FBUnhCLHFIQUFBLG1CQUFtQixPQUFBO0FBQ25CLHdIQUFBLHNCQUFzQixPQUFBO0FBQ3RCLGdJQUFBLDhCQUE4QixPQUFBO0FBQzlCLGtIQUFBLGdCQUFnQixPQUFBO0FBQ2hCLHVIQUFBLHFCQUFxQixPQUFBO0FBQ3JCLCtHQUFBLGFBQWEsT0FBQTtBQUNiLGtIQUFBLGdCQUFnQixPQUFBO0FBQ2hCLHVIQUFBLHFCQUFxQixPQUFBO0FBR3ZCLDBDQUF3QjtBQUN4Qiw2Q0FBZ0U7QUFBdkQsNkdBQUEsY0FBYyxPQUFBO0FBQ3ZCLHVEQUFrSDtBQUF6RywwSEFBQSxzQkFBc0IsT0FBQTtBQUFFLGtJQUFBLDhCQUE4QixPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMjYgUGlwZWxpbmUgQnVpbGRlciBDb250cmlidXRvcnNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5cbmV4cG9ydCAqIGZyb20gJy4vY2FjaGUtc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2NvbXBsaWFuY2UtY2xpZW50JztcbmV4cG9ydCAqIGZyb20gJy4vY29tcGxpYW5jZS1ldmVudC1zdWJzY3JpYmVyJztcbmV4cG9ydCAqIGZyb20gJy4vZW50aXR5LWV2ZW50cyc7XG5leHBvcnQgKiBmcm9tICcuL2h0dHAtY2xpZW50JztcbmV4cG9ydCB7XG4gIERFRkFVTFRfTUFYX1JFVFJJRVMsXG4gIERFRkFVTFRfUkVUUllfREVMQVlfTVMsXG4gIERFRkFVTFRfTUFYX1JBVEVfTElNSVRfUkVUUklFUyxcbiAgY2FsY3VsYXRlQmFja29mZixcbiAgaXNUcmFuc2llbnRTdGF0dXNDb2RlLFxuICBpc1JhdGVMaW1pdGVkLFxuICBnZXRSZXRyeURlY2lzaW9uLFxuICBnZXRFcnJvclJldHJ5RGVjaXNpb24sXG59IGZyb20gJy4vcmV0cnktc3RyYXRlZ3knO1xuZXhwb3J0IHR5cGUgeyBSZXRyeUNvbmZpZywgUmV0cnlEZWNpc2lvbiB9IGZyb20gJy4vcmV0cnktc3RyYXRlZ3knO1xuZXhwb3J0ICogZnJvbSAnLi9xdW90YSc7XG5leHBvcnQgeyBsb2dBZG1pbkFjdGlvbiwgdHlwZSBBdWRpdEVudHJ5IH0gZnJvbSAnLi9hZG1pbi1hdWRpdCc7XG5leHBvcnQgeyBlbnF1ZXVlQ29tcGxpYW5jZUV2ZW50LCByZWdpc3RlckNvbXBsaWFuY2VRdWV1ZUJhY2tlbmQsIHR5cGUgQ29tcGxpYW5jZUV2ZW50IH0gZnJvbSAnLi9jb21wbGlhbmNlLXF1ZXVlJztcbiJdfQ==