@pipeline-builder/api-core 4.1.12 → 4.1.14

package/lib/services/circuit-breaker.js

@@ -17,9 +17,10 @@
  * fails closed — just immediately, instead of after the full retry budget; a
  * fail-open caller (createSafeClient) gets its `null` immediately.
  *
- * State is keyed by `host:port` in a process-level registry so it is shared even
- * when callers mint a fresh client per request — one bad target trips once, not
- * once-per-client. Disable entirely with `S2S_BREAKER_ENABLED=false`.
+ * State is keyed by `host:port` plus a route class ({@link circuitBreakerKey})
+ * in a process-level registry so it is shared even when callers mint a fresh
+ * client per request — one bad target trips once, not once-per-client — while
+ * one failing surface of a service can't shed traffic to its other surfaces. Disable entirely with `S2S_BREAKER_ENABLED=false`.
  */
 import { envInt, envBool } from '../utils/env.js';
 import { createLogger } from '../utils/logger.js';
@@ -42,6 +43,8 @@ export class CircuitBreaker {
     consecutiveFailures = 0;
     openedAt = 0;
     probeInFlight = false;
+    /** When the current half-open probe was admitted (for expiring a stuck probe). */
+    probeStartedAt = 0;
     constructor(key, config = DEFAULT_BREAKER_CONFIG) {
         this.key = key;
         this.config = config;
@@ -59,20 +62,31 @@ export class CircuitBreaker {
             return true;
         if (this.state === 'closed')
             return true;
+        const now = Date.now();
         if (this.state === 'open') {
-            if (Date.now() - this.openedAt >= this.config.cooldownMs) {
+            if (now - this.openedAt >= this.config.cooldownMs) {
                 this.state = 'half-open';
-                this.probeInFlight = true;
+                this.admitProbe(now);
                 return true;
             }
             return false;
         }
-        // half-open: allow only a single probe at a time.
-        if (this.probeInFlight)
+        // half-open: allow only a single probe at a time — but a probe that has been
+        // in flight longer than the cooldown is presumed lost (its caller never
+        // reported back: hung socket, swallowed promise). Without this expiry the
+        // breaker would stay half-open with the gate shut FOREVER, fast-failing
+        // every request to a downstream that may long since have recovered.
+        if (this.probeInFlight && now - this.probeStartedAt < this.config.cooldownMs)
             return false;
-        this.probeInFlight = true;
+        if (this.probeInFlight)
+            emitCounter('s2s_circuit_probe_expired_total', { target: this.key });
+        this.admitProbe(now);
         return true;
     }
+    admitProbe(now) {
+        this.probeInFlight = true;
+        this.probeStartedAt = now;
+    }
     /** A logical request succeeded (2xx/3xx/4xx that isn't a downstream fault). */
     recordSuccess() {
         if (!this.config.enabled)
@@ -114,7 +128,19 @@ export class CircuitBreaker {
     }
 }
 const registry = new Map();
-/** Get (or lazily create) the shared breaker for a `host:port` target. */
+/**
+ * The breaker key for a target and a ROUTE CLASS. Breakers are per
+ * `host:port` + class, so one failing surface of a service (say platform's
+ * audit ingest returning 5xx) can't open the breaker for an unrelated one
+ * (platform's JWKS / key exchange). The class is a small, caller-chosen label —
+ * never derived from the path, which carries ids and would explode the registry.
+ */
+export function circuitBreakerKey(target, routeClass) {
+    return routeClass && routeClass !== DEFAULT_ROUTE_CLASS ? `${target}#${routeClass}` : target;
+}
+/** The route class of a request that names none. */
+export const DEFAULT_ROUTE_CLASS = 'default';
+/** Get (or lazily create) the shared breaker for a {@link circuitBreakerKey}. */
 export function getCircuitBreaker(key) {
     let breaker = registry.get(key);
     if (!breaker) {
@@ -135,4 +161,4 @@ export class CircuitOpenError extends Error {
         this.name = 'CircuitOpenError';
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"circuit-breaker.js","sourceRoot":"","sources":["../../src/services/circuit-breaker.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Per-target circuit breaker for service-to-service calls.\n *\n * The shared {@link InternalHttpClient} already has timeouts, a bounded socket\n * pool, and bounded retry-with-jitter — but no load-shedding. Under a sustained\n * downstream brownout every caller keeps paying `timeout × (maxRetries+1)` per\n * request, saturating the socket pool and turning one slow dependency into a\n * fleet-wide latency cascade (the classic retry storm). Worse for fail-CLOSED\n * dependencies (compliance): a brownout there blocks plugin/pipeline creation\n * with full retry latency on every request.\n *\n * This breaker short-circuits that: after `failureThreshold` consecutive\n * failures to a target it OPENS and fast-fails (no network, no retries) for\n * `cooldownMs`, then allows a single half-open probe. A fail-closed caller still\n * fails closed — just immediately, instead of after the full retry budget; a\n * fail-open caller (createSafeClient) gets its `null` immediately.\n *\n * State is keyed by `host:port` in a process-level registry so it is shared even\n * when callers mint a fresh client per request — one bad target trips once, not\n * once-per-client. Disable entirely with `S2S_BREAKER_ENABLED=false`.\n */\n\nimport { envInt, envBool } from '../utils/env.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('circuit-breaker');\n\nexport type CircuitState = 'closed' | 'open' | 'half-open';\n\nexport interface CircuitBreakerConfig {\n  /** Consecutive failures that trip the breaker from closed → open. */\n  failureThreshold: number;\n  /** How long to stay open before allowing a half-open probe (ms). */\n  cooldownMs: number;\n  /** Master switch — when false, allowRequest() is always true and no state moves. */\n  enabled: boolean;\n}\n\nexport const DEFAULT_BREAKER_CONFIG: CircuitBreakerConfig = {\n  failureThreshold: envInt('S2S_BREAKER_THRESHOLD', 5, { min: 1 }),\n  cooldownMs: envInt('S2S_BREAKER_COOLDOWN_MS', 10000, { min: 1 }),\n  enabled: envBool('S2S_BREAKER_ENABLED', true),\n};\n\n/**\n * A single target's breaker. Not concurrency-locked (JS is single-threaded per\n * event loop); `probeInFlight` gates half-open to one in-flight probe so a burst\n * during cooldown doesn't stampede the recovering downstream.\n */\nexport class CircuitBreaker {\n  private state: CircuitState = 'closed';\n  private consecutiveFailures = 0;\n  private openedAt = 0;\n  private probeInFlight = false;\n\n  constructor(\n    private readonly key: string,\n    private readonly config: CircuitBreakerConfig = DEFAULT_BREAKER_CONFIG,\n  ) {}\n\n  getState(): CircuitState {\n    return this.state;\n  }\n\n  /**\n   * Whether a request may proceed. Transitions open→half-open once the cooldown\n   * elapses and lets exactly ONE probe through. Returns false when open (or a\n   * probe is already in flight) — the caller must fast-fail without any network.\n   */\n  allowRequest(): boolean {\n    if (!this.config.enabled) return true;\n    if (this.state === 'closed') return true;\n    if (this.state === 'open') {\n      if (Date.now() - this.openedAt >= this.config.cooldownMs) {\n        this.state = 'half-open';\n        this.probeInFlight = true;\n        return true;\n      }\n      return false;\n    }\n    // half-open: allow only a single probe at a time.\n    if (this.probeInFlight) return false;\n    this.probeInFlight = true;\n    return true;\n  }\n\n  /** A logical request succeeded (2xx/3xx/4xx that isn't a downstream fault). */\n  recordSuccess(): void {\n    if (!this.config.enabled) return;\n    this.consecutiveFailures = 0;\n    this.probeInFlight = false;\n    if (this.state !== 'closed') {\n      logger.info('circuit closed (downstream recovered)', { target: this.key });\n      this.state = 'closed';\n    }\n  }\n\n  /** A logical request failed (connection error, timeout, or 5xx response). */\n  recordFailure(): void {\n    if (!this.config.enabled) return;\n    this.probeInFlight = false;\n    this.consecutiveFailures++;\n    // A failed half-open probe means the downstream is still bad — re-open.\n    if (this.state === 'half-open') {\n      this.open();\n      return;\n    }\n    if (this.state === 'closed' && this.consecutiveFailures >= this.config.failureThreshold) {\n      this.open();\n    }\n  }\n\n  private open(): void {\n    const wasOpen = this.state === 'open';\n    this.state = 'open';\n    this.openedAt = Date.now();\n    if (!wasOpen) {\n      logger.warn('circuit opened — shedding load to target', {\n        target: this.key,\n        consecutiveFailures: this.consecutiveFailures,\n        cooldownMs: this.config.cooldownMs,\n      });\n      emitCounter('s2s_circuit_opened_total', { target: this.key });\n    }\n  }\n}\n\nconst registry = new Map<string, CircuitBreaker>();\n\n/** Get (or lazily create) the shared breaker for a `host:port` target. */\nexport function getCircuitBreaker(key: string): CircuitBreaker {\n  let breaker = registry.get(key);\n  if (!breaker) {\n    breaker = new CircuitBreaker(key);\n    registry.set(key, breaker);\n  }\n  return breaker;\n}\n\n/** Test helper: clear all breaker state so suites don't leak across each other. */\nexport function resetCircuitBreakers(): void {\n  registry.clear();\n}\n\n/** Thrown by the client when a request is fast-failed because the breaker is open. */\nexport class CircuitOpenError extends Error {\n  readonly code = 'CIRCUIT_OPEN';\n  constructor(target: string) {\n    super(`Circuit open for ${target} — fast-failing to shed load`);\n    this.name = 'CircuitOpenError';\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"circuit-breaker.js","sourceRoot":"","sources":["../../src/services/circuit-breaker.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Per-target circuit breaker for service-to-service calls.\n *\n * The shared {@link InternalHttpClient} already has timeouts, a bounded socket\n * pool, and bounded retry-with-jitter — but no load-shedding. Under a sustained\n * downstream brownout every caller keeps paying `timeout × (maxRetries+1)` per\n * request, saturating the socket pool and turning one slow dependency into a\n * fleet-wide latency cascade (the classic retry storm). Worse for fail-CLOSED\n * dependencies (compliance): a brownout there blocks plugin/pipeline creation\n * with full retry latency on every request.\n *\n * This breaker short-circuits that: after `failureThreshold` consecutive\n * failures to a target it OPENS and fast-fails (no network, no retries) for\n * `cooldownMs`, then allows a single half-open probe. A fail-closed caller still\n * fails closed — just immediately, instead of after the full retry budget; a\n * fail-open caller (createSafeClient) gets its `null` immediately.\n *\n * State is keyed by `host:port` plus a route class ({@link circuitBreakerKey})\n * in a process-level registry so it is shared even when callers mint a fresh\n * client per request — one bad target trips once, not once-per-client — while\n * one failing surface of a service can't shed traffic to its other surfaces. Disable entirely with `S2S_BREAKER_ENABLED=false`.\n */\n\nimport { envInt, envBool } from '../utils/env.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('circuit-breaker');\n\nexport type CircuitState = 'closed' | 'open' | 'half-open';\n\nexport interface CircuitBreakerConfig {\n  /** Consecutive failures that trip the breaker from closed → open. */\n  failureThreshold: number;\n  /** How long to stay open before allowing a half-open probe (ms). */\n  cooldownMs: number;\n  /** Master switch — when false, allowRequest() is always true and no state moves. */\n  enabled: boolean;\n}\n\nexport const DEFAULT_BREAKER_CONFIG: CircuitBreakerConfig = {\n  failureThreshold: envInt('S2S_BREAKER_THRESHOLD', 5, { min: 1 }),\n  cooldownMs: envInt('S2S_BREAKER_COOLDOWN_MS', 10000, { min: 1 }),\n  enabled: envBool('S2S_BREAKER_ENABLED', true),\n};\n\n/**\n * A single target's breaker. Not concurrency-locked (JS is single-threaded per\n * event loop); `probeInFlight` gates half-open to one in-flight probe so a burst\n * during cooldown doesn't stampede the recovering downstream.\n */\nexport class CircuitBreaker {\n  private state: CircuitState = 'closed';\n  private consecutiveFailures = 0;\n  private openedAt = 0;\n  private probeInFlight = false;\n  /** When the current half-open probe was admitted (for expiring a stuck probe). */\n  private probeStartedAt = 0;\n\n  constructor(\n    private readonly key: string,\n    private readonly config: CircuitBreakerConfig = DEFAULT_BREAKER_CONFIG,\n  ) {}\n\n  getState(): CircuitState {\n    return this.state;\n  }\n\n  /**\n   * Whether a request may proceed. Transitions open→half-open once the cooldown\n   * elapses and lets exactly ONE probe through. Returns false when open (or a\n   * probe is already in flight) — the caller must fast-fail without any network.\n   */\n  allowRequest(): boolean {\n    if (!this.config.enabled) return true;\n    if (this.state === 'closed') return true;\n    const now = Date.now();\n    if (this.state === 'open') {\n      if (now - this.openedAt >= this.config.cooldownMs) {\n        this.state = 'half-open';\n        this.admitProbe(now);\n        return true;\n      }\n      return false;\n    }\n    // half-open: allow only a single probe at a time — but a probe that has been\n    // in flight longer than the cooldown is presumed lost (its caller never\n    // reported back: hung socket, swallowed promise). Without this expiry the\n    // breaker would stay half-open with the gate shut FOREVER, fast-failing\n    // every request to a downstream that may long since have recovered.\n    if (this.probeInFlight && now - this.probeStartedAt < this.config.cooldownMs) return false;\n    if (this.probeInFlight) emitCounter('s2s_circuit_probe_expired_total', { target: this.key });\n    this.admitProbe(now);\n    return true;\n  }\n\n  private admitProbe(now: number): void {\n    this.probeInFlight = true;\n    this.probeStartedAt = now;\n  }\n\n  /** A logical request succeeded (2xx/3xx/4xx that isn't a downstream fault). */\n  recordSuccess(): void {\n    if (!this.config.enabled) return;\n    this.consecutiveFailures = 0;\n    this.probeInFlight = false;\n    if (this.state !== 'closed') {\n      logger.info('circuit closed (downstream recovered)', { target: this.key });\n      this.state = 'closed';\n    }\n  }\n\n  /** A logical request failed (connection error, timeout, or 5xx response). */\n  recordFailure(): void {\n    if (!this.config.enabled) return;\n    this.probeInFlight = false;\n    this.consecutiveFailures++;\n    // A failed half-open probe means the downstream is still bad — re-open.\n    if (this.state === 'half-open') {\n      this.open();\n      return;\n    }\n    if (this.state === 'closed' && this.consecutiveFailures >= this.config.failureThreshold) {\n      this.open();\n    }\n  }\n\n  private open(): void {\n    const wasOpen = this.state === 'open';\n    this.state = 'open';\n    this.openedAt = Date.now();\n    if (!wasOpen) {\n      logger.warn('circuit opened — shedding load to target', {\n        target: this.key,\n        consecutiveFailures: this.consecutiveFailures,\n        cooldownMs: this.config.cooldownMs,\n      });\n      emitCounter('s2s_circuit_opened_total', { target: this.key });\n    }\n  }\n}\n\nconst registry = new Map<string, CircuitBreaker>();\n\n/**\n * The breaker key for a target and a ROUTE CLASS. Breakers are per\n * `host:port` + class, so one failing surface of a service (say platform's\n * audit ingest returning 5xx) can't open the breaker for an unrelated one\n * (platform's JWKS / key exchange). The class is a small, caller-chosen label —\n * never derived from the path, which carries ids and would explode the registry.\n */\nexport function circuitBreakerKey(target: string, routeClass?: string): string {\n  return routeClass && routeClass !== DEFAULT_ROUTE_CLASS ? `${target}#${routeClass}` : target;\n}\n\n/** The route class of a request that names none. */\nexport const DEFAULT_ROUTE_CLASS = 'default';\n\n/** Get (or lazily create) the shared breaker for a {@link circuitBreakerKey}. */\nexport function getCircuitBreaker(key: string): CircuitBreaker {\n  let breaker = registry.get(key);\n  if (!breaker) {\n    breaker = new CircuitBreaker(key);\n    registry.set(key, breaker);\n  }\n  return breaker;\n}\n\n/** Test helper: clear all breaker state so suites don't leak across each other. */\nexport function resetCircuitBreakers(): void {\n  registry.clear();\n}\n\n/** Thrown by the client when a request is fast-failed because the breaker is open. */\nexport class CircuitOpenError extends Error {\n  readonly code = 'CIRCUIT_OPEN';\n  constructor(target: string) {\n    super(`Circuit open for ${target} — fast-failing to shed load`);\n    this.name = 'CircuitOpenError';\n  }\n}\n"]}

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

@@ -1,4 +1,5 @@
 import type { ServiceConfig } from '../types/common.js';
+import type { PluginComplianceAttributes } from '../utils/plugin-compliance.js';
 /**
  * Result of a compliance validation check.
  */
@@ -27,8 +28,15 @@ export interface ComplianceViolation {
  * Uses fail-closed design: errors propagate to block the operation.
  */
 export interface ComplianceClient {
-    /** Validate plugin attributes against org rules. Throws on service error (fail-closed). */
-    validatePlugin(orgId: string, attributes: Record<string, unknown>, authHeader: string, entityId?: string, entityName?: string, action?: string): Promise<ComplianceCheckResult>;
+    /**
+     * Validate plugin attributes against org rules. Throws on service error (fail-closed).
+     *
+     * `deferredFields` names attributes this check cannot know yet; rules that
+     * read them are skipped (counted in `rulesSkipped`, never passed) and must be
+     * evaluated by a later check that has them — the build worker's post-build
+     * re-validation for {@link PLUGIN_IMAGE_COMPLIANCE_FIELDS}.
+     */
+    validatePlugin(orgId: string, attributes: PluginComplianceAttributes, authHeader: string, entityId?: string, entityName?: string, action?: string, deferredFields?: readonly string[]): Promise<ComplianceCheckResult>;
     /** Validate pipeline attributes against org rules. Throws on service error (fail-closed). */
     validatePipeline(orgId: string, attributes: Record<string, unknown>, authHeader: string, entityId?: string, entityName?: string, action?: string): Promise<ComplianceCheckResult>;
     /** Pre-flight check for plugin (no audit, no notification). */

package/lib/services/compliance-client.js

@@ -2,19 +2,21 @@
 // SPDX-License-Identifier: Apache-2.0
 import { InternalHttpClient } from './http-client.js';
 import { createLogger } from '../utils/logger.js';
+import { envBool, envInt } from '../utils/env.js';
+import { serviceEndpoint } from '../utils/service-registry.js';
 const logger = createLogger('compliance-client');
 /**
  * When true, compliance checks are bypassed if the service is unavailable
  * (fail-open). Default is fail-closed (errors propagate and block the operation).
  */
-const COMPLIANCE_BYPASS = process.env.COMPLIANCE_BYPASS === 'true';
+const COMPLIANCE_BYPASS = envBool('COMPLIANCE_BYPASS', false);
 /**
  * Per-attempt timeout for a validation POST (env: `COMPLIANCE_VALIDATE_TIMEOUT_MS`).
  * Deliberately TIGHTER than the 5s client default so the enforced retries (below)
  * fit inside a bounded total budget rather than stacking three 5s stalls onto a
  * single interactive request.
  */
-const VALIDATE_TIMEOUT_MS = parseInt(process.env.COMPLIANCE_VALIDATE_TIMEOUT_MS ?? '4000', 10);
+const VALIDATE_TIMEOUT_MS = envInt('COMPLIANCE_VALIDATE_TIMEOUT_MS', 4000, { min: 1 });
 /**
  * Return a pass-through result when COMPLIANCE_BYPASS is enabled and the
  * compliance service is unreachable.
@@ -38,9 +40,8 @@ function buildHeaders(orgId, authHeader) {
     const headers = {
         'x-org-id': orgId,
     };
-    // NOTE: the old `x-internal-service: true` header was removed — it is trusted
-    // by nothing (it was spoofable); compliance routes authenticate the caller via
-    // the `Authorization` service JWT (`requireServicePrincipal`).
+    // Compliance routes authenticate the caller via the `Authorization` service
+    // JWT (`requireServicePrincipal`); no plaintext header is trusted.
     if (authHeader)
         headers.Authorization = authHeader;
     return headers;
@@ -73,8 +74,8 @@ function validateOptions(orgId, authHeader) {
  */
 export function createComplianceClient(config) {
     const serviceConfig = {
-        host: config?.host ?? process.env.COMPLIANCE_SERVICE_HOST ?? 'compliance',
-        port: config?.port ?? parseInt(process.env.COMPLIANCE_SERVICE_PORT ?? '3000', 10),
+        host: config?.host ?? serviceEndpoint('compliance').host,
+        port: config?.port ?? serviceEndpoint('compliance').port,
     };
     const client = new InternalHttpClient(serviceConfig);
     /**
@@ -111,8 +112,14 @@ export function createComplianceClient(config) {
         }
     }
     return {
-        validatePlugin(orgId, attributes, authHeader, entityId, entityName, action) {
-            return runValidation(orgId, authHeader, '/compliance/validate/plugin', { attributes, entityId, entityName, action: action ?? 'upload' }, 'validatePlugin', { orgId, entityType: 'plugin', entityId, entityName });
+        validatePlugin(orgId, attributes, authHeader, entityId, entityName, action, deferredFields) {
+            return runValidation(orgId, authHeader, '/compliance/validate/plugin', {
+                attributes,
+                entityId,
+                entityName,
+                action: action ?? 'upload',
+                ...(deferredFields && deferredFields.length > 0 ? { deferredFields: [...deferredFields] } : {}),
+            }, 'validatePlugin', { orgId, entityType: 'plugin', entityId, entityName });
         },
         validatePipeline(orgId, attributes, authHeader, entityId, entityName, action) {
             return runValidation(orgId, authHeader, '/compliance/validate/pipeline', { attributes, entityId, entityName, action: action ?? 'create' }, 'validatePipeline', { orgId, entityType: 'pipeline', entityId, entityName });
@@ -125,4 +132,4 @@ export function createComplianceClient(config) {
         },
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compliance-client.js","sourceRoot":"","sources":["../../src/services/compliance-client.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { InternalHttpClient, type RequestOptions } from './http-client.js';\nimport type { ServiceConfig } from '../types/common.js';\nimport { createLogger } from '../utils/logger.js';\n\nconst logger = createLogger('compliance-client');\n\n/**\n * When true, compliance checks are bypassed if the service is unavailable\n * (fail-open). Default is fail-closed (errors propagate and block the operation).\n */\nconst COMPLIANCE_BYPASS = process.env.COMPLIANCE_BYPASS === 'true';\n\n/**\n * Per-attempt timeout for a validation POST (env: `COMPLIANCE_VALIDATE_TIMEOUT_MS`).\n * Deliberately TIGHTER than the 5s client default so the enforced retries (below)\n * fit inside a bounded total budget rather than stacking three 5s stalls onto a\n * single interactive request.\n */\nconst VALIDATE_TIMEOUT_MS = parseInt(process.env.COMPLIANCE_VALIDATE_TIMEOUT_MS ?? '4000', 10);\n\n/**\n * Result of a compliance validation check.\n */\nexport interface ComplianceCheckResult {\n  passed: boolean;\n  violations: ComplianceViolation[];\n  warnings: ComplianceViolation[];\n  blocked: boolean;\n  rulesEvaluated: number;\n  rulesSkipped: number;\n  exemptionsApplied: string[];\n}\n\nexport interface ComplianceViolation {\n  ruleId: string;\n  ruleName: string;\n  policyId?: string | null;\n  field: string;\n  operator: string;\n  expectedValue: unknown;\n  actualValue: unknown;\n  severity: string;\n  message: string;\n}\n\n/**\n * Compliance service client interface.\n * Uses fail-closed design: errors propagate to block the operation.\n */\nexport interface ComplianceClient {\n  /** Validate plugin attributes against org rules. Throws on service error (fail-closed). */\n  validatePlugin(\n    orgId: string,\n    attributes: Record<string, unknown>,\n    authHeader: string,\n    entityId?: string,\n    entityName?: string,\n    action?: string,\n  ): Promise<ComplianceCheckResult>;\n\n  /** Validate pipeline attributes against org rules. Throws on service error (fail-closed). */\n  validatePipeline(\n    orgId: string,\n    attributes: Record<string, unknown>,\n    authHeader: string,\n    entityId?: string,\n    entityName?: string,\n    action?: string,\n  ): Promise<ComplianceCheckResult>;\n\n  /** Pre-flight check for plugin (no audit, no notification). */\n  dryRunPlugin(\n    orgId: string,\n    attributes: Record<string, unknown>,\n    authHeader: string,\n  ): Promise<ComplianceCheckResult>;\n\n  /** Pre-flight check for pipeline (no audit, no notification). */\n  dryRunPipeline(\n    orgId: string,\n    attributes: Record<string, unknown>,\n    authHeader: string,\n  ): Promise<ComplianceCheckResult>;\n}\n\n/**\n * Return a pass-through result when COMPLIANCE_BYPASS is enabled and the\n * compliance service is unreachable.\n */\nfunction bypassResult(context: Record<string, unknown>): ComplianceCheckResult {\n  logger.warn('COMPLIANCE_BYPASS: Service unavailable, allowing request', context);\n  return {\n    passed: true,\n    blocked: false,\n    violations: [],\n    warnings: [{ ruleId: '', ruleName: '', field: '', operator: '', expectedValue: null, actualValue: null, severity: 'warning', message: 'Compliance check skipped (service unavailable)' }],\n    rulesEvaluated: 0,\n    rulesSkipped: 0,\n    exemptionsApplied: [],\n  };\n}\n\n/**\n * Build common request headers for compliance calls.\n */\nfunction buildHeaders(orgId: string, authHeader: string): Record<string, string> {\n  const headers: Record<string, string> = {\n    'x-org-id': orgId,\n  };\n  // NOTE: the old `x-internal-service: true` header was removed — it is trusted\n  // by nothing (it was spoofable); compliance routes authenticate the caller via\n  // the `Authorization` service JWT (`requireServicePrincipal`).\n  if (authHeader) headers.Authorization = authHeader;\n  return headers;\n}\n\n/**\n * Request options for a compliance validation POST.\n *\n * These calls are side-effect-free (they evaluate rules and return a verdict;\n * any audit/notification the compliance service writes is derived, not a mutation\n * the caller depends on being once-only), so they are marked `idempotent: true`.\n * That lets the HTTP client auto-retry a transient 503 / connection reset /\n * timeout instead of surfacing it as a hard failure — which, under the\n * fail-closed default, would wrongly REJECT a legitimate plugin upload / pipeline\n * create just because compliance briefly stalled. Paired with the tighter\n * per-attempt timeout so the retries stay within a bounded total budget.\n */\nfunction validateOptions(orgId: string, authHeader: string): RequestOptions {\n  return {\n    headers: buildHeaders(orgId, authHeader),\n    idempotent: true,\n    timeout: VALIDATE_TIMEOUT_MS,\n  };\n}\n\n/**\n * Create a compliance client.\n *\n * IMPORTANT: This client is fail-closed — if the compliance service is\n * unreachable or returns an error, the error propagates and the calling\n * operation (plugin upload, pipeline create) is rejected.\n */\nexport function createComplianceClient(config?: Partial<ServiceConfig>): ComplianceClient {\n  const serviceConfig: ServiceConfig = {\n    host: config?.host ?? process.env.COMPLIANCE_SERVICE_HOST ?? 'compliance',\n    port: config?.port ?? parseInt(process.env.COMPLIANCE_SERVICE_PORT ?? '3000', 10),\n  };\n\n  const client = new InternalHttpClient(serviceConfig);\n\n  /**\n   * Validate response shape + status. The HTTP client doesn't throw on non-2xx\n   * (it just returns the body), so without this an auth failure / route miss\n   * silently produced `response.body.data === undefined` and the caller\n   * crashed on `.blocked`. Now non-2xx surfaces as a thrown error that the\n   * outer try/catch can turn into either fail-closed (default) or\n   * COMPLIANCE_BYPASS (fail-open).\n   */\n  function unwrap(\n    response: { statusCode: number; body: { success?: boolean; data?: ComplianceCheckResult; message?: string } },\n    op: string,\n  ): ComplianceCheckResult {\n    if (response.statusCode < 200 || response.statusCode >= 300) {\n      const msg = response.body?.message ?? `HTTP ${response.statusCode}`;\n      throw new Error(`compliance ${op} failed: ${msg}`);\n    }\n    if (!response.body?.data) {\n      throw new Error(`compliance ${op} returned no data (status ${response.statusCode})`);\n    }\n    return response.body.data;\n  }\n\n  // Shared body for all four validate/dry-run calls: POST → unwrap, and on a\n  // transport/HTTP failure either return a fail-open bypass result (when\n  // COMPLIANCE_BYPASS) or rethrow. The four methods differ ONLY in path, request\n  // body, op label, and bypass context.\n  async function runValidation(\n    orgId: string,\n    authHeader: string,\n    path: string,\n    body: Record<string, unknown>,\n    op: string,\n    bypassCtx: Record<string, unknown>,\n  ): Promise<ComplianceCheckResult> {\n    try {\n      const response = await client.post<{ success: boolean; data: ComplianceCheckResult; message?: string }>(\n        path, body, validateOptions(orgId, authHeader),\n      );\n      return unwrap(response, op);\n    } catch (error) {\n      if (COMPLIANCE_BYPASS) return bypassResult(bypassCtx);\n      throw error;\n    }\n  }\n\n  return {\n    validatePlugin(orgId, attributes, authHeader, entityId, entityName, action) {\n      return runValidation(orgId, authHeader, '/compliance/validate/plugin',\n        { attributes, entityId, entityName, action: action ?? 'upload' }, 'validatePlugin',\n        { orgId, entityType: 'plugin', entityId, entityName });\n    },\n\n    validatePipeline(orgId, attributes, authHeader, entityId, entityName, action) {\n      return runValidation(orgId, authHeader, '/compliance/validate/pipeline',\n        { attributes, entityId, entityName, action: action ?? 'create' }, 'validatePipeline',\n        { orgId, entityType: 'pipeline', entityId, entityName });\n    },\n\n    dryRunPlugin(orgId, attributes, authHeader) {\n      return runValidation(orgId, authHeader, '/compliance/validate/plugin/dry-run',\n        { attributes }, 'dryRunPlugin', { orgId, entityType: 'plugin', dryRun: true });\n    },\n\n    dryRunPipeline(orgId, attributes, authHeader) {\n      return runValidation(orgId, authHeader, '/compliance/validate/pipeline/dry-run',\n        { attributes }, 'dryRunPipeline', { orgId, entityType: 'pipeline', dryRun: true });\n    },\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compliance-client.js","sourceRoot":"","sources":["../../src/services/compliance-client.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { InternalHttpClient, type RequestOptions } from './http-client.js';\nimport type { ServiceConfig } from '../types/common.js';\nimport type { PluginComplianceAttributes } from '../utils/plugin-compliance.js';\nimport { createLogger } from '../utils/logger.js';\nimport { envBool, envInt } from '../utils/env.js';\nimport { serviceEndpoint } from '../utils/service-registry.js';\n\nconst logger = createLogger('compliance-client');\n\n/**\n * When true, compliance checks are bypassed if the service is unavailable\n * (fail-open). Default is fail-closed (errors propagate and block the operation).\n */\nconst COMPLIANCE_BYPASS = envBool('COMPLIANCE_BYPASS', false);\n\n/**\n * Per-attempt timeout for a validation POST (env: `COMPLIANCE_VALIDATE_TIMEOUT_MS`).\n * Deliberately TIGHTER than the 5s client default so the enforced retries (below)\n * fit inside a bounded total budget rather than stacking three 5s stalls onto a\n * single interactive request.\n */\nconst VALIDATE_TIMEOUT_MS = envInt('COMPLIANCE_VALIDATE_TIMEOUT_MS', 4000, { min: 1 });\n\n/**\n * Result of a compliance validation check.\n */\nexport interface ComplianceCheckResult {\n  passed: boolean;\n  violations: ComplianceViolation[];\n  warnings: ComplianceViolation[];\n  blocked: boolean;\n  rulesEvaluated: number;\n  rulesSkipped: number;\n  exemptionsApplied: string[];\n}\n\nexport interface ComplianceViolation {\n  ruleId: string;\n  ruleName: string;\n  policyId?: string | null;\n  field: string;\n  operator: string;\n  expectedValue: unknown;\n  actualValue: unknown;\n  severity: string;\n  message: string;\n}\n\n/**\n * Compliance service client interface.\n * Uses fail-closed design: errors propagate to block the operation.\n */\nexport interface ComplianceClient {\n  /**\n   * Validate plugin attributes against org rules. Throws on service error (fail-closed).\n   *\n   * `deferredFields` names attributes this check cannot know yet; rules that\n   * read them are skipped (counted in `rulesSkipped`, never passed) and must be\n   * evaluated by a later check that has them — the build worker's post-build\n   * re-validation for {@link PLUGIN_IMAGE_COMPLIANCE_FIELDS}.\n   */\n  validatePlugin(\n    orgId: string,\n    attributes: PluginComplianceAttributes,\n    authHeader: string,\n    entityId?: string,\n    entityName?: string,\n    action?: string,\n    deferredFields?: readonly string[],\n  ): Promise<ComplianceCheckResult>;\n\n  /** Validate pipeline attributes against org rules. Throws on service error (fail-closed). */\n  validatePipeline(\n    orgId: string,\n    attributes: Record<string, unknown>,\n    authHeader: string,\n    entityId?: string,\n    entityName?: string,\n    action?: string,\n  ): Promise<ComplianceCheckResult>;\n\n  /** Pre-flight check for plugin (no audit, no notification). */\n  dryRunPlugin(\n    orgId: string,\n    attributes: Record<string, unknown>,\n    authHeader: string,\n  ): Promise<ComplianceCheckResult>;\n\n  /** Pre-flight check for pipeline (no audit, no notification). */\n  dryRunPipeline(\n    orgId: string,\n    attributes: Record<string, unknown>,\n    authHeader: string,\n  ): Promise<ComplianceCheckResult>;\n}\n\n/**\n * Return a pass-through result when COMPLIANCE_BYPASS is enabled and the\n * compliance service is unreachable.\n */\nfunction bypassResult(context: Record<string, unknown>): ComplianceCheckResult {\n  logger.warn('COMPLIANCE_BYPASS: Service unavailable, allowing request', context);\n  return {\n    passed: true,\n    blocked: false,\n    violations: [],\n    warnings: [{ ruleId: '', ruleName: '', field: '', operator: '', expectedValue: null, actualValue: null, severity: 'warning', message: 'Compliance check skipped (service unavailable)' }],\n    rulesEvaluated: 0,\n    rulesSkipped: 0,\n    exemptionsApplied: [],\n  };\n}\n\n/**\n * Build common request headers for compliance calls.\n */\nfunction buildHeaders(orgId: string, authHeader: string): Record<string, string> {\n  const headers: Record<string, string> = {\n    'x-org-id': orgId,\n  };\n  // Compliance routes authenticate the caller via the `Authorization` service\n  // JWT (`requireServicePrincipal`); no plaintext header is trusted.\n  if (authHeader) headers.Authorization = authHeader;\n  return headers;\n}\n\n/**\n * Request options for a compliance validation POST.\n *\n * These calls are side-effect-free (they evaluate rules and return a verdict;\n * any audit/notification the compliance service writes is derived, not a mutation\n * the caller depends on being once-only), so they are marked `idempotent: true`.\n * That lets the HTTP client auto-retry a transient 503 / connection reset /\n * timeout instead of surfacing it as a hard failure — which, under the\n * fail-closed default, would wrongly REJECT a legitimate plugin upload / pipeline\n * create just because compliance briefly stalled. Paired with the tighter\n * per-attempt timeout so the retries stay within a bounded total budget.\n */\nfunction validateOptions(orgId: string, authHeader: string): RequestOptions {\n  return {\n    headers: buildHeaders(orgId, authHeader),\n    idempotent: true,\n    timeout: VALIDATE_TIMEOUT_MS,\n  };\n}\n\n/**\n * Create a compliance client.\n *\n * IMPORTANT: This client is fail-closed — if the compliance service is\n * unreachable or returns an error, the error propagates and the calling\n * operation (plugin upload, pipeline create) is rejected.\n */\nexport function createComplianceClient(config?: Partial<ServiceConfig>): ComplianceClient {\n  const serviceConfig: ServiceConfig = {\n    host: config?.host ?? serviceEndpoint('compliance').host,\n    port: config?.port ?? serviceEndpoint('compliance').port,\n  };\n\n  const client = new InternalHttpClient(serviceConfig);\n\n  /**\n   * Validate response shape + status. The HTTP client doesn't throw on non-2xx\n   * (it just returns the body), so without this an auth failure / route miss\n   * silently produced `response.body.data === undefined` and the caller\n   * crashed on `.blocked`. Now non-2xx surfaces as a thrown error that the\n   * outer try/catch can turn into either fail-closed (default) or\n   * COMPLIANCE_BYPASS (fail-open).\n   */\n  function unwrap(\n    response: { statusCode: number; body: { success?: boolean; data?: ComplianceCheckResult; message?: string } },\n    op: string,\n  ): ComplianceCheckResult {\n    if (response.statusCode < 200 || response.statusCode >= 300) {\n      const msg = response.body?.message ?? `HTTP ${response.statusCode}`;\n      throw new Error(`compliance ${op} failed: ${msg}`);\n    }\n    if (!response.body?.data) {\n      throw new Error(`compliance ${op} returned no data (status ${response.statusCode})`);\n    }\n    return response.body.data;\n  }\n\n  // Shared body for all four validate/dry-run calls: POST → unwrap, and on a\n  // transport/HTTP failure either return a fail-open bypass result (when\n  // COMPLIANCE_BYPASS) or rethrow. The four methods differ ONLY in path, request\n  // body, op label, and bypass context.\n  async function runValidation(\n    orgId: string,\n    authHeader: string,\n    path: string,\n    body: Record<string, unknown>,\n    op: string,\n    bypassCtx: Record<string, unknown>,\n  ): Promise<ComplianceCheckResult> {\n    try {\n      const response = await client.post<{ success: boolean; data: ComplianceCheckResult; message?: string }>(\n        path, body, validateOptions(orgId, authHeader),\n      );\n      return unwrap(response, op);\n    } catch (error) {\n      if (COMPLIANCE_BYPASS) return bypassResult(bypassCtx);\n      throw error;\n    }\n  }\n\n  return {\n    validatePlugin(orgId, attributes, authHeader, entityId, entityName, action, deferredFields) {\n      return runValidation(orgId, authHeader, '/compliance/validate/plugin',\n        {\n          attributes,\n          entityId,\n          entityName,\n          action: action ?? 'upload',\n          ...(deferredFields && deferredFields.length > 0 ? { deferredFields: [...deferredFields] } : {}),\n        }, 'validatePlugin',\n        { orgId, entityType: 'plugin', entityId, entityName });\n    },\n\n    validatePipeline(orgId, attributes, authHeader, entityId, entityName, action) {\n      return runValidation(orgId, authHeader, '/compliance/validate/pipeline',\n        { attributes, entityId, entityName, action: action ?? 'create' }, 'validatePipeline',\n        { orgId, entityType: 'pipeline', entityId, entityName });\n    },\n\n    dryRunPlugin(orgId, attributes, authHeader) {\n      return runValidation(orgId, authHeader, '/compliance/validate/plugin/dry-run',\n        { attributes }, 'dryRunPlugin', { orgId, entityType: 'plugin', dryRun: true });\n    },\n\n    dryRunPipeline(orgId, attributes, authHeader) {\n      return runValidation(orgId, authHeader, '/compliance/validate/pipeline/dry-run',\n        { attributes }, 'dryRunPipeline', { orgId, entityType: 'pipeline', dryRun: true });\n    },\n  };\n}\n"]}

package/lib/services/compliance-event-subscriber.js

@@ -3,11 +3,12 @@
 import { entityEvents } from './entity-events.js';
 import { InternalHttpClient } from './http-client.js';
 import { serviceIdentity } from './service-keys.js';
-import { getServiceAuthHeader } from '../middleware/auth.js';
+import { getServiceAuthHeader } from '../middleware/service-tokens.js';
 import {} from '../types/common.js';
 import { createLogger } from '../utils/logger.js';
 import { emitCounter } from '../utils/metric-emitter.js';
 import { errorMessage } from '../utils/response.js';
+import { serviceEndpoint } from '../utils/service-registry.js';
 const logger = createLogger('compliance-events');
 /**
  * Registers an entity event subscriber that forwards events to the compliance service.
@@ -26,8 +27,8 @@ const logger = createLogger('compliance-events');
  */
 export function registerComplianceEventSubscriber(config, serviceName = serviceIdentity()) {
     const serviceConfig = {
-        host: config?.host ?? process.env.COMPLIANCE_SERVICE_HOST ?? 'compliance',
-        port: config?.port ?? parseInt(process.env.COMPLIANCE_SERVICE_PORT ?? '3000', 10),
+        host: config?.host ?? serviceEndpoint('compliance').host,
+        port: config?.port ?? serviceEndpoint('compliance').port,
     };
     const client = new InternalHttpClient(serviceConfig);
     const subscriber = {
@@ -36,8 +37,7 @@ export function registerComplianceEventSubscriber(config, serviceName = serviceI
                 // Mint a per-event service JWT scoped to the event's org so the
                 // compliance route's `runWithTenantContext` sees the right tenant
                 // GUC. The compliance side enforces `requireAuth` +
-                // `requireServicePrincipal` — the previous `x-internal-service`
-                // header is no longer sufficient (and was spoofable).
+                // `requireServicePrincipal`; no plaintext header is trusted.
                 //
                 // This HTTP notify is the SINGLE delivery channel for post-mutation
                 // re-validation (primary enforcement is the fail-CLOSED live
@@ -80,4 +80,4 @@ export function registerComplianceEventSubscriber(config, serviceName = serviceI
         port: serviceConfig.port,
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compliance-event-subscriber.js","sourceRoot":"","sources":["../../src/services/compliance-event-subscriber.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { entityEvents, type EntityEvent, type EntityEventSubscriber } from './entity-events.js';\nimport { InternalHttpClient } from './http-client.js';\nimport { serviceIdentity } from './service-keys.js';\nimport { getServiceAuthHeader } from '../middleware/auth.js';\nimport { type ServiceConfig } from '../types/common.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { errorMessage } from '../utils/response.js';\n\nconst logger = createLogger('compliance-events');\n\n/**\n * Registers an entity event subscriber that forwards events to the compliance service.\n *\n * Call this at service startup (in index.ts) to enable automatic compliance\n * notification on entity mutations. Events are fire-and-forget — failures\n * are logged but never block the original request.\n *\n * @param config - Optional service config override (defaults to COMPLIANCE_SERVICE_HOST/PORT env vars)\n * @param serviceName - Service identifier baked into the signed JWT's `sub`\n *   (e.g. 'pipeline', 'plugin'). The compliance route is an INTERNAL route: it\n *   admits only those two services' own signed tokens, and no user token.\n *   Defaults to THIS process's identity (`SERVICE_NAME`) — since #14 a service\n *   holds only its own signing key, so a placeholder name would mint a token no\n *   peer could verify.\n */\nexport function registerComplianceEventSubscriber(\n  config?: Partial<ServiceConfig>,\n  serviceName: string = serviceIdentity(),\n): void {\n  const serviceConfig: ServiceConfig = {\n    host: config?.host ?? process.env.COMPLIANCE_SERVICE_HOST ?? 'compliance',\n    port: config?.port ?? parseInt(process.env.COMPLIANCE_SERVICE_PORT ?? '3000', 10),\n  };\n\n  const client = new InternalHttpClient(serviceConfig);\n\n  const subscriber: EntityEventSubscriber = {\n    async onEntityEvent(event: EntityEvent): Promise<void> {\n      try {\n        // Mint a per-event service JWT scoped to the event's org so the\n        // compliance route's `runWithTenantContext` sees the right tenant\n        // GUC. The compliance side enforces `requireAuth` +\n        // `requireServicePrincipal` — the previous `x-internal-service`\n        // header is no longer sufficient (and was spoofable).\n        //\n        // This HTTP notify is the SINGLE delivery channel for post-mutation\n        // re-validation (primary enforcement is the fail-CLOSED live\n        // validate path). A stable per-event `Idempotency-Key` makes the POST\n        // retry-safe in the http-client, so a transient 5xx/timeout is retried\n        // rather than dropped on the first attempt; compliance re-evaluation is\n        // naturally idempotent, so a duplicate delivery is harmless.\n        const response = await client.post('/compliance/events/entity', event, {\n          headers: {\n            'Authorization': getServiceAuthHeader({ serviceName, orgId: event.orgId, role: 'member' }),\n            'Idempotency-Key': `${event.target}:${event.entityId}:${event.eventType}:${event.timestamp.toISOString()}`,\n          },\n        });\n        // The client RETURNS a terminal 4xx/5xx (retries exhausted) rather than\n        // throwing, so an unchecked call counted every rejection as delivered:\n        // a 403 from a mis-provisioned service identity, or a 500 from a broken\n        // compliance deploy, dropped every re-validation with no metric and no\n        // log. Route it through the same drop path as a transport error.\n        if (response.statusCode < 200 || response.statusCode >= 300) {\n          throw new Error(`compliance rejected the entity event with HTTP ${response.statusCode}`);\n        }\n      } catch (err) {\n        // Fire-and-forget: log + a drop metric so sustained loss is alertable\n        // (operators can't act on a warn line alone), then swallow — compliance\n        // notification is non-fatal to the originating mutation.\n        emitCounter('compliance_event_drop_total', { service: serviceName, target: event.target });\n        logger.warn('Failed to notify compliance service of entity event', {\n          target: event.target,\n          eventType: event.eventType,\n          entityId: event.entityId,\n          error: errorMessage(err),\n        });\n      }\n    },\n  };\n\n  entityEvents.subscribe(subscriber);\n  logger.info('Compliance event subscriber registered', {\n    host: serviceConfig.host,\n    port: serviceConfig.port,\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compliance-event-subscriber.js","sourceRoot":"","sources":["../../src/services/compliance-event-subscriber.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { entityEvents, type EntityEvent, type EntityEventSubscriber } from './entity-events.js';\nimport { InternalHttpClient } from './http-client.js';\nimport { serviceIdentity } from './service-keys.js';\nimport { getServiceAuthHeader } from '../middleware/service-tokens.js';\nimport { type ServiceConfig } from '../types/common.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { errorMessage } from '../utils/response.js';\nimport { serviceEndpoint } from '../utils/service-registry.js';\n\nconst logger = createLogger('compliance-events');\n\n/**\n * Registers an entity event subscriber that forwards events to the compliance service.\n *\n * Call this at service startup (in index.ts) to enable automatic compliance\n * notification on entity mutations. Events are fire-and-forget — failures\n * are logged but never block the original request.\n *\n * @param config - Optional service config override (defaults to COMPLIANCE_SERVICE_HOST/PORT env vars)\n * @param serviceName - Service identifier baked into the signed JWT's `sub`\n *   (e.g. 'pipeline', 'plugin'). The compliance route is an INTERNAL route: it\n *   admits only those two services' own signed tokens, and no user token.\n *   Defaults to THIS process's identity (`SERVICE_NAME`) — since #14 a service\n *   holds only its own signing key, so a placeholder name would mint a token no\n *   peer could verify.\n */\nexport function registerComplianceEventSubscriber(\n  config?: Partial<ServiceConfig>,\n  serviceName: string = serviceIdentity(),\n): void {\n  const serviceConfig: ServiceConfig = {\n    host: config?.host ?? serviceEndpoint('compliance').host,\n    port: config?.port ?? serviceEndpoint('compliance').port,\n  };\n\n  const client = new InternalHttpClient(serviceConfig);\n\n  const subscriber: EntityEventSubscriber = {\n    async onEntityEvent(event: EntityEvent): Promise<void> {\n      try {\n        // Mint a per-event service JWT scoped to the event's org so the\n        // compliance route's `runWithTenantContext` sees the right tenant\n        // GUC. The compliance side enforces `requireAuth` +\n        // `requireServicePrincipal`; no plaintext header is trusted.\n        //\n        // This HTTP notify is the SINGLE delivery channel for post-mutation\n        // re-validation (primary enforcement is the fail-CLOSED live\n        // validate path). A stable per-event `Idempotency-Key` makes the POST\n        // retry-safe in the http-client, so a transient 5xx/timeout is retried\n        // rather than dropped on the first attempt; compliance re-evaluation is\n        // naturally idempotent, so a duplicate delivery is harmless.\n        const response = await client.post('/compliance/events/entity', event, {\n          headers: {\n            'Authorization': getServiceAuthHeader({ serviceName, orgId: event.orgId, role: 'member' }),\n            'Idempotency-Key': `${event.target}:${event.entityId}:${event.eventType}:${event.timestamp.toISOString()}`,\n          },\n        });\n        // The client RETURNS a terminal 4xx/5xx (retries exhausted) rather than\n        // throwing, so an unchecked call counted every rejection as delivered:\n        // a 403 from a mis-provisioned service identity, or a 500 from a broken\n        // compliance deploy, dropped every re-validation with no metric and no\n        // log. Route it through the same drop path as a transport error.\n        if (response.statusCode < 200 || response.statusCode >= 300) {\n          throw new Error(`compliance rejected the entity event with HTTP ${response.statusCode}`);\n        }\n      } catch (err) {\n        // Fire-and-forget: log + a drop metric so sustained loss is alertable\n        // (operators can't act on a warn line alone), then swallow — compliance\n        // notification is non-fatal to the originating mutation.\n        emitCounter('compliance_event_drop_total', { service: serviceName, target: event.target });\n        logger.warn('Failed to notify compliance service of entity event', {\n          target: event.target,\n          eventType: event.eventType,\n          entityId: event.entityId,\n          error: errorMessage(err),\n        });\n      }\n    },\n  };\n\n  entityEvents.subscribe(subscriber);\n  logger.info('Compliance event subscriber registered', {\n    host: serviceConfig.host,\n    port: serviceConfig.port,\n  });\n}\n"]}