@pipeline-builder/api-core 3.4.109 → 3.4.111

package/lib/services/sse-ticket-store.js

@@ -0,0 +1,125 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import crypto from 'crypto';
+import { createEnvRedisClient } from './env-redis.js';
+import { createLogger } from '../utils/logger.js';
+const logger = createLogger('sse-ticket-store');
+/** Redis key namespaces. Ticket → orgId; windowed issue counters bound abuse. */
+const TICKET_KEY_PREFIX = 'sse:tk:';
+const ORG_COUNT_PREFIX = 'sse:tkc:';
+const TOTAL_COUNT_KEY = 'sse:tkc:__all__';
+function newTicketId() {
+    return crypto.randomBytes(24).toString('base64url');
+}
+/**
+ * In-memory backend — the original single-process behaviour. Counts LIVE
+ * (unexpired) tickets per org and evicts expired entries on a timer. Correct
+ * only within one process, so it is the fallback used when Redis isn't configured.
+ */
+function createInMemorySseTicketStore(config) {
+    const store = new Map();
+    const cleanup = setInterval(() => {
+        const now = Date.now();
+        for (const [id, t] of store)
+            if (now > t.expiresAt)
+                store.delete(id);
+    }, config.ttlMs);
+    cleanup.unref();
+    function countLiveForOrg(orgId, now) {
+        let count = 0;
+        for (const t of store.values())
+            if (t.orgId === orgId && t.expiresAt > now)
+                count++;
+        return count;
+    }
+    return {
+        async issue(orgId) {
+            const now = Date.now();
+            if (store.size >= config.maxTotal)
+                return { ok: false, reason: 'total' };
+            if (countLiveForOrg(orgId, now) >= config.maxPerOrg)
+                return { ok: false, reason: 'org' };
+            const ticket = newTicketId();
+            store.set(ticket, { orgId, expiresAt: now + config.ttlMs });
+            return { ok: true, ticket };
+        },
+        async consume(ticketId) {
+            const t = store.get(ticketId);
+            store.delete(ticketId); // single-use — consume immediately
+            if (!t || Date.now() > t.expiresAt)
+                return null;
+            return { orgId: t.orgId };
+        },
+        stop() { clearInterval(cleanup); },
+    };
+}
+/**
+ * Redis backend — multi-replica safe. Tickets live under a TTL'd key so any pod
+ * can redeem one; {@link SseTicketStore.consume} uses GETDEL so redemption is
+ * atomic (two pods can't both spend the same ticket). The per-org / global caps
+ * become windowed rate limits (max mints per TTL window) via INCR + first-hit
+ * EXPIRE — equivalent abuse bounding to the in-memory live-count, and it also
+ * caps churn.
+ *
+ * Fail-CLOSED by design (unlike the fail-open token-revocation reader): if Redis
+ * errors, `issue` returns a cap rejection and `consume` returns null, so a Redis
+ * outage degrades to "no live notifications" rather than handing out or
+ * accepting unvalidated tickets. SSE notifications are non-critical, so failing
+ * closed here costs only real-time delivery, never correctness.
+ */
+function createRedisSseTicketStore(redis, config) {
+    const ttlSec = Math.max(1, Math.ceil(config.ttlMs / 1000));
+    // Windowed counter: INCR, and on the first hit of a window set the TTL so it
+    // auto-resets. Returns true while still within `limit` for this window.
+    async function withinWindow(key, limit) {
+        const n = await redis.incr(key);
+        if (n === 1)
+            await redis.expire(key, ttlSec);
+        return n <= limit;
+    }
+    return {
+        async issue(orgId) {
+            try {
+                if (!(await withinWindow(TOTAL_COUNT_KEY, config.maxTotal)))
+                    return { ok: false, reason: 'total' };
+                if (!(await withinWindow(`${ORG_COUNT_PREFIX}${orgId}`, config.maxPerOrg)))
+                    return { ok: false, reason: 'org' };
+                const ticket = newTicketId();
+                await redis.set(`${TICKET_KEY_PREFIX}${ticket}`, orgId, 'EX', ttlSec);
+                return { ok: true, ticket };
+            }
+            catch (err) {
+                logger.warn('SSE ticket issue failed (fail-closed)', { error: err instanceof Error ? err.message : String(err) });
+                return { ok: false, reason: 'total' };
+            }
+        },
+        async consume(ticketId) {
+            try {
+                const orgId = await redis.getdel(`${TICKET_KEY_PREFIX}${ticketId}`);
+                return orgId ? { orgId } : null;
+            }
+            catch (err) {
+                logger.warn('SSE ticket consume failed (fail-closed)', { error: err instanceof Error ? err.message : String(err) });
+                return null;
+            }
+        },
+        stop() { },
+    };
+}
+/**
+ * Build an {@link SseTicketStore} from the standard Redis env (`REDIS_URL` or
+ * `REDIS_HOST`/`REDIS_PORT`). Uses the Redis backend when configured
+ * (multi-replica safe), otherwise falls back to the in-memory single-process
+ * backend. A service opts in with one boot line:
+ *   `const tickets = createEnvSseTicketStore({ ttlMs, maxTotal, maxPerOrg });`
+ */
+export function createEnvSseTicketStore(config) {
+    const redis = createEnvRedisClient('sse-ticket');
+    if (redis) {
+        logger.info('SSE ticket store: Redis backend (multi-replica)');
+        return createRedisSseTicketStore(redis, config);
+    }
+    logger.info('SSE ticket store: in-memory backend (single-process fallback)');
+    return createInMemorySseTicketStore(config);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sse-ticket-store.js","sourceRoot":"","sources":["../../src/services/sse-ticket-store.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,MAAM,MAAM,QAAQ,CAAC;AAE5B,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,MAAM,GAAG,YAAY,CAAC,kBAAkB,CAAC,CAAC;AAEhD,iFAAiF;AACjF,MAAM,iBAAiB,GAAG,SAAS,CAAC;AACpC,MAAM,gBAAgB,GAAG,UAAU,CAAC;AACpC,MAAM,eAAe,GAAG,iBAAiB,CAAC;AA2C1C,SAAS,WAAW;IAClB,OAAO,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;AACtD,CAAC;AAED;;;;GAIG;AACH,SAAS,4BAA4B,CAAC,MAA4B;IAEhE,MAAM,KAAK,GAAG,IAAI,GAAG,EAAiB,CAAC;IAEvC,MAAM,OAAO,GAAG,WAAW,CAAC,GAAG,EAAE;QAC/B,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,KAAK,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,KAAK;YAAE,IAAI,GAAG,GAAG,CAAC,CAAC,SAAS;gBAAE,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IACvE,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACjB,OAAO,CAAC,KAAK,EAAE,CAAC;IAEhB,SAAS,eAAe,CAAC,KAAa,EAAE,GAAW;QACjD,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,KAAK,MAAM,CAAC,IAAI,KAAK,CAAC,MAAM,EAAE;YAAE,IAAI,CAAC,CAAC,KAAK,KAAK,KAAK,IAAI,CAAC,CAAC,SAAS,GAAG,GAAG;gBAAE,KAAK,EAAE,CAAC;QACpF,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO;QACL,KAAK,CAAC,KAAK,CAAC,KAAa;YACvB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YACvB,IAAI,KAAK,CAAC,IAAI,IAAI,MAAM,CAAC,QAAQ;gBAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;YACzE,IAAI,eAAe,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,SAAS;gBAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;YACzF,MAAM,MAAM,GAAG,WAAW,EAAE,CAAC;YAC7B,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,GAAG,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;YAC5D,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAC9B,CAAC;QACD,KAAK,CAAC,OAAO,CAAC,QAAgB;YAC5B,MAAM,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YAC9B,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,mCAAmC;YAC3D,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,SAAS;gBAAE,OAAO,IAAI,CAAC;YAChD,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;QAC5B,CAAC;QACD,IAAI,KAAW,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;KACzC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAS,yBAAyB,CAAC,KAAe,EAAE,MAA4B;IAC9E,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC;IAE3D,6EAA6E;IAC7E,wEAAwE;IACxE,KAAK,UAAU,YAAY,CAAC,GAAW,EAAE,KAAa;QACpD,MAAM,CAAC,GAAG,MAAM,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAChC,IAAI,CAAC,KAAK,CAAC;YAAE,MAAM,KAAK,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;QAC7C,OAAO,CAAC,IAAI,KAAK,CAAC;IACpB,CAAC;IAED,OAAO;QACL,KAAK,CAAC,KAAK,CAAC,KAAa;YACvB,IAAI,CAAC;gBACH,IAAI,CAAC,CAAC,MAAM,YAAY,CAAC,eAAe,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;oBAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;gBACnG,IAAI,CAAC,CAAC,MAAM,YAAY,CAAC,GAAG,gBAAgB,GAAG,KAAK,EAAE,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC;oBAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;gBAChH,MAAM,MAAM,GAAG,WAAW,EAAE,CAAC;gBAC7B,MAAM,KAAK,CAAC,GAAG,CAAC,GAAG,iBAAiB,GAAG,MAAM,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;gBACtE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;YAC9B,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,MAAM,CAAC,IAAI,CAAC,uCAAuC,EAAE,EAAE,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBAClH,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;YACxC,CAAC;QACH,CAAC;QACD,KAAK,CAAC,OAAO,CAAC,QAAgB;YAC5B,IAAI,CAAC;gBACH,MAAM,KAAK,GAAG,MAAM,KAAK,CAAC,MAAM,CAAC,GAAG,iBAAiB,GAAG,QAAQ,EAAE,CAAC,CAAC;gBACpE,OAAO,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;YAClC,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,MAAM,CAAC,IAAI,CAAC,yCAAyC,EAAE,EAAE,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBACpH,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;QACD,IAAI,KAA0E,CAAC;KAChF,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CAAC,MAA4B;IAClE,MAAM,KAAK,GAAG,oBAAoB,CAAW,YAAY,CAAC,CAAC;IAC3D,IAAI,KAAK,EAAE,CAAC;QACV,MAAM,CAAC,IAAI,CAAC,iDAAiD,CAAC,CAAC;QAC/D,OAAO,yBAAyB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAClD,CAAC;IACD,MAAM,CAAC,IAAI,CAAC,+DAA+D,CAAC,CAAC;IAC7E,OAAO,4BAA4B,CAAC,MAAM,CAAC,CAAC;AAC9C,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport crypto from 'crypto';\n\nimport { createEnvRedisClient } from './env-redis.js';\nimport { createLogger } from '../utils/logger.js';\n\nconst logger = createLogger('sse-ticket-store');\n\n/** Redis key namespaces. Ticket → orgId; windowed issue counters bound abuse. */\nconst TICKET_KEY_PREFIX = 'sse:tk:';\nconst ORG_COUNT_PREFIX = 'sse:tkc:';\nconst TOTAL_COUNT_KEY = 'sse:tkc:__all__';\n\n/** Result of {@link SseTicketStore.issue}. */\nexport type SseTicketIssueResult =\n  | { ok: true; ticket: string }\n  | { ok: false; reason: 'total' | 'org' };\n\n/**\n * Store for short-lived, single-use SSE auth tickets. A client exchanges its JWT\n * for a ticket (so the token never lands in an EventSource query string / access\n * log), then redeems it on the SSE `GET`.\n *\n * The store is the multi-replica correctness boundary: a ticket minted on pod A\n * MUST be redeemable on pod B. The Redis backend makes that true; the in-memory\n * backend is a single-process fallback for dev / single-replica installs.\n */\nexport interface SseTicketStore {\n  /** Mint a ticket for `orgId`, or reject when a rate window is saturated. */\n  issue(orgId: string): Promise<SseTicketIssueResult>;\n  /** Atomically redeem a ticket exactly once; returns its org or null if invalid/expired/spent. */\n  consume(ticketId: string): Promise<{ orgId: string } | null>;\n  /** Release timers/resources. In-memory clears its sweep interval; Redis is a no-op. */\n  stop(): void;\n}\n\n/** Caps + TTL for the ticket store. */\nexport interface SseTicketStoreConfig {\n  /** Ticket lifetime — long enough for the client to open the EventSource. */\n  ttlMs: number;\n  /** Hard cap on tickets minted per TTL window across all orgs (abuse bound). */\n  maxTotal: number;\n  /** Per-org cap on tickets minted per TTL window (single-tenant abuse bound). */\n  maxPerOrg: number;\n}\n\n/** Minimal ioredis surface this store needs (GETDEL requires Redis ≥ 6.2). */\ninterface SseRedis {\n  incr(key: string): Promise<number>;\n  expire(key: string, seconds: number): Promise<unknown>;\n  set(key: string, value: string, ...args: unknown[]): Promise<unknown>;\n  getdel(key: string): Promise<string | null>;\n}\n\nfunction newTicketId(): string {\n  return crypto.randomBytes(24).toString('base64url');\n}\n\n/**\n * In-memory backend — the original single-process behaviour. Counts LIVE\n * (unexpired) tickets per org and evicts expired entries on a timer. Correct\n * only within one process, so it is the fallback used when Redis isn't configured.\n */\nfunction createInMemorySseTicketStore(config: SseTicketStoreConfig): SseTicketStore {\n  interface Entry { orgId: string; expiresAt: number }\n  const store = new Map<string, Entry>();\n\n  const cleanup = setInterval(() => {\n    const now = Date.now();\n    for (const [id, t] of store) if (now > t.expiresAt) store.delete(id);\n  }, config.ttlMs);\n  cleanup.unref();\n\n  function countLiveForOrg(orgId: string, now: number): number {\n    let count = 0;\n    for (const t of store.values()) if (t.orgId === orgId && t.expiresAt > now) count++;\n    return count;\n  }\n\n  return {\n    async issue(orgId: string): Promise<SseTicketIssueResult> {\n      const now = Date.now();\n      if (store.size >= config.maxTotal) return { ok: false, reason: 'total' };\n      if (countLiveForOrg(orgId, now) >= config.maxPerOrg) return { ok: false, reason: 'org' };\n      const ticket = newTicketId();\n      store.set(ticket, { orgId, expiresAt: now + config.ttlMs });\n      return { ok: true, ticket };\n    },\n    async consume(ticketId: string): Promise<{ orgId: string } | null> {\n      const t = store.get(ticketId);\n      store.delete(ticketId); // single-use — consume immediately\n      if (!t || Date.now() > t.expiresAt) return null;\n      return { orgId: t.orgId };\n    },\n    stop(): void { clearInterval(cleanup); },\n  };\n}\n\n/**\n * Redis backend — multi-replica safe. Tickets live under a TTL'd key so any pod\n * can redeem one; {@link SseTicketStore.consume} uses GETDEL so redemption is\n * atomic (two pods can't both spend the same ticket). The per-org / global caps\n * become windowed rate limits (max mints per TTL window) via INCR + first-hit\n * EXPIRE — equivalent abuse bounding to the in-memory live-count, and it also\n * caps churn.\n *\n * Fail-CLOSED by design (unlike the fail-open token-revocation reader): if Redis\n * errors, `issue` returns a cap rejection and `consume` returns null, so a Redis\n * outage degrades to \"no live notifications\" rather than handing out or\n * accepting unvalidated tickets. SSE notifications are non-critical, so failing\n * closed here costs only real-time delivery, never correctness.\n */\nfunction createRedisSseTicketStore(redis: SseRedis, config: SseTicketStoreConfig): SseTicketStore {\n  const ttlSec = Math.max(1, Math.ceil(config.ttlMs / 1000));\n\n  // Windowed counter: INCR, and on the first hit of a window set the TTL so it\n  // auto-resets. Returns true while still within `limit` for this window.\n  async function withinWindow(key: string, limit: number): Promise<boolean> {\n    const n = await redis.incr(key);\n    if (n === 1) await redis.expire(key, ttlSec);\n    return n <= limit;\n  }\n\n  return {\n    async issue(orgId: string): Promise<SseTicketIssueResult> {\n      try {\n        if (!(await withinWindow(TOTAL_COUNT_KEY, config.maxTotal))) return { ok: false, reason: 'total' };\n        if (!(await withinWindow(`${ORG_COUNT_PREFIX}${orgId}`, config.maxPerOrg))) return { ok: false, reason: 'org' };\n        const ticket = newTicketId();\n        await redis.set(`${TICKET_KEY_PREFIX}${ticket}`, orgId, 'EX', ttlSec);\n        return { ok: true, ticket };\n      } catch (err) {\n        logger.warn('SSE ticket issue failed (fail-closed)', { error: err instanceof Error ? err.message : String(err) });\n        return { ok: false, reason: 'total' };\n      }\n    },\n    async consume(ticketId: string): Promise<{ orgId: string } | null> {\n      try {\n        const orgId = await redis.getdel(`${TICKET_KEY_PREFIX}${ticketId}`);\n        return orgId ? { orgId } : null;\n      } catch (err) {\n        logger.warn('SSE ticket consume failed (fail-closed)', { error: err instanceof Error ? err.message : String(err) });\n        return null;\n      }\n    },\n    stop(): void { /* Redis keys expire on their own TTL — nothing to release. */ },\n  };\n}\n\n/**\n * Build an {@link SseTicketStore} from the standard Redis env (`REDIS_URL` or\n * `REDIS_HOST`/`REDIS_PORT`). Uses the Redis backend when configured\n * (multi-replica safe), otherwise falls back to the in-memory single-process\n * backend. A service opts in with one boot line:\n *   `const tickets = createEnvSseTicketStore({ ttlMs, maxTotal, maxPerOrg });`\n */\nexport function createEnvSseTicketStore(config: SseTicketStoreConfig): SseTicketStore {\n  const redis = createEnvRedisClient<SseRedis>('sse-ticket');\n  if (redis) {\n    logger.info('SSE ticket store: Redis backend (multi-replica)');\n    return createRedisSseTicketStore(redis, config);\n  }\n  logger.info('SSE ticket store: in-memory backend (single-process fallback)');\n  return createInMemorySseTicketStore(config);\n}\n"]}

package/lib/types/error-codes.d.ts

@@ -33,6 +33,12 @@ export declare enum ErrorCode {
     CONFLICT = "CONFLICT",
     DUPLICATE_ENTRY = "DUPLICATE_ENTRY",
     SCAN_CONFLICT = "SCAN_CONFLICT",
+    PAYMENT_METHOD_REQUIRED = "PAYMENT_METHOD_REQUIRED",// 402
+    DISCOUNT_CEILING_EXCEEDED = "DISCOUNT_CEILING_EXCEEDED",// 400
+    DISCOUNT_NOT_FOUND = "DISCOUNT_NOT_FOUND",// 404
+    DISCOUNT_INACTIVE = "DISCOUNT_INACTIVE",// 409
+    PLAN_OVER_CAP = "PLAN_OVER_CAP",// 409
+    ADDON_OVER_CAP = "ADDON_OVER_CAP",// 409
     INTERNAL_ERROR = "INTERNAL_ERROR",
     DATABASE_ERROR = "DATABASE_ERROR",
     SERVICE_UNAVAILABLE = "SERVICE_UNAVAILABLE",

package/lib/types/error-codes.js

@@ -43,6 +43,13 @@ export var ErrorCode;
     ErrorCode["CONFLICT"] = "CONFLICT";
     ErrorCode["DUPLICATE_ENTRY"] = "DUPLICATE_ENTRY";
     ErrorCode["SCAN_CONFLICT"] = "SCAN_CONFLICT";
+    // Billing errors
+    ErrorCode["PAYMENT_METHOD_REQUIRED"] = "PAYMENT_METHOD_REQUIRED";
+    ErrorCode["DISCOUNT_CEILING_EXCEEDED"] = "DISCOUNT_CEILING_EXCEEDED";
+    ErrorCode["DISCOUNT_NOT_FOUND"] = "DISCOUNT_NOT_FOUND";
+    ErrorCode["DISCOUNT_INACTIVE"] = "DISCOUNT_INACTIVE";
+    ErrorCode["PLAN_OVER_CAP"] = "PLAN_OVER_CAP";
+    ErrorCode["ADDON_OVER_CAP"] = "ADDON_OVER_CAP";
     // Server errors (500)
     ErrorCode["INTERNAL_ERROR"] = "INTERNAL_ERROR";
     ErrorCode["DATABASE_ERROR"] = "DATABASE_ERROR";
@@ -80,6 +87,12 @@ export const ErrorCodeStatus = {
     [ErrorCode.CONFLICT]: 409,
     [ErrorCode.DUPLICATE_ENTRY]: 409,
     [ErrorCode.SCAN_CONFLICT]: 409,
+    [ErrorCode.PAYMENT_METHOD_REQUIRED]: 402,
+    [ErrorCode.DISCOUNT_CEILING_EXCEEDED]: 400,
+    [ErrorCode.DISCOUNT_NOT_FOUND]: 404,
+    [ErrorCode.DISCOUNT_INACTIVE]: 409,
+    [ErrorCode.PLAN_OVER_CAP]: 409,
+    [ErrorCode.ADDON_OVER_CAP]: 409,
     [ErrorCode.INTERNAL_ERROR]: 500,
     [ErrorCode.DATABASE_ERROR]: 500,
     [ErrorCode.SERVICE_UNAVAILABLE]: 503,
@@ -91,4 +104,4 @@ export const ErrorCodeStatus = {
 export function getStatusForErrorCode(code) {
     return ErrorCodeStatus[code] ?? 500;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error-codes.js","sourceRoot":"","sources":["../../src/types/error-codes.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Standardized error codes used across all API microservices.\n * Use these codes in error responses for consistent client handling.\n *\n * Each HTTP status category has one primary code. Use the `details`\n * field in error responses for sub-type information (e.g. which quota\n * was exceeded, which field failed validation).\n */\nexport enum ErrorCode {\n  // Authentication errors (401)\n  UNAUTHORIZED = 'UNAUTHORIZED',\n  TOKEN_EXPIRED = 'TOKEN_EXPIRED',\n  TOKEN_INVALID = 'TOKEN_INVALID',\n  TOKEN_MISSING = 'TOKEN_MISSING',\n  TOKEN_REVOKED = 'TOKEN_REVOKED',\n\n  // Authorization errors (403)\n  INSUFFICIENT_PERMISSIONS = 'INSUFFICIENT_PERMISSIONS',\n  ORG_MISMATCH = 'ORG_MISMATCH',\n  COMPLIANCE_VIOLATION = 'COMPLIANCE_VIOLATION',\n\n  // Not found errors (404)\n  NOT_FOUND = 'NOT_FOUND',\n  ORG_NOT_FOUND = 'ORG_NOT_FOUND',\n\n  // Validation errors (400)\n  VALIDATION_ERROR = 'VALIDATION_ERROR',\n  MISSING_REQUIRED_FIELD = 'MISSING_REQUIRED_FIELD',\n  TEMPLATE_UNKNOWN_PATH = 'TEMPLATE_UNKNOWN_PATH',\n  TEMPLATE_CYCLE = 'TEMPLATE_CYCLE',\n  TEMPLATE_PARSE_ERROR = 'TEMPLATE_PARSE_ERROR',\n  TEMPLATE_TYPE_MISMATCH = 'TEMPLATE_TYPE_MISMATCH',\n  TEMPLATE_SECRETS_RESERVED = 'TEMPLATE_SECRETS_RESERVED',\n  TEMPLATE_CONTRACT_VIOLATION = 'TEMPLATE_CONTRACT_VIOLATION',\n  TEMPLATE_SIZE_EXCEEDED = 'TEMPLATE_SIZE_EXCEEDED',\n  TEMPLATE_VALIDATION_FAILED = 'TEMPLATE_VALIDATION_FAILED',\n\n  // Quota/Rate limit errors (429)\n  QUOTA_EXCEEDED = 'QUOTA_EXCEEDED',\n  RATE_LIMIT_EXCEEDED = 'RATE_LIMIT_EXCEEDED',\n\n  // Payload errors (413)\n  PAYLOAD_TOO_LARGE = 'PAYLOAD_TOO_LARGE',\n\n  // Conflict errors (409)\n  CONFLICT = 'CONFLICT',\n  DUPLICATE_ENTRY = 'DUPLICATE_ENTRY',\n  SCAN_CONFLICT = 'SCAN_CONFLICT',\n\n  // Billing errors\n  PAYMENT_METHOD_REQUIRED = 'PAYMENT_METHOD_REQUIRED', // 402\n  DISCOUNT_CEILING_EXCEEDED = 'DISCOUNT_CEILING_EXCEEDED', // 400\n  DISCOUNT_NOT_FOUND = 'DISCOUNT_NOT_FOUND', // 404\n  DISCOUNT_INACTIVE = 'DISCOUNT_INACTIVE', // 409\n  PLAN_OVER_CAP = 'PLAN_OVER_CAP', // 409\n  ADDON_OVER_CAP = 'ADDON_OVER_CAP', // 409\n\n  // Server errors (500)\n  INTERNAL_ERROR = 'INTERNAL_ERROR',\n  DATABASE_ERROR = 'DATABASE_ERROR',\n\n  // Service unavailable (503)\n  SERVICE_UNAVAILABLE = 'SERVICE_UNAVAILABLE',\n  COMPLIANCE_SERVICE_UNAVAILABLE = 'COMPLIANCE_SERVICE_UNAVAILABLE',\n}\n\n/**\n * Maps error codes to their default HTTP status codes.\n */\nexport const ErrorCodeStatus: Record<ErrorCode, number> = {\n  [ErrorCode.UNAUTHORIZED]: 401,\n  [ErrorCode.TOKEN_EXPIRED]: 401,\n  [ErrorCode.TOKEN_INVALID]: 401,\n  [ErrorCode.TOKEN_MISSING]: 401,\n  [ErrorCode.TOKEN_REVOKED]: 401,\n  [ErrorCode.INSUFFICIENT_PERMISSIONS]: 403,\n  [ErrorCode.ORG_MISMATCH]: 403,\n  [ErrorCode.COMPLIANCE_VIOLATION]: 403,\n  [ErrorCode.NOT_FOUND]: 404,\n  [ErrorCode.ORG_NOT_FOUND]: 404,\n  [ErrorCode.VALIDATION_ERROR]: 400,\n  [ErrorCode.MISSING_REQUIRED_FIELD]: 400,\n  [ErrorCode.TEMPLATE_UNKNOWN_PATH]: 400,\n  [ErrorCode.TEMPLATE_CYCLE]: 400,\n  [ErrorCode.TEMPLATE_PARSE_ERROR]: 400,\n  [ErrorCode.TEMPLATE_TYPE_MISMATCH]: 400,\n  [ErrorCode.TEMPLATE_SECRETS_RESERVED]: 400,\n  [ErrorCode.TEMPLATE_CONTRACT_VIOLATION]: 400,\n  [ErrorCode.TEMPLATE_SIZE_EXCEEDED]: 400,\n  [ErrorCode.TEMPLATE_VALIDATION_FAILED]: 400,\n  [ErrorCode.QUOTA_EXCEEDED]: 429,\n  [ErrorCode.RATE_LIMIT_EXCEEDED]: 429,\n  [ErrorCode.PAYLOAD_TOO_LARGE]: 413,\n  [ErrorCode.CONFLICT]: 409,\n  [ErrorCode.DUPLICATE_ENTRY]: 409,\n  [ErrorCode.SCAN_CONFLICT]: 409,\n  [ErrorCode.PAYMENT_METHOD_REQUIRED]: 402,\n  [ErrorCode.DISCOUNT_CEILING_EXCEEDED]: 400,\n  [ErrorCode.DISCOUNT_NOT_FOUND]: 404,\n  [ErrorCode.DISCOUNT_INACTIVE]: 409,\n  [ErrorCode.PLAN_OVER_CAP]: 409,\n  [ErrorCode.ADDON_OVER_CAP]: 409,\n  [ErrorCode.INTERNAL_ERROR]: 500,\n  [ErrorCode.DATABASE_ERROR]: 500,\n  [ErrorCode.SERVICE_UNAVAILABLE]: 503,\n  [ErrorCode.COMPLIANCE_SERVICE_UNAVAILABLE]: 503,\n};\n\n/**\n * Get the HTTP status code for an error code.\n */\nexport function getStatusForErrorCode(code: ErrorCode): number {\n  return ErrorCodeStatus[code] ?? 500;\n}\n"]}

package/lib/utils/alias-resolver.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Clear the memoized alias set so the next access re-reads `SUPPORT_ALIASES`.
+ * The cache is process-lifetime by design (env is fixed per process); this hook
+ * exists so tests can vary the env between cases.
+ */
+export declare function resetSupportAliasesCache(): void;
 /** Well-known fallback support alias used when SUPPORT_ALIASES is unconfigured. */
 export declare const DEFAULT_SUPPORT_ALIAS = "support@pipeline-builder";
 /**
@@ -7,6 +13,12 @@ export declare const DEFAULT_SUPPORT_ALIAS = "support@pipeline-builder";
  * is unset. (All configured aliases still resolve via {@link resolveRecipientAlias}.)
  */
 export declare function getPrimarySupportAlias(): string;
+/**
+ * ALL configured support aliases (order preserved), for UIs that surface every
+ * support inbox as a distinct recipient suggestion. Falls back to a single
+ * {@link DEFAULT_SUPPORT_ALIAS} when SUPPORT_ALIASES is unset.
+ */
+export declare function getAllSupportAliases(): string[];
 /** Result of alias resolution. */
 export interface AliasResolution {
     /** The resolved organization ID (e.g., 'system'). */

package/lib/utils/alias-resolver.js

@@ -13,6 +13,14 @@ function getSupportAliases() {
     }
     return _supportAliases;
 }
+/**
+ * Clear the memoized alias set so the next access re-reads `SUPPORT_ALIASES`.
+ * The cache is process-lifetime by design (env is fixed per process); this hook
+ * exists so tests can vary the env between cases.
+ */
+export function resetSupportAliasesCache() {
+    _supportAliases = undefined;
+}
 /** Well-known fallback support alias used when SUPPORT_ALIASES is unconfigured. */
 export const DEFAULT_SUPPORT_ALIAS = 'support@pipeline-builder';
 /**
@@ -26,6 +34,15 @@ export function getPrimarySupportAlias() {
         return alias;
     return DEFAULT_SUPPORT_ALIAS;
 }
+/**
+ * ALL configured support aliases (order preserved), for UIs that surface every
+ * support inbox as a distinct recipient suggestion. Falls back to a single
+ * {@link DEFAULT_SUPPORT_ALIAS} when SUPPORT_ALIASES is unset.
+ */
+export function getAllSupportAliases() {
+    const all = [...getSupportAliases()];
+    return all.length > 0 ? all : [DEFAULT_SUPPORT_ALIAS];
+}
 /**
  * Resolve an email-like alias to an actual organization ID.
  *
@@ -48,4 +65,4 @@ export function resolveRecipientAlias(recipientOrgId) {
         originalValue: recipientOrgId,
     };
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxpYXMtcmVzb2x2ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvYWxpYXMtcmVzb2x2ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQUV0QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFFdEQseUZBQXlGO0FBQ3pGLElBQUksZUFBd0MsQ0FBQztBQUU3QyxTQUFTLGlCQUFpQjtJQUN4QixJQUFJLENBQUMsZUFBZSxFQUFFLENBQUM7UUFDckIsTUFBTSxHQUFHLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQyxlQUFlLElBQUksRUFBRSxDQUFDO1FBQzlDLGVBQWUsR0FBRyxJQUFJLEdBQUcsQ0FDdkIsR0FBRzthQUNBLEtBQUssQ0FBQyxHQUFHLENBQUM7YUFDVixHQUFHLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLENBQUMsV0FBVyxFQUFFLENBQUM7YUFDeEMsTUFBTSxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUMsS0FBSyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FDckMsQ0FBQztJQUNKLENBQUM7SUFDRCxPQUFPLGVBQWUsQ0FBQztBQUN6QixDQUFDO0FBRUQsbUZBQW1GO0FBQ25GLE1BQU0sQ0FBQyxNQUFNLHFCQUFxQixHQUFHLDBCQUEwQixDQUFDO0FBRWhFOzs7OztHQUtHO0FBQ0gsTUFBTSxVQUFVLHNCQUFzQjtJQUNwQyxLQUFLLE1BQU0sS0FBSyxJQUFJLGlCQUFpQixFQUFFO1FBQUUsT0FBTyxLQUFLLENBQUM7SUFDdEQsT0FBTyxxQkFBcUIsQ0FBQztBQUMvQixDQUFDO0FBWUQ7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQVUscUJBQXFCLENBQUMsY0FBc0I7SUFDMUQsTUFBTSxVQUFVLEdBQUcsY0FBYyxDQUFDLElBQUksRUFBRSxDQUFDLFdBQVcsRUFBRSxDQUFDO0lBQ3ZELE1BQU0sT0FBTyxHQUFHLGlCQUFpQixFQUFFLENBQUM7SUFFcEMsSUFBSSxPQUFPLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxFQUFFLENBQUM7UUFDNUIsT0FBTztZQUNMLGFBQWEsRUFBRSxhQUFhO1lBQzVCLFFBQVEsRUFBRSxJQUFJO1lBQ2QsYUFBYSxFQUFFLGNBQWM7U0FDOUIsQ0FBQztJQUNKLENBQUM7SUFFRCxPQUFPO1FBQ0wsYUFBYSxFQUFFLFVBQVU7UUFDekIsUUFBUSxFQUFFLEtBQUs7UUFDZixhQUFhLEVBQUUsY0FBYztLQUM5QixDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG5pbXBvcnQgeyBTWVNURU1fT1JHX0lEIH0gZnJvbSAnLi4vbWlkZGxld2FyZS9hdXRoLmpzJztcblxuLyoqIExhemlseS1jYWNoZWQgc2V0IG9mIHN1cHBvcnQgYWxpYXNlcywgcGFyc2VkIGZyb20gU1VQUE9SVF9BTElBU0VTIG9uIGZpcnN0IGFjY2Vzcy4gKi9cbmxldCBfc3VwcG9ydEFsaWFzZXM6IFNldDxzdHJpbmc+IHwgdW5kZWZpbmVkO1xuXG5mdW5jdGlvbiBnZXRTdXBwb3J0QWxpYXNlcygpOiBTZXQ8c3RyaW5nPiB7XG4gIGlmICghX3N1cHBvcnRBbGlhc2VzKSB7XG4gICAgY29uc3QgcmF3ID0gcHJvY2Vzcy5lbnYuU1VQUE9SVF9BTElBU0VTIHx8ICcnO1xuICAgIF9zdXBwb3J0QWxpYXNlcyA9IG5ldyBTZXQoXG4gICAgICByYXdcbiAgICAgICAgLnNwbGl0KCcsJylcbiAgICAgICAgLm1hcChhbGlhcyA9PiBhbGlhcy50cmltKCkudG9Mb3dlckNhc2UoKSlcbiAgICAgICAgLmZpbHRlcihhbGlhcyA9PiBhbGlhcy5sZW5ndGggPiAwKSxcbiAgICApO1xuICB9XG4gIHJldHVybiBfc3VwcG9ydEFsaWFzZXM7XG59XG5cbi8qKiBXZWxsLWtub3duIGZhbGxiYWNrIHN1cHBvcnQgYWxpYXMgdXNlZCB3aGVuIFNVUFBPUlRfQUxJQVNFUyBpcyB1bmNvbmZpZ3VyZWQuICovXG5leHBvcnQgY29uc3QgREVGQVVMVF9TVVBQT1JUX0FMSUFTID0gJ3N1cHBvcnRAcGlwZWxpbmUtYnVpbGRlcic7XG5cbi8qKlxuICogVGhlIFBSSU1BUlkgKGZpcnN0LWNvbmZpZ3VyZWQpIHN1cHBvcnQgYWxpYXMg4oCUIGZvciBkaXNwbGF5IC8gcHJlZmlsbCBpbiBVSXNcbiAqIChlLmcuIHRoZSBjb21wb3NlIFwiVG9cIiBmaWVsZCksIHNvIHRoZSBzaG93biB2YWx1ZSBpcyBkcml2ZW4gYnkgU1VQUE9SVF9BTElBU0VTXG4gKiByYXRoZXIgdGhhbiBoYXJkY29kZWQuIEZhbGxzIGJhY2sgdG8ge0BsaW5rIERFRkFVTFRfU1VQUE9SVF9BTElBU30gd2hlbiB0aGUgZW52XG4gKiBpcyB1bnNldC4gKEFsbCBjb25maWd1cmVkIGFsaWFzZXMgc3RpbGwgcmVzb2x2ZSB2aWEge0BsaW5rIHJlc29sdmVSZWNpcGllbnRBbGlhc30uKVxuICovXG5leHBvcnQgZnVuY3Rpb24gZ2V0UHJpbWFyeVN1cHBvcnRBbGlhcygpOiBzdHJpbmcge1xuICBmb3IgKGNvbnN0IGFsaWFzIG9mIGdldFN1cHBvcnRBbGlhc2VzKCkpIHJldHVybiBhbGlhcztcbiAgcmV0dXJuIERFRkFVTFRfU1VQUE9SVF9BTElBUztcbn1cblxuLyoqIFJlc3VsdCBvZiBhbGlhcyByZXNvbHV0aW9uLiAqL1xuZXhwb3J0IGludGVyZmFjZSBBbGlhc1Jlc29sdXRpb24ge1xuICAvKiogVGhlIHJlc29sdmVkIG9yZ2FuaXphdGlvbiBJRCAoZS5nLiwgJ3N5c3RlbScpLiAqL1xuICByZXNvbHZlZE9yZ0lkOiBzdHJpbmc7XG4gIC8qKiBXaGV0aGVyIHRoZSBpbnB1dCB3YXMgYW4gYWxpYXMgdGhhdCBnb3QgcmVzb2x2ZWQuICovXG4gIHdhc0FsaWFzOiBib29sZWFuO1xuICAvKiogVGhlIG9yaWdpbmFsIGlucHV0IHZhbHVlLCB1c2VmdWwgZm9yIGF1ZGl0IGxvZ2dpbmcuICovXG4gIG9yaWdpbmFsVmFsdWU6IHN0cmluZztcbn1cblxuLyoqXG4gKiBSZXNvbHZlIGFuIGVtYWlsLWxpa2UgYWxpYXMgdG8gYW4gYWN0dWFsIG9yZ2FuaXphdGlvbiBJRC5cbiAqXG4gKiBJZiB0aGUgaW5wdXQgbWF0Y2hlcyBhIGNvbmZpZ3VyZWQgc3VwcG9ydCBhbGlhcywgaXQgcmVzb2x2ZXMgdG8gdGhlIHN5c3RlbVxuICogb3JnIElELiBPdGhlcndpc2UgdGhlIGlucHV0IGlzIHJldHVybmVkIGFzLWlzIChsb3dlcmNhc2VkKS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHJlc29sdmVSZWNpcGllbnRBbGlhcyhyZWNpcGllbnRPcmdJZDogc3RyaW5nKTogQWxpYXNSZXNvbHV0aW9uIHtcbiAgY29uc3Qgbm9ybWFsaXplZCA9IHJlY2lwaWVudE9yZ0lkLnRyaW0oKS50b0xvd2VyQ2FzZSgpO1xuICBjb25zdCBhbGlhc2VzID0gZ2V0U3VwcG9ydEFsaWFzZXMoKTtcblxuICBpZiAoYWxpYXNlcy5oYXMobm9ybWFsaXplZCkpIHtcbiAgICByZXR1cm4ge1xuICAgICAgcmVzb2x2ZWRPcmdJZDogU1lTVEVNX09SR19JRCxcbiAgICAgIHdhc0FsaWFzOiB0cnVlLFxuICAgICAgb3JpZ2luYWxWYWx1ZTogcmVjaXBpZW50T3JnSWQsXG4gICAgfTtcbiAgfVxuXG4gIHJldHVybiB7XG4gICAgcmVzb2x2ZWRPcmdJZDogbm9ybWFsaXplZCxcbiAgICB3YXNBbGlhczogZmFsc2UsXG4gICAgb3JpZ2luYWxWYWx1ZTogcmVjaXBpZW50T3JnSWQsXG4gIH07XG59XG5cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxpYXMtcmVzb2x2ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvYWxpYXMtcmVzb2x2ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQUV0QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFFdEQseUZBQXlGO0FBQ3pGLElBQUksZUFBd0MsQ0FBQztBQUU3QyxTQUFTLGlCQUFpQjtJQUN4QixJQUFJLENBQUMsZUFBZSxFQUFFLENBQUM7UUFDckIsTUFBTSxHQUFHLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQyxlQUFlLElBQUksRUFBRSxDQUFDO1FBQzlDLGVBQWUsR0FBRyxJQUFJLEdBQUcsQ0FDdkIsR0FBRzthQUNBLEtBQUssQ0FBQyxHQUFHLENBQUM7YUFDVixHQUFHLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLENBQUMsV0FBVyxFQUFFLENBQUM7YUFDeEMsTUFBTSxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUMsS0FBSyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FDckMsQ0FBQztJQUNKLENBQUM7SUFDRCxPQUFPLGVBQWUsQ0FBQztBQUN6QixDQUFDO0FBRUQ7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSx3QkFBd0I7SUFDdEMsZUFBZSxHQUFHLFNBQVMsQ0FBQztBQUM5QixDQUFDO0FBRUQsbUZBQW1GO0FBQ25GLE1BQU0sQ0FBQyxNQUFNLHFCQUFxQixHQUFHLDBCQUEwQixDQUFDO0FBRWhFOzs7OztHQUtHO0FBQ0gsTUFBTSxVQUFVLHNCQUFzQjtJQUNwQyxLQUFLLE1BQU0sS0FBSyxJQUFJLGlCQUFpQixFQUFFO1FBQUUsT0FBTyxLQUFLLENBQUM7SUFDdEQsT0FBTyxxQkFBcUIsQ0FBQztBQUMvQixDQUFDO0FBRUQ7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSxvQkFBb0I7SUFDbEMsTUFBTSxHQUFHLEdBQUcsQ0FBQyxHQUFHLGlCQUFpQixFQUFFLENBQUMsQ0FBQztJQUNyQyxPQUFPLEdBQUcsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMscUJBQXFCLENBQUMsQ0FBQztBQUN4RCxDQUFDO0FBWUQ7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQVUscUJBQXFCLENBQUMsY0FBc0I7SUFDMUQsTUFBTSxVQUFVLEdBQUcsY0FBYyxDQUFDLElBQUksRUFBRSxDQUFDLFdBQVcsRUFBRSxDQUFDO0lBQ3ZELE1BQU0sT0FBTyxHQUFHLGlCQUFpQixFQUFFLENBQUM7SUFFcEMsSUFBSSxPQUFPLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxFQUFFLENBQUM7UUFDNUIsT0FBTztZQUNMLGFBQWEsRUFBRSxhQUFhO1lBQzVCLFFBQVEsRUFBRSxJQUFJO1lBQ2QsYUFBYSxFQUFFLGNBQWM7U0FDOUIsQ0FBQztJQUNKLENBQUM7SUFFRCxPQUFPO1FBQ0wsYUFBYSxFQUFFLFVBQVU7UUFDekIsUUFBUSxFQUFFLEtBQUs7UUFDZixhQUFhLEVBQUUsY0FBYztLQUM5QixDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG5pbXBvcnQgeyBTWVNURU1fT1JHX0lEIH0gZnJvbSAnLi4vbWlkZGxld2FyZS9hdXRoLmpzJztcblxuLyoqIExhemlseS1jYWNoZWQgc2V0IG9mIHN1cHBvcnQgYWxpYXNlcywgcGFyc2VkIGZyb20gU1VQUE9SVF9BTElBU0VTIG9uIGZpcnN0IGFjY2Vzcy4gKi9cbmxldCBfc3VwcG9ydEFsaWFzZXM6IFNldDxzdHJpbmc+IHwgdW5kZWZpbmVkO1xuXG5mdW5jdGlvbiBnZXRTdXBwb3J0QWxpYXNlcygpOiBTZXQ8c3RyaW5nPiB7XG4gIGlmICghX3N1cHBvcnRBbGlhc2VzKSB7XG4gICAgY29uc3QgcmF3ID0gcHJvY2Vzcy5lbnYuU1VQUE9SVF9BTElBU0VTIHx8ICcnO1xuICAgIF9zdXBwb3J0QWxpYXNlcyA9IG5ldyBTZXQoXG4gICAgICByYXdcbiAgICAgICAgLnNwbGl0KCcsJylcbiAgICAgICAgLm1hcChhbGlhcyA9PiBhbGlhcy50cmltKCkudG9Mb3dlckNhc2UoKSlcbiAgICAgICAgLmZpbHRlcihhbGlhcyA9PiBhbGlhcy5sZW5ndGggPiAwKSxcbiAgICApO1xuICB9XG4gIHJldHVybiBfc3VwcG9ydEFsaWFzZXM7XG59XG5cbi8qKlxuICogQ2xlYXIgdGhlIG1lbW9pemVkIGFsaWFzIHNldCBzbyB0aGUgbmV4dCBhY2Nlc3MgcmUtcmVhZHMgYFNVUFBPUlRfQUxJQVNFU2AuXG4gKiBUaGUgY2FjaGUgaXMgcHJvY2Vzcy1saWZldGltZSBieSBkZXNpZ24gKGVudiBpcyBmaXhlZCBwZXIgcHJvY2Vzcyk7IHRoaXMgaG9va1xuICogZXhpc3RzIHNvIHRlc3RzIGNhbiB2YXJ5IHRoZSBlbnYgYmV0d2VlbiBjYXNlcy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHJlc2V0U3VwcG9ydEFsaWFzZXNDYWNoZSgpOiB2b2lkIHtcbiAgX3N1cHBvcnRBbGlhc2VzID0gdW5kZWZpbmVkO1xufVxuXG4vKiogV2VsbC1rbm93biBmYWxsYmFjayBzdXBwb3J0IGFsaWFzIHVzZWQgd2hlbiBTVVBQT1JUX0FMSUFTRVMgaXMgdW5jb25maWd1cmVkLiAqL1xuZXhwb3J0IGNvbnN0IERFRkFVTFRfU1VQUE9SVF9BTElBUyA9ICdzdXBwb3J0QHBpcGVsaW5lLWJ1aWxkZXInO1xuXG4vKipcbiAqIFRoZSBQUklNQVJZIChmaXJzdC1jb25maWd1cmVkKSBzdXBwb3J0IGFsaWFzIOKAlCBmb3IgZGlzcGxheSAvIHByZWZpbGwgaW4gVUlzXG4gKiAoZS5nLiB0aGUgY29tcG9zZSBcIlRvXCIgZmllbGQpLCBzbyB0aGUgc2hvd24gdmFsdWUgaXMgZHJpdmVuIGJ5IFNVUFBPUlRfQUxJQVNFU1xuICogcmF0aGVyIHRoYW4gaGFyZGNvZGVkLiBGYWxscyBiYWNrIHRvIHtAbGluayBERUZBVUxUX1NVUFBPUlRfQUxJQVN9IHdoZW4gdGhlIGVudlxuICogaXMgdW5zZXQuIChBbGwgY29uZmlndXJlZCBhbGlhc2VzIHN0aWxsIHJlc29sdmUgdmlhIHtAbGluayByZXNvbHZlUmVjaXBpZW50QWxpYXN9LilcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldFByaW1hcnlTdXBwb3J0QWxpYXMoKTogc3RyaW5nIHtcbiAgZm9yIChjb25zdCBhbGlhcyBvZiBnZXRTdXBwb3J0QWxpYXNlcygpKSByZXR1cm4gYWxpYXM7XG4gIHJldHVybiBERUZBVUxUX1NVUFBPUlRfQUxJQVM7XG59XG5cbi8qKlxuICogQUxMIGNvbmZpZ3VyZWQgc3VwcG9ydCBhbGlhc2VzIChvcmRlciBwcmVzZXJ2ZWQpLCBmb3IgVUlzIHRoYXQgc3VyZmFjZSBldmVyeVxuICogc3VwcG9ydCBpbmJveCBhcyBhIGRpc3RpbmN0IHJlY2lwaWVudCBzdWdnZXN0aW9uLiBGYWxscyBiYWNrIHRvIGEgc2luZ2xlXG4gKiB7QGxpbmsgREVGQVVMVF9TVVBQT1JUX0FMSUFTfSB3aGVuIFNVUFBPUlRfQUxJQVNFUyBpcyB1bnNldC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldEFsbFN1cHBvcnRBbGlhc2VzKCk6IHN0cmluZ1tdIHtcbiAgY29uc3QgYWxsID0gWy4uLmdldFN1cHBvcnRBbGlhc2VzKCldO1xuICByZXR1cm4gYWxsLmxlbmd0aCA+IDAgPyBhbGwgOiBbREVGQVVMVF9TVVBQT1JUX0FMSUFTXTtcbn1cblxuLyoqIFJlc3VsdCBvZiBhbGlhcyByZXNvbHV0aW9uLiAqL1xuZXhwb3J0IGludGVyZmFjZSBBbGlhc1Jlc29sdXRpb24ge1xuICAvKiogVGhlIHJlc29sdmVkIG9yZ2FuaXphdGlvbiBJRCAoZS5nLiwgJ3N5c3RlbScpLiAqL1xuICByZXNvbHZlZE9yZ0lkOiBzdHJpbmc7XG4gIC8qKiBXaGV0aGVyIHRoZSBpbnB1dCB3YXMgYW4gYWxpYXMgdGhhdCBnb3QgcmVzb2x2ZWQuICovXG4gIHdhc0FsaWFzOiBib29sZWFuO1xuICAvKiogVGhlIG9yaWdpbmFsIGlucHV0IHZhbHVlLCB1c2VmdWwgZm9yIGF1ZGl0IGxvZ2dpbmcuICovXG4gIG9yaWdpbmFsVmFsdWU6IHN0cmluZztcbn1cblxuLyoqXG4gKiBSZXNvbHZlIGFuIGVtYWlsLWxpa2UgYWxpYXMgdG8gYW4gYWN0dWFsIG9yZ2FuaXphdGlvbiBJRC5cbiAqXG4gKiBJZiB0aGUgaW5wdXQgbWF0Y2hlcyBhIGNvbmZpZ3VyZWQgc3VwcG9ydCBhbGlhcywgaXQgcmVzb2x2ZXMgdG8gdGhlIHN5c3RlbVxuICogb3JnIElELiBPdGhlcndpc2UgdGhlIGlucHV0IGlzIHJldHVybmVkIGFzLWlzIChsb3dlcmNhc2VkKS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHJlc29sdmVSZWNpcGllbnRBbGlhcyhyZWNpcGllbnRPcmdJZDogc3RyaW5nKTogQWxpYXNSZXNvbHV0aW9uIHtcbiAgY29uc3Qgbm9ybWFsaXplZCA9IHJlY2lwaWVudE9yZ0lkLnRyaW0oKS50b0xvd2VyQ2FzZSgpO1xuICBjb25zdCBhbGlhc2VzID0gZ2V0U3VwcG9ydEFsaWFzZXMoKTtcblxuICBpZiAoYWxpYXNlcy5oYXMobm9ybWFsaXplZCkpIHtcbiAgICByZXR1cm4ge1xuICAgICAgcmVzb2x2ZWRPcmdJZDogU1lTVEVNX09SR19JRCxcbiAgICAgIHdhc0FsaWFzOiB0cnVlLFxuICAgICAgb3JpZ2luYWxWYWx1ZTogcmVjaXBpZW50T3JnSWQsXG4gICAgfTtcbiAgfVxuXG4gIHJldHVybiB7XG4gICAgcmVzb2x2ZWRPcmdJZDogbm9ybWFsaXplZCxcbiAgICB3YXNBbGlhczogZmFsc2UsXG4gICAgb3JpZ2luYWxWYWx1ZTogcmVjaXBpZW50T3JnSWQsXG4gIH07XG59XG5cbiJdfQ==

package/lib/utils/compliance-attributes.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Project an entity into the compliance-event `attributes`, redacting secret
+ * VALUES while preserving everything the compliance engine actually evaluates.
+ * Recurses so nested secrets (deep inside a pipeline's `props`) are covered too.
+ */
+export declare function toComplianceAttributes(value: unknown): unknown;

package/lib/utils/compliance-attributes.js

@@ -0,0 +1,69 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Secret-redaction for compliance-event `attributes`.
+ *
+ * Shared by the plugin AND pipeline services (previously a byte-identical copy
+ * in each — a security-critical function that must not drift: a future "also
+ * redact `credentials`" fix has to protect BOTH services). Both feed entity
+ * attributes to the compliance engine over Redis, and neither may leak plaintext
+ * secrets there.
+ *
+ * The compliance rule engine reads secret maps (`env`/`buildArgs`, incl. nested
+ * `props.synth.env`, `props.stages[].steps[].env`, …) ONLY by KEY — `$keys(env)`,
+ * `$count(env)`, dot-path existence, key-`contains` — never by value (see
+ * api/compliance/src/engine/rule-operators.ts + its tests). So we preserve each
+ * secret map's shape + KEYS while overwriting every value with a marker; scalar
+ * secret fields (source `token`, passwords, …) are replaced outright. Structure
+ * and non-secret metadata pass through unchanged, so rule evaluation is
+ * identical while plaintext secrets never reach Redis or the compliance service.
+ */
+/** Marker written in place of a redacted secret VALUE. */
+const REDACTED = '[REDACTED]';
+/** Map keys whose (string→string) VALUES are secret build-time material. */
+const SECRET_MAP_KEYS = new Set(['env', 'buildArgs']);
+/**
+ * Scalar keys that themselves carry a secret string (tokens/passwords/etc.).
+ * Applied only to string values so boolean flags and declaration arrays (e.g.
+ * `secrets: PluginSecret[]`) are left intact.
+ */
+function isSecretScalarKey(key) {
+    const k = key.toLowerCase();
+    return k.includes('token') || k.includes('secret') || k.includes('password')
+        || k.includes('passphrase') || k.includes('credential') || k.includes('apikey')
+        || k.includes('accesskey') || k.includes('privatekey');
+}
+/** Only plain (Object-prototype) objects are traversed — Dates/class instances pass through intact. */
+function isPlainObject(v) {
+    if (v === null || typeof v !== 'object')
+        return false;
+    const proto = Object.getPrototypeOf(v);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * Project an entity into the compliance-event `attributes`, redacting secret
+ * VALUES while preserving everything the compliance engine actually evaluates.
+ * Recurses so nested secrets (deep inside a pipeline's `props`) are covered too.
+ */
+export function toComplianceAttributes(value) {
+    if (Array.isArray(value))
+        return value.map(toComplianceAttributes);
+    if (isPlainObject(value)) {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            if (SECRET_MAP_KEYS.has(k) && isPlainObject(v)) {
+                // Preserve keys (compliance reads $keys/$count/presence), redact values.
+                out[k] = Object.fromEntries(Object.keys(v).map((mk) => [mk, REDACTED]));
+            }
+            else if (isSecretScalarKey(k) && typeof v === 'string') {
+                out[k] = REDACTED;
+            }
+            else {
+                out[k] = toComplianceAttributes(v);
+            }
+        }
+        return out;
+    }
+    return value; // primitives, Date, null — untouched
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/env.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Typed environment-variable readers with consistent parsing + defaults.
+ *
+ * Services previously hand-rolled `parseInt(process.env.X || '…', 10)` /
+ * `process.env.X === 'true'` at hundreds of call sites — which drifts (the same
+ * var parsed with different defaults in different packages) and silently returns
+ * the default on a typo'd name. These helpers centralize the parsing so a value
+ * is read the same way everywhere, and make shared constants importable rather
+ * than re-derived (see `MAX_PAGE_LIMIT` / `DEFAULT_PAGE_LIMIT` in
+ * `validation/common-schemas.ts`).
+ */
+/**
+ * Parse an integer env var. Unset / blank / non-numeric → `def`. Optional
+ * `min`/`max` clamp the result (applied after the default).
+ */
+export declare function envInt(name: string, def: number, opts?: {
+    min?: number;
+    max?: number;
+}): number;
+/**
+ * Parse a boolean env var. `true`/`1`/`yes` → true, `false`/`0`/`no` → false
+ * (case-insensitive); unset / blank / unrecognized → `def`.
+ */
+export declare function envBool(name: string, def: boolean): boolean;
+/** Read an env var constrained to `allowed`; unset / not-in-set → `def`. */
+export declare function envEnum<T extends string>(name: string, allowed: readonly T[], def: T): T;
+/** Read a string env var; unset / blank → `def`. */
+export declare function envStr(name: string, def: string): string;

package/lib/utils/env.js

@@ -0,0 +1,54 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Typed environment-variable readers with consistent parsing + defaults.
+ *
+ * Services previously hand-rolled `parseInt(process.env.X || '…', 10)` /
+ * `process.env.X === 'true'` at hundreds of call sites — which drifts (the same
+ * var parsed with different defaults in different packages) and silently returns
+ * the default on a typo'd name. These helpers centralize the parsing so a value
+ * is read the same way everywhere, and make shared constants importable rather
+ * than re-derived (see `MAX_PAGE_LIMIT` / `DEFAULT_PAGE_LIMIT` in
+ * `validation/common-schemas.ts`).
+ */
+/**
+ * Parse an integer env var. Unset / blank / non-numeric → `def`. Optional
+ * `min`/`max` clamp the result (applied after the default).
+ */
+export function envInt(name, def, opts) {
+    const raw = process.env[name];
+    let n = raw === undefined || raw.trim() === '' ? def : Number.parseInt(raw, 10);
+    if (!Number.isFinite(n))
+        n = def;
+    if (opts?.min !== undefined)
+        n = Math.max(opts.min, n);
+    if (opts?.max !== undefined)
+        n = Math.min(opts.max, n);
+    return n;
+}
+/**
+ * Parse a boolean env var. `true`/`1`/`yes` → true, `false`/`0`/`no` → false
+ * (case-insensitive); unset / blank / unrecognized → `def`.
+ */
+export function envBool(name, def) {
+    const raw = process.env[name];
+    if (raw === undefined || raw.trim() === '')
+        return def;
+    const v = raw.trim().toLowerCase();
+    if (v === 'true' || v === '1' || v === 'yes')
+        return true;
+    if (v === 'false' || v === '0' || v === 'no')
+        return false;
+    return def;
+}
+/** Read an env var constrained to `allowed`; unset / not-in-set → `def`. */
+export function envEnum(name, allowed, def) {
+    const raw = process.env[name]?.trim();
+    return raw !== undefined && allowed.includes(raw) ? raw : def;
+}
+/** Read a string env var; unset / blank → `def`. */
+export function envStr(name, def) {
+    const raw = process.env[name];
+    return raw === undefined || raw.trim() === '' ? def : raw;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW52LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL2Vudi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDOzs7Ozs7Ozs7O0dBVUc7QUFFSDs7O0dBR0c7QUFDSCxNQUFNLFVBQVUsTUFBTSxDQUFDLElBQVksRUFBRSxHQUFXLEVBQUUsSUFBcUM7SUFDckYsTUFBTSxHQUFHLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUM5QixJQUFJLENBQUMsR0FBRyxHQUFHLEtBQUssU0FBUyxJQUFJLEdBQUcsQ0FBQyxJQUFJLEVBQUUsS0FBSyxFQUFFLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDLENBQUM7SUFDaEYsSUFBSSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDO1FBQUUsQ0FBQyxHQUFHLEdBQUcsQ0FBQztJQUNqQyxJQUFJLElBQUksRUFBRSxHQUFHLEtBQUssU0FBUztRQUFFLENBQUMsR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQyxDQUFDLENBQUM7SUFDdkQsSUFBSSxJQUFJLEVBQUUsR0FBRyxLQUFLLFNBQVM7UUFBRSxDQUFDLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ3ZELE9BQU8sQ0FBQyxDQUFDO0FBQ1gsQ0FBQztBQUVEOzs7R0FHRztBQUNILE1BQU0sVUFBVSxPQUFPLENBQUMsSUFBWSxFQUFFLEdBQVk7SUFDaEQsTUFBTSxHQUFHLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUM5QixJQUFJLEdBQUcsS0FBSyxTQUFTLElBQUksR0FBRyxDQUFDLElBQUksRUFBRSxLQUFLLEVBQUU7UUFBRSxPQUFPLEdBQUcsQ0FBQztJQUN2RCxNQUFNLENBQUMsR0FBRyxHQUFHLENBQUMsSUFBSSxFQUFFLENBQUMsV0FBVyxFQUFFLENBQUM7SUFDbkMsSUFBSSxDQUFDLEtBQUssTUFBTSxJQUFJLENBQUMsS0FBSyxHQUFHLElBQUksQ0FBQyxLQUFLLEtBQUs7UUFBRSxPQUFPLElBQUksQ0FBQztJQUMxRCxJQUFJLENBQUMsS0FBSyxPQUFPLElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDLEtBQUssSUFBSTtRQUFFLE9BQU8sS0FBSyxDQUFDO0lBQzNELE9BQU8sR0FBRyxDQUFDO0FBQ2IsQ0FBQztBQUVELDRFQUE0RTtBQUM1RSxNQUFNLFVBQVUsT0FBTyxDQUFtQixJQUFZLEVBQUUsT0FBcUIsRUFBRSxHQUFNO0lBQ25GLE1BQU0sR0FBRyxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsSUFBSSxFQUFtQixDQUFDO0lBQ3ZELE9BQU8sR0FBRyxLQUFLLFNBQVMsSUFBSSxPQUFPLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQztBQUNoRSxDQUFDO0FBRUQsb0RBQW9EO0FBQ3BELE1BQU0sVUFBVSxNQUFNLENBQUMsSUFBWSxFQUFFLEdBQVc7SUFDOUMsTUFBTSxHQUFHLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUM5QixPQUFPLEdBQUcsS0FBSyxTQUFTLElBQUksR0FBRyxDQUFDLElBQUksRUFBRSxLQUFLLEVBQUUsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUM7QUFDNUQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG4vKipcbiAqIFR5cGVkIGVudmlyb25tZW50LXZhcmlhYmxlIHJlYWRlcnMgd2l0aCBjb25zaXN0ZW50IHBhcnNpbmcgKyBkZWZhdWx0cy5cbiAqXG4gKiBTZXJ2aWNlcyBwcmV2aW91c2x5IGhhbmQtcm9sbGVkIGBwYXJzZUludChwcm9jZXNzLmVudi5YIHx8ICfigKYnLCAxMClgIC9cbiAqIGBwcm9jZXNzLmVudi5YID09PSAndHJ1ZSdgIGF0IGh1bmRyZWRzIG9mIGNhbGwgc2l0ZXMg4oCUIHdoaWNoIGRyaWZ0cyAodGhlIHNhbWVcbiAqIHZhciBwYXJzZWQgd2l0aCBkaWZmZXJlbnQgZGVmYXVsdHMgaW4gZGlmZmVyZW50IHBhY2thZ2VzKSBhbmQgc2lsZW50bHkgcmV0dXJuc1xuICogdGhlIGRlZmF1bHQgb24gYSB0eXBvJ2QgbmFtZS4gVGhlc2UgaGVscGVycyBjZW50cmFsaXplIHRoZSBwYXJzaW5nIHNvIGEgdmFsdWVcbiAqIGlzIHJlYWQgdGhlIHNhbWUgd2F5IGV2ZXJ5d2hlcmUsIGFuZCBtYWtlIHNoYXJlZCBjb25zdGFudHMgaW1wb3J0YWJsZSByYXRoZXJcbiAqIHRoYW4gcmUtZGVyaXZlZCAoc2VlIGBNQVhfUEFHRV9MSU1JVGAgLyBgREVGQVVMVF9QQUdFX0xJTUlUYCBpblxuICogYHZhbGlkYXRpb24vY29tbW9uLXNjaGVtYXMudHNgKS5cbiAqL1xuXG4vKipcbiAqIFBhcnNlIGFuIGludGVnZXIgZW52IHZhci4gVW5zZXQgLyBibGFuayAvIG5vbi1udW1lcmljIOKGkiBgZGVmYC4gT3B0aW9uYWxcbiAqIGBtaW5gL2BtYXhgIGNsYW1wIHRoZSByZXN1bHQgKGFwcGxpZWQgYWZ0ZXIgdGhlIGRlZmF1bHQpLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZW52SW50KG5hbWU6IHN0cmluZywgZGVmOiBudW1iZXIsIG9wdHM/OiB7IG1pbj86IG51bWJlcjsgbWF4PzogbnVtYmVyIH0pOiBudW1iZXIge1xuICBjb25zdCByYXcgPSBwcm9jZXNzLmVudltuYW1lXTtcbiAgbGV0IG4gPSByYXcgPT09IHVuZGVmaW5lZCB8fCByYXcudHJpbSgpID09PSAnJyA/IGRlZiA6IE51bWJlci5wYXJzZUludChyYXcsIDEwKTtcbiAgaWYgKCFOdW1iZXIuaXNGaW5pdGUobikpIG4gPSBkZWY7XG4gIGlmIChvcHRzPy5taW4gIT09IHVuZGVmaW5lZCkgbiA9IE1hdGgubWF4KG9wdHMubWluLCBuKTtcbiAgaWYgKG9wdHM/Lm1heCAhPT0gdW5kZWZpbmVkKSBuID0gTWF0aC5taW4ob3B0cy5tYXgsIG4pO1xuICByZXR1cm4gbjtcbn1cblxuLyoqXG4gKiBQYXJzZSBhIGJvb2xlYW4gZW52IHZhci4gYHRydWVgL2AxYC9geWVzYCDihpIgdHJ1ZSwgYGZhbHNlYC9gMGAvYG5vYCDihpIgZmFsc2VcbiAqIChjYXNlLWluc2Vuc2l0aXZlKTsgdW5zZXQgLyBibGFuayAvIHVucmVjb2duaXplZCDihpIgYGRlZmAuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBlbnZCb29sKG5hbWU6IHN0cmluZywgZGVmOiBib29sZWFuKTogYm9vbGVhbiB7XG4gIGNvbnN0IHJhdyA9IHByb2Nlc3MuZW52W25hbWVdO1xuICBpZiAocmF3ID09PSB1bmRlZmluZWQgfHwgcmF3LnRyaW0oKSA9PT0gJycpIHJldHVybiBkZWY7XG4gIGNvbnN0IHYgPSByYXcudHJpbSgpLnRvTG93ZXJDYXNlKCk7XG4gIGlmICh2ID09PSAndHJ1ZScgfHwgdiA9PT0gJzEnIHx8IHYgPT09ICd5ZXMnKSByZXR1cm4gdHJ1ZTtcbiAgaWYgKHYgPT09ICdmYWxzZScgfHwgdiA9PT0gJzAnIHx8IHYgPT09ICdubycpIHJldHVybiBmYWxzZTtcbiAgcmV0dXJuIGRlZjtcbn1cblxuLyoqIFJlYWQgYW4gZW52IHZhciBjb25zdHJhaW5lZCB0byBgYWxsb3dlZGA7IHVuc2V0IC8gbm90LWluLXNldCDihpIgYGRlZmAuICovXG5leHBvcnQgZnVuY3Rpb24gZW52RW51bTxUIGV4dGVuZHMgc3RyaW5nPihuYW1lOiBzdHJpbmcsIGFsbG93ZWQ6IHJlYWRvbmx5IFRbXSwgZGVmOiBUKTogVCB7XG4gIGNvbnN0IHJhdyA9IHByb2Nlc3MuZW52W25hbWVdPy50cmltKCkgYXMgVCB8IHVuZGVmaW5lZDtcbiAgcmV0dXJuIHJhdyAhPT0gdW5kZWZpbmVkICYmIGFsbG93ZWQuaW5jbHVkZXMocmF3KSA/IHJhdyA6IGRlZjtcbn1cblxuLyoqIFJlYWQgYSBzdHJpbmcgZW52IHZhcjsgdW5zZXQgLyBibGFuayDihpIgYGRlZmAuICovXG5leHBvcnQgZnVuY3Rpb24gZW52U3RyKG5hbWU6IHN0cmluZywgZGVmOiBzdHJpbmcpOiBzdHJpbmcge1xuICBjb25zdCByYXcgPSBwcm9jZXNzLmVudltuYW1lXTtcbiAgcmV0dXJuIHJhdyA9PT0gdW5kZWZpbmVkIHx8IHJhdy50cmltKCkgPT09ICcnID8gZGVmIDogcmF3O1xufVxuIl19

package/lib/utils/index.d.ts

@@ -13,3 +13,5 @@ export * from './secret-encryption.js';
 export * from './metric-emitter.js';
 export * from './aws-scrub.js';
 export * from './ssrf.js';
+export * from './env.js';
+export * from './compliance-attributes.js';

package/lib/utils/index.js

@@ -15,4 +15,6 @@ export * from './secret-encryption.js';
 export * from './metric-emitter.js';
 export * from './aws-scrub.js';
 export * from './ssrf.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQUV0QyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsV0FBVyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMjYgUGlwZWxpbmUgQnVpbGRlciBDb250cmlidXRvcnNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5cbmV4cG9ydCAqIGZyb20gJy4vbG9nZ2VyLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vc2FmZS1yZXF1aXJlLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vY3Jhc2gtaGFuZGxlcnMuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9yZXNwb25zZS5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3BhcmFtcy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2hlYWRlcnMuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9pZGVudGl0eS5qcyc7XG5leHBvcnQgKiBmcm9tICcuL29iamVjdC5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2FsaWFzLXJlc29sdmVyLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vY29uY3VycmVuY3kuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9hdWRpdC5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3NlY3JldC1lbmNyeXB0aW9uLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vbWV0cmljLWVtaXR0ZXIuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9hd3Mtc2NydWIuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9zc3JmLmpzJztcbiJdfQ==
+export * from './env.js';
+export * from './compliance-attributes.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQUV0QyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsNEJBQTRCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuZXhwb3J0ICogZnJvbSAnLi9sb2dnZXIuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9zYWZlLXJlcXVpcmUuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9jcmFzaC1oYW5kbGVycy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3Jlc3BvbnNlLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vcGFyYW1zLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vaGVhZGVycy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2lkZW50aXR5LmpzJztcbmV4cG9ydCAqIGZyb20gJy4vb2JqZWN0LmpzJztcbmV4cG9ydCAqIGZyb20gJy4vYWxpYXMtcmVzb2x2ZXIuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9jb25jdXJyZW5jeS5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2F1ZGl0LmpzJztcbmV4cG9ydCAqIGZyb20gJy4vc2VjcmV0LWVuY3J5cHRpb24uanMnO1xuZXhwb3J0ICogZnJvbSAnLi9tZXRyaWMtZW1pdHRlci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2F3cy1zY3J1Yi5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3NzcmYuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9lbnYuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9jb21wbGlhbmNlLWF0dHJpYnV0ZXMuanMnO1xuIl19

package/lib/utils/secret-encryption.d.ts

@@ -36,35 +36,6 @@ export declare class EnvKeyProvider implements KeyProvider {
     constructor(masterKeyOverride?: string);
     deriveKey(orgId: string): Buffer;
 }
-/**
- *  AWS-KMS-backed KeyProvider.
- *
- * Trade-off picked: store ONE master key encrypted under a KMS CMK; on
- * first use, call `kms:Decrypt` to recover the master key bytes; HKDF-
- * derive per-org from it (same as EnvKeyProvider). The process then holds
- * the plaintext master key in memory until restart.
- *
- * PROS: one KMS call per process lifetime (cheap, low p99 impact),
- * the encrypted-master-key blob is safe to commit/log/checkin,
- * KMS audit log records when the master is recovered.
- * CONS: process memory still holds the master key  same posture as
- * EnvKeyProvider once warmed up. For stronger isolation an
- * operator can move to per-record envelope encryption (call
- * GenerateDataKey on every write); that's a follow-on.
- *
- * Operator setup * 1. Create a KMS CMK with key policy allowing the platform service's
- * IAM role kms:Decrypt.
- * 2. Generate a random 32-byte master * head -c 32 /dev/urandom | base64
- * 3. Wrap it with KMS * aws kms encrypt --key-id <KEY_ID> \
- * --plaintext <base64-from-step-2> --output text \
- * --query CiphertextBlob
- * 4. Set on the service * SECRET_ENCRYPTION_KMS_KEY_ID=<KEY_ID>
- * SECRET_ENCRYPTION_KMS_CIPHERTEXT=<base64-output-of-step-3>
- * 5. Pick this provider via `setKeyProvider(new KmsKeyProvider())`.
- *
- * Construct lazily  importing the AWS SDK has a non-trivial cold-start
- * cost so envs that stay on EnvKeyProvider never load it.
- */
 export declare class KmsKeyProvider implements KeyProvider {
     private masterKeyCache;
     private readonly keyId;