@pipeline-builder/api-core 3.4.82 → 3.4.84

package/lib/middleware/mongo-sanitize.js

@@ -1,5 +1,22 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
+import { HttpStatus } from '../constants/http-status.js';
+import { ErrorCode } from '../types/error-codes.js';
+import { sendError } from '../utils/response.js';
+/** Maximum nesting depth accepted by {@link mongoSanitize}. */
+export const MAX_SANITIZE_DEPTH = 10;
+/**
+ * Thrown when a request payload nests deeper than {@link MAX_SANITIZE_DEPTH}.
+ * The middleware maps this to HTTP 400 instead of silently truncating the walk
+ * (which would let operator-shaped keys below the cap slip through unsanitized).
+ */
+export class PayloadTooDeepError extends Error {
+    statusCode = HttpStatus.BAD_REQUEST;
+    constructor(message = `Request payload nesting exceeds the maximum depth of ${MAX_SANITIZE_DEPTH}`) {
+        super(message);
+        this.name = 'PayloadTooDeepError';
+    }
+}
 /**
  * MongoDB operator-injection middleware.
  *
@@ -13,18 +30,40 @@
  * Apply BEFORE any Mongo query handler (typically right after
  * `express.json()`). Postgres-backed services don't need it.
  *
- * Modifies in place. On Express 5+ where `req.query` is a read-only getter,
- * this still works because we mutate the underlying object's keys, not the
- * reference.
+ * `req.body` and `req.params` are plain writable objects, so they're sanitized
+ * in place. On Express 5 `req.query` is a GETTER that re-parses the URL and
+ * returns a fresh object on every access — mutating it is a no-op — so we
+ * sanitize a snapshot and pin it onto the request instance with
+ * `Object.defineProperty`, shadowing the getter for all downstream reads.
  */
 export function mongoSanitize() {
-    return (req, _res, next) => {
-        if (req.body && typeof req.body === 'object')
-            sanitizeObject(req.body);
-        if (req.query && typeof req.query === 'object')
-            sanitizeObject(req.query);
-        if (req.params && typeof req.params === 'object')
-            sanitizeObject(req.params);
+    return (req, res, next) => {
+        try {
+            if (req.body && typeof req.body === 'object')
+                sanitizeObject(req.body);
+            if (req.params && typeof req.params === 'object')
+                sanitizeObject(req.params);
+            if (req.query && typeof req.query === 'object') {
+                const q = req.query;
+                sanitizeObject(q);
+                // Pin the sanitized snapshot so the Express 5 getter can't re-parse a
+                // fresh (unsanitized) object on the next access.
+                try {
+                    Object.defineProperty(req, 'query', { value: q, writable: true, configurable: true, enumerable: true });
+                }
+                catch {
+                    // Express 4 (writable data prop) — the in-place sanitize above sufficed.
+                }
+            }
+        }
+        catch (err) {
+            // Reject over-deep payloads with a 400 rather than silently truncating
+            // the sanitize walk (which risked leaving deep operator keys in place).
+            if (err instanceof PayloadTooDeepError) {
+                return sendError(res, err.statusCode, err.message, ErrorCode.VALIDATION_ERROR);
+            }
+            throw err;
+        }
         next();
     };
 }
@@ -33,9 +72,12 @@ export function mongoSanitize() {
 // `constructor.prototype` to inject Mongo operators or pollute Object.prototype.
 const FORBIDDEN_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
 function sanitizeObject(obj, depth = 0) {
-    // Cap depth — defense against pathological nested input.
-    if (depth > 10)
-        return;
+    // Reject pathologically nested input rather than silently returning — a
+    // silent cap would leave any operator/dot/prototype keys deeper than the
+    // cap un-sanitized. The middleware maps this to a 400.
+    if (depth > MAX_SANITIZE_DEPTH) {
+        throw new PayloadTooDeepError();
+    }
     for (const key of Object.keys(obj)) {
         if (key.startsWith('$') || key.includes('.') || FORBIDDEN_KEYS.has(key)) {
             delete obj[key];
@@ -55,4 +97,4 @@ function sanitizeObject(obj, depth = 0) {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mongo-sanitize.js","sourceRoot":"","sources":["../../src/middleware/mongo-sanitize.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { NextFunction, Request, Response } from 'express';\nimport { HttpStatus } from '../constants/http-status.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { sendError } from '../utils/response.js';\n\n/** Maximum nesting depth accepted by {@link mongoSanitize}. */\nexport const MAX_SANITIZE_DEPTH = 10;\n\n/**\n * Thrown when a request payload nests deeper than {@link MAX_SANITIZE_DEPTH}.\n * The middleware maps this to HTTP 400 instead of silently truncating the walk\n * (which would let operator-shaped keys below the cap slip through unsanitized).\n */\nexport class PayloadTooDeepError extends Error {\n  readonly statusCode = HttpStatus.BAD_REQUEST;\n  constructor(message = `Request payload nesting exceeds the maximum depth of ${MAX_SANITIZE_DEPTH}`) {\n    super(message);\n    this.name = 'PayloadTooDeepError';\n  }\n}\n\n/**\n * MongoDB operator-injection middleware.\n *\n * Recursively strips object keys starting with `$` (Mongo operators like\n * `$ne`, `$gt`, `$where`) and keys containing `.` (dot-walks) from\n * `req.body`, `req.query`, and `req.params`. Without this, a JSON request\n * like `{\"email\": {\"$ne\": null}}` against a Mongo-backed service can match\n * any document — Zod catches the wrong *type* but won't reach into nested\n * objects to strip operator-shaped keys.\n *\n * Apply BEFORE any Mongo query handler (typically right after\n * `express.json()`). Postgres-backed services don't need it.\n *\n * `req.body` and `req.params` are plain writable objects, so they're sanitized\n * in place. On Express 5 `req.query` is a GETTER that re-parses the URL and\n * returns a fresh object on every access — mutating it is a no-op — so we\n * sanitize a snapshot and pin it onto the request instance with\n * `Object.defineProperty`, shadowing the getter for all downstream reads.\n */\nexport function mongoSanitize() {\n  return (req: Request, res: Response, next: NextFunction) => {\n    try {\n      if (req.body && typeof req.body === 'object') sanitizeObject(req.body);\n      if (req.params && typeof req.params === 'object') sanitizeObject(req.params as Record<string, unknown>);\n      if (req.query && typeof req.query === 'object') {\n        const q = req.query as Record<string, unknown>;\n        sanitizeObject(q);\n        // Pin the sanitized snapshot so the Express 5 getter can't re-parse a\n        // fresh (unsanitized) object on the next access.\n        try {\n          Object.defineProperty(req, 'query', { value: q, writable: true, configurable: true, enumerable: true });\n        } catch {\n          // Express 4 (writable data prop) — the in-place sanitize above sufficed.\n        }\n      }\n    } catch (err) {\n      // Reject over-deep payloads with a 400 rather than silently truncating\n      // the sanitize walk (which risked leaving deep operator keys in place).\n      if (err instanceof PayloadTooDeepError) {\n        return sendError(res, err.statusCode, err.message, ErrorCode.VALIDATION_ERROR);\n      }\n      throw err;\n    }\n    next();\n  };\n}\n\n// Prototype-pollution keys — these never belong in JSON request bodies, and a\n// downstream recursive merge/assign on the parsed object could otherwise walk\n// `constructor.prototype` to inject Mongo operators or pollute Object.prototype.\nconst FORBIDDEN_KEYS = new Set(['__proto__', 'constructor', 'prototype']);\n\nfunction sanitizeObject(obj: Record<string, unknown>, depth = 0): void {\n  // Reject pathologically nested input rather than silently returning — a\n  // silent cap would leave any operator/dot/prototype keys deeper than the\n  // cap un-sanitized. The middleware maps this to a 400.\n  if (depth > MAX_SANITIZE_DEPTH) {\n    throw new PayloadTooDeepError();\n  }\n  for (const key of Object.keys(obj)) {\n    if (key.startsWith('$') || key.includes('.') || FORBIDDEN_KEYS.has(key)) {\n      delete obj[key];\n      continue;\n    }\n    const v = obj[key];\n    if (v && typeof v === 'object') {\n      if (Array.isArray(v)) {\n        for (const item of v) {\n          if (item && typeof item === 'object') sanitizeObject(item as Record<string, unknown>, depth + 1);\n        }\n      } else {\n        sanitizeObject(v as Record<string, unknown>, depth + 1);\n      }\n    }\n  }\n}\n"]}

package/lib/services/cache-service.js

@@ -135,8 +135,11 @@ export class CacheService {
                 }
                 return keys.length;
             }
-            // In-memory — match glob-style pattern
-            const regex = new RegExp('^' + fp.replace(/\*/g, '.*') + '$');
+            // In-memory — match glob-style pattern. Escape regex metacharacters first
+            // so a literal `.`/`(`/`[` in a key prefix (e.g. `org:v1.2:*`) can't
+            // over-match or throw (a throw here is swallowed → nothing invalidated →
+            // stale reads); only `*` is treated as a wildcard.
+            const regex = new RegExp('^' + fp.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\\\*/g, '.*') + '$');
             let deleted = 0;
             for (const key of this.memory.keys()) {
                 if (regex.test(key)) {
@@ -204,4 +207,4 @@ export class CacheService {
 export function createCacheService(prefix, defaultTtlSeconds = 300, redis) {
     return new CacheService({ prefix, defaultTtlSeconds, redis });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache-service.js","sourceRoot":"","sources":["../../src/services/cache-service.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Lightweight caching service with TTL support.\n *\n * Two implementations:\n * - In-memory (default): LRU-style Map cache, no external dependencies\n * - Redis: When a Redis client is provided, uses Redis for cross-process caching\n *\n * Design:\n * - All operations are fail-safe: cache misses/errors return null, never throw\n * - JSON serialization for Redis; direct reference for in-memory\n * - Key namespace prefixing to avoid collisions between services\n */\n\n\n/**\n * Cache entry with value and expiration time.\n */\ninterface CacheEntry<T> {\n  value: T;\n  expiresAt: number; // Unix timestamp in ms\n}\n\n/**\n * Minimal Redis-like client interface (subset of ioredis).\n * Services pass their own Redis client instance.\n */\nexport interface RedisCacheClient {\n  get(key: string): Promise<string | null>;\n  set(key: string, value: string, ...args: unknown[]): Promise<unknown>;\n  del(...keys: string[]): Promise<number>;\n  keys(pattern: string): Promise<string[]>;\n  /** SCAN-based iteration (preferred over KEYS for production). */\n  scanStream?(options: { match: string; count?: number }): NodeJS.ReadableStream;\n}\n\nexport interface CacheConfig {\n  /** Key prefix for namespace isolation (e.g., 'plugin:', 'compliance:') */\n  prefix: string;\n  /** Default TTL in seconds */\n  defaultTtlSeconds: number;\n  /** Max entries for in-memory cache (default 1000) */\n  maxEntries?: number;\n  /** Optional Redis client — uses in-memory cache if not provided */\n  redis?: RedisCacheClient;\n}\n\n/**\n * Cache service with get/set/del operations and automatic TTL expiry.\n *\n * @example\n * ```typescript\n * const cache = new CacheService({ prefix: 'plugin:', defaultTtlSeconds: 300 });\n *\n * // Set with default TTL\n * await cache.set('org123:list', plugins);\n *\n * // Get (returns null on miss)\n * const cached = await cache.get<Plugin[]>('org123:list');\n *\n * // Invalidate\n * await cache.del('org123:list');\n *\n * // Invalidate by pattern\n * await cache.invalidatePattern('org123:*');\n * ```\n */\nexport class CacheService {\n  private memory = new Map<string, CacheEntry<unknown>>();\n  private readonly prefix: string;\n  private readonly defaultTtlMs: number;\n  private readonly maxEntries: number;\n  private readonly redis?: RedisCacheClient;\n\n  /** Cache metrics — tracks hits, misses, and invalidations. */\n  readonly metrics = { hits: 0, misses: 0, sets: 0, invalidations: 0 };\n\n  constructor(config: CacheConfig) {\n    this.prefix = config.prefix;\n    this.defaultTtlMs = config.defaultTtlSeconds * 1000;\n    this.maxEntries = config.maxEntries ?? 1000;\n    this.redis = config.redis;\n  }\n\n  private fullKey(key: string): string {\n    return `${this.prefix}${key}`;\n  }\n\n  /**\n   * Get a cached value. Returns null on miss or error.\n   */\n  async get<T>(key: string): Promise<T | null> {\n    const fk = this.fullKey(key);\n\n    try {\n      if (this.redis) {\n        const raw = await this.redis.get(fk);\n        if (!raw) { this.metrics.misses++; return null; }\n        this.metrics.hits++;\n        return JSON.parse(raw) as T;\n      }\n\n      // In-memory\n      const entry = this.memory.get(fk);\n      if (!entry) { this.metrics.misses++; return null; }\n      if (Date.now() > entry.expiresAt) {\n        this.memory.delete(fk);\n        this.metrics.misses++;\n        return null;\n      }\n      this.metrics.hits++;\n      return entry.value as T;\n    } catch {\n      this.metrics.misses++;\n      return null;\n    }\n  }\n\n  /**\n   * Set a cached value with optional TTL override.\n   *\n   * @param key - Cache key (prefix is added automatically)\n   * @param value - Value to cache (must be JSON-serializable for Redis)\n   * @param ttlSeconds - TTL override (uses default if not provided)\n   */\n  async set<T>(key: string, value: T, ttlSeconds?: number): Promise<void> {\n    const fk = this.fullKey(key);\n    const ttl = ttlSeconds ?? this.defaultTtlMs / 1000;\n\n    try {\n      this.metrics.sets++;\n      if (this.redis) {\n        await this.redis.set(fk, JSON.stringify(value), 'EX', ttl);\n        return;\n      }\n\n      // In-memory — evict oldest if at capacity\n      if (this.memory.size >= this.maxEntries) {\n        const firstKey = this.memory.keys().next().value;\n        if (firstKey) this.memory.delete(firstKey);\n      }\n\n      this.memory.set(fk, {\n        value,\n        expiresAt: Date.now() + ttl * 1000,\n      });\n    } catch {\n      // Cache set failure is non-fatal\n    }\n  }\n\n  /**\n   * Delete a cached value.\n   */\n  async del(key: string): Promise<void> {\n    const fk = this.fullKey(key);\n\n    try {\n      if (this.redis) {\n        await this.redis.del(fk);\n        return;\n      }\n      this.memory.delete(fk);\n    } catch {\n      // Cache delete failure is non-fatal\n    }\n  }\n\n  /**\n   * Invalidate all keys matching a pattern (e.g., 'org123:*').\n   * Uses SCAN for Redis (non-blocking) with KEYS fallback, or regex for in-memory.\n   */\n  async invalidatePattern(pattern: string): Promise<number> {\n    const fp = this.fullKey(pattern);\n\n    try {\n      if (this.redis) {\n        const keys = this.redis.scanStream\n          ? await this.scanKeys(fp)\n          : await this.redis.keys(fp);\n        if (keys.length > 0) {\n          await this.redis.del(...keys);\n          this.metrics.invalidations += keys.length;\n        }\n        return keys.length;\n      }\n\n      // In-memory — match glob-style pattern\n      const regex = new RegExp('^' + fp.replace(/\\*/g, '.*') + '$');\n      let deleted = 0;\n      for (const key of this.memory.keys()) {\n        if (regex.test(key)) {\n          this.memory.delete(key);\n          deleted++;\n        }\n      }\n      this.metrics.invalidations += deleted;\n      return deleted;\n    } catch {\n      return 0;\n    }\n  }\n\n  /** Collect keys via Redis SCAN (non-blocking alternative to KEYS). */\n  private scanKeys(pattern: string): Promise<string[]> {\n    return new Promise((resolve, reject) => {\n      const stream = this.redis!.scanStream!({ match: pattern, count: 100 });\n      const keys: string[] = [];\n      stream.on('data', (batch: string[]) => keys.push(...batch));\n      stream.once('end', () => resolve(keys));\n      stream.once('error', reject);\n    });\n  }\n\n  /**\n   * Get or compute: returns cached value if available, otherwise calls the\n   * factory function, caches the result, and returns it.\n   *\n   * @param key - Cache key\n   * @param factory - Async function to compute the value on cache miss\n   * @param ttlSeconds - Optional TTL override\n   * @returns The cached or computed value\n   */\n  async getOrSet<T>(key: string, factory: () => Promise<T>, ttlSeconds?: number): Promise<T> {\n    const cached = await this.get<T>(key);\n    if (cached !== null) return cached;\n\n    const value = await factory();\n    await this.set(key, value, ttlSeconds);\n    return value;\n  }\n\n  /**\n   * Clear all entries (useful for testing).\n   */\n  async clear(): Promise<void> {\n    if (this.redis) {\n      await this.invalidatePattern('*');\n    } else {\n      this.memory.clear();\n    }\n  }\n\n  /** Current in-memory cache size (for diagnostics). */\n  get size(): number {\n    return this.memory.size;\n  }\n}\n\n/**\n * Create a cache service instance.\n *\n * @param prefix - Namespace prefix (e.g., 'compliance:', 'plugin:')\n * @param defaultTtlSeconds - Default TTL in seconds (default 300 = 5 min)\n * @param redis - Optional Redis client for cross-process caching\n */\nexport function createCacheService(\n  prefix: string,\n  defaultTtlSeconds = 300,\n  redis?: RedisCacheClient,\n): CacheService {\n  return new CacheService({ prefix, defaultTtlSeconds, redis });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache-service.js","sourceRoot":"","sources":["../../src/services/cache-service.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAgDtC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,OAAO,YAAY;IACf,MAAM,GAAG,IAAI,GAAG,EAA+B,CAAC;IACvC,MAAM,CAAS;IACf,YAAY,CAAS;IACrB,UAAU,CAAS;IACnB,KAAK,CAAoB;IAE1C,8DAA8D;IACrD,OAAO,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,CAAC;IAErE,YAAY,MAAmB;QAC7B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,iBAAiB,GAAG,IAAI,CAAC;QACpD,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,IAAI,IAAI,CAAC;QAC5C,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;IAC5B,CAAC;IAEO,OAAO,CAAC,GAAW;QACzB,OAAO,GAAG,IAAI,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC;IAChC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,GAAG,CAAI,GAAW;QACtB,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAE7B,IAAI,CAAC;YACH,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;gBACf,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBACrC,IAAI,CAAC,GAAG,EAAE,CAAC;oBAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;oBAAC,OAAO,IAAI,CAAC;gBAAC,CAAC;gBACjD,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;gBACpB,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAM,CAAC;YAC9B,CAAC;YAED,YAAY;YACZ,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAClC,IAAI,CAAC,KAAK,EAAE,CAAC;gBAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;gBAAC,OAAO,IAAI,CAAC;YAAC,CAAC;YACnD,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,SAAS,EAAE,CAAC;gBACjC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;gBACvB,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;gBACtB,OAAO,IAAI,CAAC;YACd,CAAC;YACD,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;YACpB,OAAO,KAAK,CAAC,KAAU,CAAC;QAC1B,CAAC;QAAC,MAAM,CAAC;YACP,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;YACtB,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,GAAG,CAAI,GAAW,EAAE,KAAQ,EAAE,UAAmB;QACrD,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAC7B,MAAM,GAAG,GAAG,UAAU,IAAI,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QAEnD,IAAI,CAAC;YACH,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;YACpB,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;gBACf,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC;gBAC3D,OAAO;YACT,CAAC;YAED,0CAA0C;YAC1C,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;gBACxC,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC;gBACjD,IAAI,QAAQ;oBAAE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YAC7C,CAAC;YAED,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE;gBAClB,KAAK;gBACL,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI;aACnC,CAAC,CAAC;QACL,CAAC;QAAC,MAAM,CAAC;YACP,iCAAiC;QACnC,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,GAAG,CAAC,GAAW;QACnB,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAE7B,IAAI,CAAC;YACH,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;gBACf,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBACzB,OAAO;YACT,CAAC;YACD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QACzB,CAAC;QAAC,MAAM,CAAC;YACP,oCAAoC;QACtC,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,iBAAiB,CAAC,OAAe;QACrC,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAEjC,IAAI,CAAC;YACH,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;gBACf,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU;oBAChC,CAAC,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;oBACzB,CAAC,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;gBAC9B,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACpB,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC;oBAC9B,IAAI,CAAC,OAAO,CAAC,aAAa,IAAI,IAAI,CAAC,MAAM,CAAC;gBAC5C,CAAC;gBACD,OAAO,IAAI,CAAC,MAAM,CAAC;YACrB,CAAC;YAED,0EAA0E;YAC1E,qEAAqE;YACrE,yEAAyE;YACzE,mDAAmD;YACnD,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,GAAG,GAAG,EAAE,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC;YACvG,IAAI,OAAO,GAAG,CAAC,CAAC;YAChB,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC;gBACrC,IAAI,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;oBACpB,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;oBACxB,OAAO,EAAE,CAAC;gBACZ,CAAC;YACH,CAAC;YACD,IAAI,CAAC,OAAO,CAAC,aAAa,IAAI,OAAO,CAAC;YACtC,OAAO,OAAO,CAAC;QACjB,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,CAAC,CAAC;QACX,CAAC;IACH,CAAC;IAED,sEAAsE;IAC9D,QAAQ,CAAC,OAAe;QAC9B,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAM,CAAC,UAAW,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;YACvE,MAAM,IAAI,GAAa,EAAE,CAAC;YAC1B,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAe,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;YAC5D,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;YACxC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QAC/B,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,QAAQ,CAAI,GAAW,EAAE,OAAyB,EAAE,UAAmB;QAC3E,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,CAAI,GAAG,CAAC,CAAC;QACtC,IAAI,MAAM,KAAK,IAAI;YAAE,OAAO,MAAM,CAAC;QAEnC,MAAM,KAAK,GAAG,MAAM,OAAO,EAAE,CAAC;QAC9B,MAAM,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC;QACvC,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,KAAK;QACT,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;QACpC,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QACtB,CAAC;IACH,CAAC;IAED,sDAAsD;IACtD,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;IAC1B,CAAC;CACF;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAChC,MAAc,EACd,iBAAiB,GAAG,GAAG,EACvB,KAAwB;IAExB,OAAO,IAAI,YAAY,CAAC,EAAE,MAAM,EAAE,iBAAiB,EAAE,KAAK,EAAE,CAAC,CAAC;AAChE,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Lightweight caching service with TTL support.\n *\n * Two implementations:\n * - In-memory (default): LRU-style Map cache, no external dependencies\n * - Redis: When a Redis client is provided, uses Redis for cross-process caching\n *\n * Design:\n * - All operations are fail-safe: cache misses/errors return null, never throw\n * - JSON serialization for Redis; direct reference for in-memory\n * - Key namespace prefixing to avoid collisions between services\n */\n\n\n/**\n * Cache entry with value and expiration time.\n */\ninterface CacheEntry<T> {\n  value: T;\n  expiresAt: number; // Unix timestamp in ms\n}\n\n/**\n * Minimal Redis-like client interface (subset of ioredis).\n * Services pass their own Redis client instance.\n */\nexport interface RedisCacheClient {\n  get(key: string): Promise<string | null>;\n  set(key: string, value: string, ...args: unknown[]): Promise<unknown>;\n  del(...keys: string[]): Promise<number>;\n  keys(pattern: string): Promise<string[]>;\n  /** SCAN-based iteration (preferred over KEYS for production). */\n  scanStream?(options: { match: string; count?: number }): NodeJS.ReadableStream;\n}\n\nexport interface CacheConfig {\n  /** Key prefix for namespace isolation (e.g., 'plugin:', 'compliance:') */\n  prefix: string;\n  /** Default TTL in seconds */\n  defaultTtlSeconds: number;\n  /** Max entries for in-memory cache (default 1000) */\n  maxEntries?: number;\n  /** Optional Redis client — uses in-memory cache if not provided */\n  redis?: RedisCacheClient;\n}\n\n/**\n * Cache service with get/set/del operations and automatic TTL expiry.\n *\n * @example\n * ```typescript\n * const cache = new CacheService({ prefix: 'plugin:', defaultTtlSeconds: 300 });\n *\n * // Set with default TTL\n * await cache.set('org123:list', plugins);\n *\n * // Get (returns null on miss)\n * const cached = await cache.get<Plugin[]>('org123:list');\n *\n * // Invalidate\n * await cache.del('org123:list');\n *\n * // Invalidate by pattern\n * await cache.invalidatePattern('org123:*');\n * ```\n */\nexport class CacheService {\n  private memory = new Map<string, CacheEntry<unknown>>();\n  private readonly prefix: string;\n  private readonly defaultTtlMs: number;\n  private readonly maxEntries: number;\n  private readonly redis?: RedisCacheClient;\n\n  /** Cache metrics — tracks hits, misses, and invalidations. */\n  readonly metrics = { hits: 0, misses: 0, sets: 0, invalidations: 0 };\n\n  constructor(config: CacheConfig) {\n    this.prefix = config.prefix;\n    this.defaultTtlMs = config.defaultTtlSeconds * 1000;\n    this.maxEntries = config.maxEntries ?? 1000;\n    this.redis = config.redis;\n  }\n\n  private fullKey(key: string): string {\n    return `${this.prefix}${key}`;\n  }\n\n  /**\n   * Get a cached value. Returns null on miss or error.\n   */\n  async get<T>(key: string): Promise<T | null> {\n    const fk = this.fullKey(key);\n\n    try {\n      if (this.redis) {\n        const raw = await this.redis.get(fk);\n        if (!raw) { this.metrics.misses++; return null; }\n        this.metrics.hits++;\n        return JSON.parse(raw) as T;\n      }\n\n      // In-memory\n      const entry = this.memory.get(fk);\n      if (!entry) { this.metrics.misses++; return null; }\n      if (Date.now() > entry.expiresAt) {\n        this.memory.delete(fk);\n        this.metrics.misses++;\n        return null;\n      }\n      this.metrics.hits++;\n      return entry.value as T;\n    } catch {\n      this.metrics.misses++;\n      return null;\n    }\n  }\n\n  /**\n   * Set a cached value with optional TTL override.\n   *\n   * @param key - Cache key (prefix is added automatically)\n   * @param value - Value to cache (must be JSON-serializable for Redis)\n   * @param ttlSeconds - TTL override (uses default if not provided)\n   */\n  async set<T>(key: string, value: T, ttlSeconds?: number): Promise<void> {\n    const fk = this.fullKey(key);\n    const ttl = ttlSeconds ?? this.defaultTtlMs / 1000;\n\n    try {\n      this.metrics.sets++;\n      if (this.redis) {\n        await this.redis.set(fk, JSON.stringify(value), 'EX', ttl);\n        return;\n      }\n\n      // In-memory — evict oldest if at capacity\n      if (this.memory.size >= this.maxEntries) {\n        const firstKey = this.memory.keys().next().value;\n        if (firstKey) this.memory.delete(firstKey);\n      }\n\n      this.memory.set(fk, {\n        value,\n        expiresAt: Date.now() + ttl * 1000,\n      });\n    } catch {\n      // Cache set failure is non-fatal\n    }\n  }\n\n  /**\n   * Delete a cached value.\n   */\n  async del(key: string): Promise<void> {\n    const fk = this.fullKey(key);\n\n    try {\n      if (this.redis) {\n        await this.redis.del(fk);\n        return;\n      }\n      this.memory.delete(fk);\n    } catch {\n      // Cache delete failure is non-fatal\n    }\n  }\n\n  /**\n   * Invalidate all keys matching a pattern (e.g., 'org123:*').\n   * Uses SCAN for Redis (non-blocking) with KEYS fallback, or regex for in-memory.\n   */\n  async invalidatePattern(pattern: string): Promise<number> {\n    const fp = this.fullKey(pattern);\n\n    try {\n      if (this.redis) {\n        const keys = this.redis.scanStream\n          ? await this.scanKeys(fp)\n          : await this.redis.keys(fp);\n        if (keys.length > 0) {\n          await this.redis.del(...keys);\n          this.metrics.invalidations += keys.length;\n        }\n        return keys.length;\n      }\n\n      // In-memory — match glob-style pattern. Escape regex metacharacters first\n      // so a literal `.`/`(`/`[` in a key prefix (e.g. `org:v1.2:*`) can't\n      // over-match or throw (a throw here is swallowed → nothing invalidated →\n      // stale reads); only `*` is treated as a wildcard.\n      const regex = new RegExp('^' + fp.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&').replace(/\\\\\\*/g, '.*') + '$');\n      let deleted = 0;\n      for (const key of this.memory.keys()) {\n        if (regex.test(key)) {\n          this.memory.delete(key);\n          deleted++;\n        }\n      }\n      this.metrics.invalidations += deleted;\n      return deleted;\n    } catch {\n      return 0;\n    }\n  }\n\n  /** Collect keys via Redis SCAN (non-blocking alternative to KEYS). */\n  private scanKeys(pattern: string): Promise<string[]> {\n    return new Promise((resolve, reject) => {\n      const stream = this.redis!.scanStream!({ match: pattern, count: 100 });\n      const keys: string[] = [];\n      stream.on('data', (batch: string[]) => keys.push(...batch));\n      stream.once('end', () => resolve(keys));\n      stream.once('error', reject);\n    });\n  }\n\n  /**\n   * Get or compute: returns cached value if available, otherwise calls the\n   * factory function, caches the result, and returns it.\n   *\n   * @param key - Cache key\n   * @param factory - Async function to compute the value on cache miss\n   * @param ttlSeconds - Optional TTL override\n   * @returns The cached or computed value\n   */\n  async getOrSet<T>(key: string, factory: () => Promise<T>, ttlSeconds?: number): Promise<T> {\n    const cached = await this.get<T>(key);\n    if (cached !== null) return cached;\n\n    const value = await factory();\n    await this.set(key, value, ttlSeconds);\n    return value;\n  }\n\n  /**\n   * Clear all entries (useful for testing).\n   */\n  async clear(): Promise<void> {\n    if (this.redis) {\n      await this.invalidatePattern('*');\n    } else {\n      this.memory.clear();\n    }\n  }\n\n  /** Current in-memory cache size (for diagnostics). */\n  get size(): number {\n    return this.memory.size;\n  }\n}\n\n/**\n * Create a cache service instance.\n *\n * @param prefix - Namespace prefix (e.g., 'compliance:', 'plugin:')\n * @param defaultTtlSeconds - Default TTL in seconds (default 300 = 5 min)\n * @param redis - Optional Redis client for cross-process caching\n */\nexport function createCacheService(\n  prefix: string,\n  defaultTtlSeconds = 300,\n  redis?: RedisCacheClient,\n): CacheService {\n  return new CacheService({ prefix, defaultTtlSeconds, redis });\n}\n"]}

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

@@ -54,6 +54,7 @@ export function registerComplianceEventSubscriber(config, serviceName = 'entity-
                 target: event.target,
                 entityId: event.entityId,
                 orgId: event.orgId,
+                parentOrgId: event.parentOrgId,
                 userId: event.userId,
                 attributes: event.attributes,
                 timestamp: event.timestamp.toISOString(),
@@ -66,4 +67,4 @@ export function registerComplianceEventSubscriber(config, serviceName = 'entity-
         port: serviceConfig.port,
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -3,6 +3,9 @@ export interface ComplianceEvent {
     target: 'plugin' | 'pipeline';
     entityId: string;
     orgId: string;
+    /** Owning org's parent (present only when `orgId` is a team) so the async
+     *  worker evaluates parent `propagateToChildren` rules like the live path. */
+    parentOrgId?: string;
     userId: string;
     attributes: Record<string, unknown>;
     timestamp: string;

package/lib/services/compliance-queue.js

@@ -31,4 +31,4 @@ export async function enqueueComplianceEvent(event) {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcGxpYW5jZS1xdWV1ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zZXJ2aWNlcy9jb21wbGlhbmNlLXF1ZXVlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLCtDQUErQztBQUMvQyxzQ0FBc0M7QUFFdEMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRWxELE1BQU0sTUFBTSxHQUFHLFlBQVksQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDO0FBWWhEOzs7O0dBSUc7QUFDSCxJQUFJLFNBQVMsR0FBdUQsSUFBSSxDQUFDO0FBRXpFLE1BQU0sVUFBVSw4QkFBOEIsQ0FBQyxFQUE2QztJQUMxRixTQUFTLEdBQUcsRUFBRSxDQUFDO0lBQ2YsTUFBTSxDQUFDLElBQUksQ0FBQyxxQ0FBcUMsQ0FBQyxDQUFDO0FBQ3JELENBQUM7QUFFRCxNQUFNLENBQUMsS0FBSyxVQUFVLHNCQUFzQixDQUFDLEtBQXNCO0lBQ2pFLElBQUksQ0FBQyxTQUFTLEVBQUUsQ0FBQztRQUNmLE1BQU0sQ0FBQyxLQUFLLENBQUMsMERBQTBELEVBQUU7WUFDdkUsU0FBUyxFQUFFLEtBQUssQ0FBQyxTQUFTLEVBQUUsTUFBTSxFQUFFLEtBQUssQ0FBQyxNQUFNLEVBQUUsUUFBUSxFQUFFLEtBQUssQ0FBQyxRQUFRO1NBQzNFLENBQUMsQ0FBQztRQUNILE9BQU87SUFDVCxDQUFDO0lBQ0QsSUFBSSxDQUFDO1FBQ0gsTUFBTSxTQUFTLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDdkIsTUFBTSxDQUFDLEtBQUssQ0FBQywyQkFBMkIsRUFBRSxFQUFFLFNBQVMsRUFBRSxLQUFLLENBQUMsU0FBUyxFQUFFLE1BQU0sRUFBRSxLQUFLLENBQUMsTUFBTSxFQUFFLFFBQVEsRUFBRSxLQUFLLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQztJQUM1SCxDQUFDO0lBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQztRQUNiLE1BQU0sQ0FBQyxJQUFJLENBQUMsb0NBQW9DLEVBQUU7WUFDaEQsU0FBUyxFQUFFLEtBQUssQ0FBQyxTQUFTO1lBQzFCLFFBQVEsRUFBRSxLQUFLLENBQUMsUUFBUTtZQUN4QixLQUFLLEVBQUUsR0FBRyxZQUFZLEtBQUssQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQztTQUN4RCxDQUFDLENBQUM7SUFDTCxDQUFDO0FBQ0gsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG5pbXBvcnQgeyBjcmVhdGVMb2dnZXIgfSBmcm9tICcuLi91dGlscy9sb2dnZXIuanMnO1xuXG5jb25zdCBsb2dnZXIgPSBjcmVhdGVMb2dnZXIoJ2NvbXBsaWFuY2UtcXVldWUnKTtcblxuZXhwb3J0IGludGVyZmFjZSBDb21wbGlhbmNlRXZlbnQge1xuICBldmVudFR5cGU6ICd2YWxpZGF0ZScgfCAnc2NhbicgfCAnbm90aWZ5JztcbiAgdGFyZ2V0OiAncGx1Z2luJyB8ICdwaXBlbGluZSc7XG4gIGVudGl0eUlkOiBzdHJpbmc7XG4gIG9yZ0lkOiBzdHJpbmc7XG4gIHVzZXJJZDogc3RyaW5nO1xuICBhdHRyaWJ1dGVzOiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPjtcbiAgdGltZXN0YW1wOiBzdHJpbmc7XG59XG5cbi8qKlxuICogUGx1Z2dhYmxlIGNvbXBsaWFuY2UgZXZlbnQgcXVldWUuXG4gKiBTZXJ2aWNlcyByZWdpc3RlciBhIGJhY2tlbmQgKEJ1bGxNUSwgU1FTLCBvciBpbi1tZW1vcnkpIGF0IHN0YXJ0dXAuXG4gKiBJZiBubyBiYWNrZW5kIGlzIHJlZ2lzdGVyZWQsIGV2ZW50cyBhcmUgbG9nZ2VkIGFuZCBkaXNjYXJkZWQuXG4gKi9cbmxldCBlbnF1ZXVlRm46ICgoZXZlbnQ6IENvbXBsaWFuY2VFdmVudCkgPT4gUHJvbWlzZTx2b2lkPikgfCBudWxsID0gbnVsbDtcblxuZXhwb3J0IGZ1bmN0aW9uIHJlZ2lzdGVyQ29tcGxpYW5jZVF1ZXVlQmFja2VuZChmbjogKGV2ZW50OiBDb21wbGlhbmNlRXZlbnQpID0+IFByb21pc2U8dm9pZD4pOiB2b2lkIHtcbiAgZW5xdWV1ZUZuID0gZm47XG4gIGxvZ2dlci5pbmZvKCdDb21wbGlhbmNlIHF1ZXVlIGJhY2tlbmQgcmVnaXN0ZXJlZCcpO1xufVxuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gZW5xdWV1ZUNvbXBsaWFuY2VFdmVudChldmVudDogQ29tcGxpYW5jZUV2ZW50KTogUHJvbWlzZTx2b2lkPiB7XG4gIGlmICghZW5xdWV1ZUZuKSB7XG4gICAgbG9nZ2VyLmRlYnVnKCdDb21wbGlhbmNlIGV2ZW50IGRpc2NhcmRlZCAobm8gcXVldWUgYmFja2VuZCByZWdpc3RlcmVkKScsIHtcbiAgICAgIGV2ZW50VHlwZTogZXZlbnQuZXZlbnRUeXBlLCB0YXJnZXQ6IGV2ZW50LnRhcmdldCwgZW50aXR5SWQ6IGV2ZW50LmVudGl0eUlkLFxuICAgIH0pO1xuICAgIHJldHVybjtcbiAgfVxuICB0cnkge1xuICAgIGF3YWl0IGVucXVldWVGbihldmVudCk7XG4gICAgbG9nZ2VyLmRlYnVnKCdDb21wbGlhbmNlIGV2ZW50IGVucXVldWVkJywgeyBldmVudFR5cGU6IGV2ZW50LmV2ZW50VHlwZSwgdGFyZ2V0OiBldmVudC50YXJnZXQsIGVudGl0eUlkOiBldmVudC5lbnRpdHlJZCB9KTtcbiAgfSBjYXRjaCAoZXJyKSB7XG4gICAgbG9nZ2VyLndhcm4oJ0ZhaWxlZCB0byBlbnF1ZXVlIGNvbXBsaWFuY2UgZXZlbnQnLCB7XG4gICAgICBldmVudFR5cGU6IGV2ZW50LmV2ZW50VHlwZSxcbiAgICAgIGVudGl0eUlkOiBldmVudC5lbnRpdHlJZCxcbiAgICAgIGVycm9yOiBlcnIgaW5zdGFuY2VvZiBFcnJvciA/IGVyci5tZXNzYWdlIDogU3RyaW5nKGVyciksXG4gICAgfSk7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -9,6 +9,10 @@ export interface EntityEvent {
     entityId: string;
     /** The organization that owns this entity */
     orgId: string;
+    /** Org → team hierarchy: the owning org's parent (present only when `orgId` is
+     *  a team). Lets compliance evaluate parent `propagateToChildren` rules on the
+     *  async event path, matching live validation. */
+    parentOrgId?: string;
     /** The user who performed the mutation */
     userId: string;
     /** When the event occurred */

package/lib/services/entity-events.js

@@ -57,4 +57,4 @@ class EntityEventEmitter {
 }
 /** Singleton entity event emitter — shared across the process */
 export const entityEvents = new EntityEventEmitter();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/services/leader-lock.d.ts

@@ -6,6 +6,9 @@ export interface LockRedis {
     set(key: string, value: string, ...args: unknown[]): Promise<unknown>;
     get(key: string): Promise<string | null>;
     del(...keys: string[]): Promise<number>;
+    /** Optional Lua eval (ioredis has it). When present, release uses an atomic
+     *  compare-and-delete so a lapsed holder can't free a successor's lock. */
+    eval?(script: string, numKeys: number, ...args: unknown[]): Promise<unknown>;
 }
 /**
  * Run `fn` only if this process wins a short-lived distributed lock — the

package/lib/services/leader-lock.js

@@ -1,6 +1,9 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import { randomUUID } from 'crypto';
+/** Atomic "delete only if I still own it" — closes the get-then-del race where
+ *  the lock expires and is re-acquired between the two calls. */
+const RELEASE_IF_OWNER = 'if redis.call("get", KEYS[1]) == ARGV[1] then return redis.call("del", KEYS[1]) else return 0 end';
 /**
  * Run `fn` only if this process wins a short-lived distributed lock — the
  * across-pods "single runner" guard for periodic jobs (digest flushes, etc.).
@@ -22,10 +25,16 @@ export async function withLeaderLock(redis, key, ttlMs, fn) {
     }
     finally {
         // Release only if the lock is still ours — if our run overran the TTL and
-        // another holder took over, deleting here would free their lock early.
+        // another holder took over, releasing here would free their lock early.
+        // Prefer an atomic CAS (Lua); fall back to get-then-del for clients without
+        // eval (the small non-atomic window is TTL-bounded).
         try {
-            if ((await redis.get(key)) === token)
+            if (typeof redis.eval === 'function') {
+                await redis.eval(RELEASE_IF_OWNER, 1, key, token);
+            }
+            else if ((await redis.get(key)) === token) {
                 await redis.del(key);
+            }
         }
         catch {
             // Best-effort: the TTL expires the lock regardless.
@@ -33,4 +42,4 @@ export async function withLeaderLock(redis, key, ttlMs, fn) {
     }
     return true;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/types/common.d.ts

@@ -1,3 +1,4 @@
+import type { Permission } from './permissions.js';
 /**
  * Quota type identifiers.
  *
@@ -126,6 +127,8 @@ export type ApiResponse<T = unknown> = ApiSuccessResponse<T> | ApiErrorResponse;
  * Use `POST /auth/switch-org` to change the active organization, which
  * re-issues tokens with the new org's role and context.
  */
+/** Per-org role in a single organization/team. Not a global role. */
+export type OrgRole = 'owner' | 'admin' | 'member';
 export interface JwtPayload {
     /** User ID (subject) */
     sub: string;
@@ -134,9 +137,17 @@ export interface JwtPayload {
     /** User email */
     email: string;
     /** Per-org role in the active organization ('owner' | 'admin' | 'member'). Not a global role. */
-    role: 'owner' | 'admin' | 'member';
+    role: OrgRole;
     /** Derived: true when role is 'admin' or 'owner' in the active organization */
     isAdmin?: boolean;
+    /**
+     * Resolved fine-grained permissions for the active org/team — the union of
+     * the role's base bundle and every group the user belongs to (see
+     * `resolveUserPermissions`). Absent on machine/scoped tokens. Superadmins are
+     * granted all permissions implicitly and may omit this. Endpoints enforce via
+     * `requirePermission(...)`.
+     */
+    permissions?: Permission[];
     /**
      * Global super-admin flag (cross-org). When `true`, the user is treated
      * as a system administrator regardless of which org they're currently
@@ -151,6 +162,13 @@ export interface JwtPayload {
     tier?: string;
     /** Resolved feature flags for this user/org */
     features?: string[];
+    /**
+     * Narrow capability scope for machine/automation tokens (e.g.
+     * `'reporting:ingest'`). Absent on normal interactive user tokens. Endpoints
+     * that accept a scoped identity check this (see `hasScope`) instead of role;
+     * a scoped token is minted with minimal role for least-privilege.
+     */
+    scope?: string;
     /** Active organization ID (from UserOrganization membership) */
     organizationId?: string;
     /** Active organization name */

package/lib/types/common.js

@@ -48,4 +48,4 @@ export function validateQuotaType(value, fieldName = 'quotaType') {
     }
     return value;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.js","sourceRoot":"","sources":["../../src/types/common.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AA8BtC;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc;IAC7D,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,YAAY;CACrD,CAAC;AAEX;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,iBAAiB,CAAC,QAAQ,CAAC,KAAkB,CAAC,CAAC;AACrF,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAc,EAAE,SAAS,GAAG,WAAW;IACvE,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CACb,WAAW,SAAS,MAAM,KAAK,sBAAsB,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CACpF,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Quota type identifiers.\n *\n * - `plugins` / `pipelines` — count of created entities\n * - `apiCalls` — generic API call count (read-heavy paths)\n * - `aiCalls` — AI provider invocations (counted separately because each call\n *   has external dollar cost; sized smaller than apiCalls per tier)\n * - `storageBytes` — registry storage budget per org. Unlike the others\n *   (which count discrete events), this is a measured total recomputed\n *   on demand. Incremented by the image-registry's push-gate before\n *   issuing a token whose scope includes `push`; the GC scheduler\n *   eventually frees the bytes, then the next push-gate check reads\n *   the lower value. NOT a counter-style quota in the sense of\n *   `incrementUsage` — the registry pushes the measured total via\n *   `updateLimits`/`resetUsage` flows. Tier limits are bytes.\n * - `dashboards` / `alertRules` / `alertDestinations` / `idpConfigs` —\n *   resource-count quotas added to close per-org DoS surfaces in the\n *   user-editable feature tables. Without these caps a single org could\n *   spam thousands of dashboards / rules and bloat the shared Postgres /\n *   Mongo working sets. Counted at create time; decremented on delete.\n */\n// NOTE: `seats` is intentionally NOT here. It's a tier limit (QuotaTierLimits)\n// enforced by comparing the org's LIVE member count at invite time — not an\n// incrementing per-period counter like the consumable quotas below.\nexport type QuotaType =\n  | 'plugins' | 'pipelines' | 'apiCalls' | 'aiCalls' | 'storageBytes'\n  | 'dashboards' | 'alertRules' | 'alertDestinations' | 'idpConfigs';\n\n/**\n * Valid quota type values.\n */\nexport const VALID_QUOTA_TYPES = [\n  'plugins', 'pipelines', 'apiCalls', 'aiCalls', 'storageBytes',\n  'dashboards', 'alertRules', 'alertDestinations', 'idpConfigs',\n] as const;\n\n/**\n * Type guard to check if a value is a valid QuotaType.\n *\n * @param value - Value to check\n * @returns True if value is a valid QuotaType\n *\n * @example\n * ```typescript\n * if (isValidQuotaType(req.body.quotaType)) {\n *   // quotaType is guaranteed to be QuotaType\n * }\n * ```\n */\nexport function isValidQuotaType(value: unknown): value is QuotaType {\n  return typeof value === 'string' && VALID_QUOTA_TYPES.includes(value as QuotaType);\n}\n\n/**\n * Validate and assert that a value is a valid QuotaType.\n * Throws an error if validation fails.\n *\n * @param value - Value to validate\n * @param fieldName - Name of the field being validated (for error messages)\n * @returns The validated QuotaType\n * @throws Error if value is not a valid QuotaType\n *\n * @example\n * ```typescript\n * try {\n *   const quotaType = validateQuotaType(req.body.quotaType, 'quotaType');\n *   // Use quotaType safely\n * } catch (err) {\n *   return sendError(res, 400, err.message);\n * }\n * ```\n */\nexport function validateQuotaType(value: unknown, fieldName = 'quotaType'): QuotaType {\n  if (!isValidQuotaType(value)) {\n    throw new Error(\n      `Invalid ${fieldName}: \"${value}\". Must be one of: ${VALID_QUOTA_TYPES.join(', ')}`,\n    );\n  }\n  return value;\n}\n\n/**\n * Result from quota check operation.\n */\nexport interface QuotaCheckResult {\n  /** Whether the request is allowed */\n  allowed: boolean;\n  /** Maximum quota limit (-1 for unlimited) */\n  limit: number;\n  /** Current usage count */\n  used: number;\n  /** Remaining quota (-1 for unlimited) */\n  remaining: number;\n  /** ISO timestamp when quota resets */\n  resetAt: string;\n  /** Whether quota is unlimited */\n  unlimited: boolean;\n  /**\n   * True ONLY when this result is the fail-open sentinel returned because the\n   * quota service was unreachable / returned non-ok (not a real quota reading).\n   * Lets fail-closed callers (e.g. the registry storage push-gate) distinguish\n   * an outage from a genuine `limit: -1` (unlimited) org. Absent on real results.\n   */\n  failOpen?: boolean;\n}\n\n/**\n * Quota information for error responses.\n */\nexport interface QuotaInfo {\n  type: QuotaType;\n  limit: number;\n  used: number;\n  remaining: number;\n}\n\n/**\n * Standard API success response.\n */\nexport interface ApiSuccessResponse<T = unknown> {\n  success: true;\n  statusCode: number;\n  data?: T;\n  message?: string;\n}\n\n/**\n * Standard API error response.\n */\nexport interface ApiErrorResponse {\n  success: false;\n  statusCode: number;\n  message: string;\n  code?: string;\n  details?: unknown;\n  quota?: QuotaInfo;\n}\n\n/**\n * Combined API response type.\n */\nexport type ApiResponse<T = unknown> = ApiSuccessResponse<T> | ApiErrorResponse;\n\n/**\n * JWT payload from access tokens.\n *\n * Users can belong to multiple organizations. The token is scoped to one\n * active organization at a time. The `role` field is the user's per-org\n * role in that organization (from the UserOrganization junction collection),\n * and `isAdmin` is derived as `role === 'admin' || role === 'owner'`.\n *\n * Use `POST /auth/switch-org` to change the active organization, which\n * re-issues tokens with the new org's role and context.\n */\nexport interface JwtPayload {\n  /** User ID (subject) */\n  sub: string;\n  /** Username */\n  username: string;\n  /** User email */\n  email: string;\n  /** Per-org role in the active organization ('owner' | 'admin' | 'member'). Not a global role. */\n  role: 'owner' | 'admin' | 'member';\n  /** Derived: true when role is 'admin' or 'owner' in the active organization */\n  isAdmin?: boolean;\n  /**\n   * Global super-admin flag (cross-org). When `true`, the user is treated\n   * as a system administrator regardless of which org they're currently\n   * acting under. This is the canonical signal for sysadmin authority —\n   * previously the only path was membership in the well-known \"system\" org\n   * with role admin/owner, which conflated \"Pipeline Builder operator\" with\n   * \"real customer tenant\" in the data model. Either path still works\n   * during the rollout; new users should be granted via `isSuperAdmin`.\n   */\n  isSuperAdmin?: boolean;\n  /** Organization's quota tier ('developer' | 'pro' | 'team' | 'enterprise') */\n  tier?: string;\n  /** Resolved feature flags for this user/org */\n  features?: string[];\n  /** Active organization ID (from UserOrganization membership) */\n  organizationId?: string;\n  /** Active organization name */\n  organizationName?: string;\n  /**\n   * Org → team hierarchy (org-team-hierarchy proposal, phase 1).\n   * `parentOrganizationId` is the active org's direct parent; `rootOrganizationId`\n   * is the top of its ancestry chain. Both are **omitted for flat (root) orgs** —\n   * consumers should treat the effective root as `rootOrganizationId ?? organizationId`.\n   * Currently every org is flat, so these are absent on all tokens today.\n   */\n  parentOrganizationId?: string;\n  /** Root organization ID of the active org's ancestry chain (see `parentOrganizationId`). */\n  rootOrganizationId?: string;\n  /**\n   * Set on tokens issued by the sysadmin impersonation flow\n   * (`POST /admin/impersonate/:userId`). Carries the original sysadmin's\n   * user id so audit events still attribute actions correctly.\n   */\n  impersonatorId?: string;\n  /**\n   * When true, the token is read-only — any non-GET request is rejected\n   * upstream by the platform's read-only impersonation gate. Lets\n   * sysadmins \"view as user X\" without risking a destructive action.\n   */\n  impersonationReadOnly?: boolean;\n  /** Token type */\n  type: 'access' | 'refresh';\n  /** Issued at timestamp */\n  iat?: number;\n  /** Expiration timestamp */\n  exp?: number;\n}\n\n/**\n * Extended Express Request with user property.\n */\ndeclare global {\n  namespace Express {\n    interface Request {\n      user?: JwtPayload;\n    }\n  }\n}\n\n/**\n * Service configuration for internal HTTP client.\n */\nexport interface ServiceConfig {\n  /** Service hostname */\n  host: string;\n  /** Service port */\n  port: number;\n  /** Request timeout in milliseconds */\n  timeout?: number;\n}\n\n/**\n * Health check response.\n */\nexport interface HealthCheckResponse {\n  status: 'healthy' | 'unhealthy';\n  service: string;\n  timestamp: string;\n  uptime: number;\n  version?: string;\n  dependencies?: Record<string, 'connected' | 'disconnected' | 'unknown'>;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.js","sourceRoot":"","sources":["../../src/types/common.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAgCtC;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc;IAC7D,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,YAAY;CACrD,CAAC;AAEX;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,iBAAiB,CAAC,QAAQ,CAAC,KAAkB,CAAC,CAAC;AACrF,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAc,EAAE,SAAS,GAAG,WAAW;IACvE,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CACb,WAAW,SAAS,MAAM,KAAK,sBAAsB,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CACpF,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Permission } from './permissions.js';\n\n/**\n * Quota type identifiers.\n *\n * - `plugins` / `pipelines` — count of created entities\n * - `apiCalls` — generic API call count (read-heavy paths)\n * - `aiCalls` — AI provider invocations (counted separately because each call\n *   has external dollar cost; sized smaller than apiCalls per tier)\n * - `storageBytes` — registry storage budget per org. Unlike the others\n *   (which count discrete events), this is a measured total recomputed\n *   on demand. Incremented by the image-registry's push-gate before\n *   issuing a token whose scope includes `push`; the GC scheduler\n *   eventually frees the bytes, then the next push-gate check reads\n *   the lower value. NOT a counter-style quota in the sense of\n *   `incrementUsage` — the registry pushes the measured total via\n *   `updateLimits`/`resetUsage` flows. Tier limits are bytes.\n * - `dashboards` / `alertRules` / `alertDestinations` / `idpConfigs` —\n *   resource-count quotas added to close per-org DoS surfaces in the\n *   user-editable feature tables. Without these caps a single org could\n *   spam thousands of dashboards / rules and bloat the shared Postgres /\n *   Mongo working sets. Counted at create time; decremented on delete.\n */\n// NOTE: `seats` is intentionally NOT here. It's a tier limit (QuotaTierLimits)\n// enforced by comparing the org's LIVE member count at invite time — not an\n// incrementing per-period counter like the consumable quotas below.\nexport type QuotaType =\n  | 'plugins' | 'pipelines' | 'apiCalls' | 'aiCalls' | 'storageBytes'\n  | 'dashboards' | 'alertRules' | 'alertDestinations' | 'idpConfigs';\n\n/**\n * Valid quota type values.\n */\nexport const VALID_QUOTA_TYPES = [\n  'plugins', 'pipelines', 'apiCalls', 'aiCalls', 'storageBytes',\n  'dashboards', 'alertRules', 'alertDestinations', 'idpConfigs',\n] as const;\n\n/**\n * Type guard to check if a value is a valid QuotaType.\n *\n * @param value - Value to check\n * @returns True if value is a valid QuotaType\n *\n * @example\n * ```typescript\n * if (isValidQuotaType(req.body.quotaType)) {\n *   // quotaType is guaranteed to be QuotaType\n * }\n * ```\n */\nexport function isValidQuotaType(value: unknown): value is QuotaType {\n  return typeof value === 'string' && VALID_QUOTA_TYPES.includes(value as QuotaType);\n}\n\n/**\n * Validate and assert that a value is a valid QuotaType.\n * Throws an error if validation fails.\n *\n * @param value - Value to validate\n * @param fieldName - Name of the field being validated (for error messages)\n * @returns The validated QuotaType\n * @throws Error if value is not a valid QuotaType\n *\n * @example\n * ```typescript\n * try {\n *   const quotaType = validateQuotaType(req.body.quotaType, 'quotaType');\n *   // Use quotaType safely\n * } catch (err) {\n *   return sendError(res, 400, err.message);\n * }\n * ```\n */\nexport function validateQuotaType(value: unknown, fieldName = 'quotaType'): QuotaType {\n  if (!isValidQuotaType(value)) {\n    throw new Error(\n      `Invalid ${fieldName}: \"${value}\". Must be one of: ${VALID_QUOTA_TYPES.join(', ')}`,\n    );\n  }\n  return value;\n}\n\n/**\n * Result from quota check operation.\n */\nexport interface QuotaCheckResult {\n  /** Whether the request is allowed */\n  allowed: boolean;\n  /** Maximum quota limit (-1 for unlimited) */\n  limit: number;\n  /** Current usage count */\n  used: number;\n  /** Remaining quota (-1 for unlimited) */\n  remaining: number;\n  /** ISO timestamp when quota resets */\n  resetAt: string;\n  /** Whether quota is unlimited */\n  unlimited: boolean;\n  /**\n   * True ONLY when this result is the fail-open sentinel returned because the\n   * quota service was unreachable / returned non-ok (not a real quota reading).\n   * Lets fail-closed callers (e.g. the registry storage push-gate) distinguish\n   * an outage from a genuine `limit: -1` (unlimited) org. Absent on real results.\n   */\n  failOpen?: boolean;\n}\n\n/**\n * Quota information for error responses.\n */\nexport interface QuotaInfo {\n  type: QuotaType;\n  limit: number;\n  used: number;\n  remaining: number;\n}\n\n/**\n * Standard API success response.\n */\nexport interface ApiSuccessResponse<T = unknown> {\n  success: true;\n  statusCode: number;\n  data?: T;\n  message?: string;\n}\n\n/**\n * Standard API error response.\n */\nexport interface ApiErrorResponse {\n  success: false;\n  statusCode: number;\n  message: string;\n  code?: string;\n  details?: unknown;\n  quota?: QuotaInfo;\n}\n\n/**\n * Combined API response type.\n */\nexport type ApiResponse<T = unknown> = ApiSuccessResponse<T> | ApiErrorResponse;\n\n/**\n * JWT payload from access tokens.\n *\n * Users can belong to multiple organizations. The token is scoped to one\n * active organization at a time. The `role` field is the user's per-org\n * role in that organization (from the UserOrganization junction collection),\n * and `isAdmin` is derived as `role === 'admin' || role === 'owner'`.\n *\n * Use `POST /auth/switch-org` to change the active organization, which\n * re-issues tokens with the new org's role and context.\n */\n/** Per-org role in a single organization/team. Not a global role. */\nexport type OrgRole = 'owner' | 'admin' | 'member';\n\nexport interface JwtPayload {\n  /** User ID (subject) */\n  sub: string;\n  /** Username */\n  username: string;\n  /** User email */\n  email: string;\n  /** Per-org role in the active organization ('owner' | 'admin' | 'member'). Not a global role. */\n  role: OrgRole;\n  /** Derived: true when role is 'admin' or 'owner' in the active organization */\n  isAdmin?: boolean;\n  /**\n   * Resolved fine-grained permissions for the active org/team — the union of\n   * the role's base bundle and every group the user belongs to (see\n   * `resolveUserPermissions`). Absent on machine/scoped tokens. Superadmins are\n   * granted all permissions implicitly and may omit this. Endpoints enforce via\n   * `requirePermission(...)`.\n   */\n  permissions?: Permission[];\n  /**\n   * Global super-admin flag (cross-org). When `true`, the user is treated\n   * as a system administrator regardless of which org they're currently\n   * acting under. This is the canonical signal for sysadmin authority —\n   * previously the only path was membership in the well-known \"system\" org\n   * with role admin/owner, which conflated \"Pipeline Builder operator\" with\n   * \"real customer tenant\" in the data model. Either path still works\n   * during the rollout; new users should be granted via `isSuperAdmin`.\n   */\n  isSuperAdmin?: boolean;\n  /** Organization's quota tier ('developer' | 'pro' | 'team' | 'enterprise') */\n  tier?: string;\n  /** Resolved feature flags for this user/org */\n  features?: string[];\n  /**\n   * Narrow capability scope for machine/automation tokens (e.g.\n   * `'reporting:ingest'`). Absent on normal interactive user tokens. Endpoints\n   * that accept a scoped identity check this (see `hasScope`) instead of role;\n   * a scoped token is minted with minimal role for least-privilege.\n   */\n  scope?: string;\n  /** Active organization ID (from UserOrganization membership) */\n  organizationId?: string;\n  /** Active organization name */\n  organizationName?: string;\n  /**\n   * Org → team hierarchy (org-team-hierarchy proposal, phase 1).\n   * `parentOrganizationId` is the active org's direct parent; `rootOrganizationId`\n   * is the top of its ancestry chain. Both are **omitted for flat (root) orgs** —\n   * consumers should treat the effective root as `rootOrganizationId ?? organizationId`.\n   * Currently every org is flat, so these are absent on all tokens today.\n   */\n  parentOrganizationId?: string;\n  /** Root organization ID of the active org's ancestry chain (see `parentOrganizationId`). */\n  rootOrganizationId?: string;\n  /**\n   * Set on tokens issued by the sysadmin impersonation flow\n   * (`POST /admin/impersonate/:userId`). Carries the original sysadmin's\n   * user id so audit events still attribute actions correctly.\n   */\n  impersonatorId?: string;\n  /**\n   * When true, the token is read-only — any non-GET request is rejected\n   * upstream by the platform's read-only impersonation gate. Lets\n   * sysadmins \"view as user X\" without risking a destructive action.\n   */\n  impersonationReadOnly?: boolean;\n  /** Token type */\n  type: 'access' | 'refresh';\n  /** Issued at timestamp */\n  iat?: number;\n  /** Expiration timestamp */\n  exp?: number;\n}\n\n/**\n * Extended Express Request with user property.\n */\ndeclare global {\n  namespace Express {\n    interface Request {\n      user?: JwtPayload;\n    }\n  }\n}\n\n/**\n * Service configuration for internal HTTP client.\n */\nexport interface ServiceConfig {\n  /** Service hostname */\n  host: string;\n  /** Service port */\n  port: number;\n  /** Request timeout in milliseconds */\n  timeout?: number;\n}\n\n/**\n * Health check response.\n */\nexport interface HealthCheckResponse {\n  status: 'healthy' | 'unhealthy';\n  service: string;\n  timestamp: string;\n  uptime: number;\n  version?: string;\n  dependencies?: Record<string, 'connected' | 'disconnected' | 'unknown'>;\n}\n"]}

package/lib/types/feature-flags.d.ts

@@ -1,6 +1,6 @@
 import type { QuotaTier } from './quota-tiers.js';
 /** Canonical feature flag identifiers. */
-export type FeatureFlag = 'priority_support' | 'custom_integrations' | 'ai_generation' | 'bulk_operations' | 'audit_log';
+export type FeatureFlag = 'priority_support' | 'custom_integrations' | 'ai_generation' | 'bulk_operations' | 'audit_log' | 'sso';
 /** All valid feature flags (order determines display order). */
 export declare const ALL_FEATURE_FLAGS: readonly FeatureFlag[];
 /** Check whether a string is a valid FeatureFlag. */
@@ -25,14 +25,17 @@ export declare const FEATURE_METADATA: Record<FeatureFlag, {
  * @param isSuperAdmin - Whether the user has the global super-admin flag
  * @returns Sorted array of enabled feature flags
  */
-export declare function resolveUserFeatures(tier: QuotaTier, featureOverrides?: Record<string, boolean> | null, isSuperAdmin?: boolean): FeatureFlag[];
+export declare function resolveUserFeatures(tier: QuotaTier, featureOverrides?: Record<string, boolean> | null, isSuperAdmin?: boolean, accountFeatures?: readonly string[] | null): FeatureFlag[];
 /**
- * Check if a specific feature is enabled for a user.
+ * Check if a specific feature is enabled for a user. Delegates to
+ * {@link resolveUserFeatures} so it stays in lockstep — including account-level
+ * entitlements purchased via add-on bundles (`accountFeatures`).
  *
  * @param tier - The organization's quota tier
  * @param feature - The feature flag to check
  * @param featureOverrides - Per-user overrides
  * @param isSuperAdmin - Whether the user has the global super-admin flag
+ * @param accountFeatures - Account-level entitlements (e.g. bundle-granted)
  * @returns true if the feature is enabled
  */
-export declare function hasFeature(tier: QuotaTier, feature: FeatureFlag, featureOverrides?: Record<string, boolean> | null, isSuperAdmin?: boolean): boolean;
+export declare function hasFeature(tier: QuotaTier, feature: FeatureFlag, featureOverrides?: Record<string, boolean> | null, isSuperAdmin?: boolean, accountFeatures?: readonly string[] | null): boolean;