@pipeline-builder/api-core 4.1.22 → 5.0.1

package/lib/services/leader-lock.js

@@ -35,6 +35,35 @@ const RELEASE_IF_OWNER = 'if redis.call("get", KEYS[1]) == ARGV[1] then return r
 const EXTEND_IF_OWNER = 'if redis.call("get", KEYS[1]) == ARGV[1] then return redis.call("pexpire", KEYS[1], ARGV[2]) else return 0 end';
 /** Longest a run waits for a not-yet-connected client before skipping the window. */
 const LOCK_READY_TIMEOUT_MS = 10_000;
+/**
+ * Default lock lifetime — a CRASH-RECOVERY window, not a run-duration cover.
+ *
+ * The holder heartbeats (compare-and-PEXPIRE every `ttlMs / 3`) for as long as
+ * `fn` runs, so a six-hour job holds a two-minute lock perfectly well. What the
+ * TTL actually decides is how long a job stays BLOCKED after the pod holding it
+ * dies without releasing — the key simply sits there until it expires. Sizing the
+ * TTL to the expected run time (which is what several callers used to do) turned a
+ * crashed pod into hours of silent inactivity.
+ *
+ * Two minutes leaves three missed heartbeats of slack, so an event-loop stall or a
+ * brief Redis blip does not hand the lock to a second pod mid-run, while recovery
+ * after a real crash is bounded at two minutes.
+ */
+export const DEFAULT_LEADER_LOCK_TTL_MS = 120_000;
+/**
+ * The one way to build a leader-lock key: `<service>:<job>:leader`.
+ *
+ * Four conventions had grown up — `plugin:vuln-rescan:leader`,
+ * `platform:leader:org-purge`, a bare `ecosystem-stats:leader`, and billing's
+ * unnamespaced `subscription-lifecycle` — which meant no single glob found every
+ * lock. `KEYS '*:leader'` missed billing's three entirely, so an operator asking
+ * "what is held right now" got a partial answer. The env Redis client sets no
+ * `keyPrefix`, so these share one flat keyspace with cache, BullMQ and spool keys;
+ * the `<service>:` segment is what keeps them apart.
+ */
+export function leaderLockKey(service, job) {
+    return `${service}:${job}:leader`;
+}
 /**
  * Run `fn` only if this process wins a short-lived distributed lock — the
  * across-pods "single runner" guard for periodic jobs (digest flushes, etc.).
@@ -50,10 +79,23 @@ const LOCK_READY_TIMEOUT_MS = 10_000;
  * If Redis can't be reached the run is skipped (returns false) rather than
  * rejecting — callers are timers, and a Redis blip must not crash the process.
  *
+ * EVERY outcome is counted, because they mean very different things and the
+ * difference used to be visible only in a log line:
+ *  - `leader_lock_acquired_total` — this pod ran the window. A job whose count
+ *    stays flat is not running ANYWHERE, which is the condition worth alerting on.
+ *  - `leader_lock_contended_total` — another pod holds it. Healthy and expected
+ *    with replicas > 1; exactly one acquire per window across the fleet.
+ *  - `leader_lock_unavailable_total` — Redis unreachable, so NOBODY ran this
+ *    window. A Redis blip silently stopping every sweep fleet-wide was previously
+ *    a WARN log and nothing else.
+ *
  * @returns true if we held the lock and ran `fn`; false if another holder did or
  *   the lock couldn't be taken.
  */
-export async function withLeaderLock(redis, key, ttlMs, fn) {
+export async function withLeaderLock(redis, key, ttlMs, fn, opts = {}) {
+    // Asked to stop before we even tried: don't take a lock we are about to drop.
+    if (opts.signal?.aborted)
+        return false;
     const token = randomUUID();
     let acquired;
     try {
@@ -70,11 +112,24 @@ export async function withLeaderLock(redis, key, ttlMs, fn) {
         lockLogger.warn('Leader lock unavailable; skipping this run', {
             key, error: errorMessage(err),
         });
+        emitCounter('leader_lock_unavailable_total', { key });
         return false;
     }
-    if (acquired !== 'OK')
+    if (acquired !== 'OK') {
+        emitCounter('leader_lock_contended_total', { key });
         return false;
+    }
+    emitCounter('leader_lock_acquired_total', { key });
     const lost = new AbortController();
+    // Shutdown is merged into the SAME signal a lock loss uses: from `fn`'s point of
+    // view both mean "stop between units of work and return". `signal.reason` says
+    // which. Registered with `once` so a long-lived caller signal doesn't retain
+    // this controller after the run.
+    const onExternalAbort = () => {
+        if (!lost.signal.aborted)
+            lost.abort('shutdown');
+    };
+    opts.signal?.addEventListener('abort', onExternalAbort, { once: true });
     let heartbeat;
     if (typeof redis.eval === 'function') {
         const evalFn = redis.eval.bind(redis);
@@ -83,7 +138,7 @@ export async function withLeaderLock(redis, key, ttlMs, fn) {
                 if (Number(extended) !== 1 && !lost.signal.aborted) {
                     lockLogger.warn('Leader lock lost mid-run (another holder, or the key expired)', { key });
                     emitCounter('leader_lock_lost_total', { key });
-                    lost.abort();
+                    lost.abort('lock-lost');
                 }
             }).catch((err) => {
                 // A blip: the next beat retries; the TTL still covers this interval.
@@ -98,6 +153,7 @@ export async function withLeaderLock(redis, key, ttlMs, fn) {
     finally {
         if (heartbeat)
             clearInterval(heartbeat);
+        opts.signal?.removeEventListener('abort', onExternalAbort);
         // Release only if the lock is still ours — if our run overran the TTL and
         // 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
@@ -153,4 +209,4 @@ export async function releaseSharedEnvLock() {
     sharedLock = undefined;
     await closeLeaderLock(client);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"leader-lock.js","sourceRoot":"","sources":["../../src/services/leader-lock.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { randomUUID } from 'crypto';\nimport { createEnvRedisClient, whenRedisReady, type ReadyAwareRedis } from './env-redis.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { errorMessage } from '../utils/response.js';\n\nconst lockLogger = createLogger('leader-lock');\n\n/**\n * Minimal Redis client surface needed for a leader lock (a subset of ioredis).\n * `set` is variadic so callers can pass `'PX', ttl, 'NX'`.\n */\nexport interface LockRedis extends ReadyAwareRedis {\n  set(key: string, value: string, ...args: unknown[]): Promise<unknown>;\n  get(key: string): Promise<string | null>;\n  del(...keys: string[]): Promise<number>;\n  /** Optional Lua eval (ioredis has it). When present, release uses an atomic\n   *  compare-and-delete so a lapsed holder can't free a successor's lock. */\n  eval?(script: string, numKeys: number, ...args: unknown[]): Promise<unknown>;\n  /** Graceful close (ioredis `quit`) — called on shutdown so the connection\n   *  doesn't keep the event loop alive. */\n  quit?(): Promise<unknown>;\n  /** Immediate close (ioredis `disconnect`) — the fallback if `quit` fails. */\n  disconnect?(): void;\n}\n\n/**\n * Best-effort close of a leader-lock Redis client on shutdown. Prefers graceful\n * `quit`; falls back to `disconnect`. No-op for a null client / one without\n * either method. Never throws.\n */\nexport async function closeLeaderLock(redis: LockRedis | null | undefined): Promise<void> {\n  if (!redis) return;\n  try {\n    if (typeof redis.quit === 'function') { await redis.quit(); return; }\n  } catch {\n    // fall through to disconnect\n  }\n  try { redis.disconnect?.(); } catch { /* best-effort */ }\n}\n\n/** Atomic \"delete only if I still own it\" — closes the get-then-del race where\n *  the lock expires and is re-acquired between the two calls. */\nconst RELEASE_IF_OWNER =\n  'if redis.call(\"get\", KEYS[1]) == ARGV[1] then return redis.call(\"del\", KEYS[1]) else return 0 end';\n\n/** Atomic \"extend only if I still own it\" — the heartbeat. */\nconst EXTEND_IF_OWNER =\n  'if redis.call(\"get\", KEYS[1]) == ARGV[1] then return redis.call(\"pexpire\", KEYS[1], ARGV[2]) else return 0 end';\n\n/** Longest a run waits for a not-yet-connected client before skipping the window. */\nconst LOCK_READY_TIMEOUT_MS = 10_000;\n\n/** What a leader-locked run is told while it runs. */\nexport interface LeaderLockRun {\n  /**\n   * Aborted when the lock is LOST mid-run (a heartbeat found another holder, or\n   * the key gone). Long runs should check it between units of work and stop —\n   * past that point another pod may be doing the same work.\n   */\n  signal: AbortSignal;\n}\n\n/**\n * Run `fn` only if this process wins a short-lived distributed lock — the\n * across-pods \"single runner\" guard for periodic jobs (digest flushes, etc.).\n *\n * Uses `SET key token NX PX ttl`, so exactly one holder runs per window and the\n * lock auto-expires if that holder dies mid-run (no stuck lock). While `fn`\n * runs, the holder HEARTBEATS (compare-and-PEXPIRE every `ttlMs / 3`), so a run\n * that outlasts `ttlMs` keeps the lock instead of silently letting a second pod\n * start the same work; a heartbeat that finds the lock gone aborts\n * `run.signal`. The lock is released on completion, but only if we still own\n * it — a slower predecessor never deletes a successor's lock.\n *\n * If Redis can't be reached the run is skipped (returns false) rather than\n * rejecting — callers are timers, and a Redis blip must not crash the process.\n *\n * @returns true if we held the lock and ran `fn`; false if another holder did or\n *   the lock couldn't be taken.\n */\nexport async function withLeaderLock(\n  redis: LockRedis,\n  key: string,\n  ttlMs: number,\n  fn: (run: LeaderLockRun) => Promise<void>,\n): Promise<boolean> {\n  const token = randomUUID();\n  let acquired: unknown;\n  try {\n    // The env client has no offline queue: a SET before the first connection\n    // completes is rejected, which made the FIRST tick after every boot a\n    // guaranteed skip. Wait (bounded) for readiness first.\n    await whenRedisReady(redis, Math.min(LOCK_READY_TIMEOUT_MS, Math.max(1, ttlMs)));\n    acquired = await redis.set(key, token, 'PX', ttlMs, 'NX');\n  } catch (err) {\n    // Redis unreachable (including before the first connection completes): no\n    // pod can prove it's the leader, so nobody runs this window. Skipping is\n    // the safe side — running here could duplicate destructive work across pods.\n    lockLogger.warn('Leader lock unavailable; skipping this run', {\n      key, error: errorMessage(err),\n    });\n    return false;\n  }\n  if (acquired !== 'OK') return false;\n\n  const lost = new AbortController();\n  let heartbeat: NodeJS.Timeout | undefined;\n  if (typeof redis.eval === 'function') {\n    const evalFn = redis.eval.bind(redis);\n    heartbeat = setInterval(() => {\n      evalFn(EXTEND_IF_OWNER, 1, key, token, ttlMs).then((extended) => {\n        if (Number(extended) !== 1 && !lost.signal.aborted) {\n          lockLogger.warn('Leader lock lost mid-run (another holder, or the key expired)', { key });\n          emitCounter('leader_lock_lost_total', { key });\n          lost.abort();\n        }\n      }).catch((err) => {\n        // A blip: the next beat retries; the TTL still covers this interval.\n        lockLogger.debug('Leader lock heartbeat failed', { key, error: errorMessage(err) });\n      });\n    }, Math.max(1, Math.floor(ttlMs / 3)));\n    heartbeat.unref?.();\n  }\n\n  try {\n    await fn({ signal: lost.signal });\n  } finally {\n    if (heartbeat) clearInterval(heartbeat);\n    // Release only if the lock is still ours — if our run overran the TTL and\n    // another holder took over, releasing here would free their lock early.\n    // Prefer an atomic CAS (Lua); fall back to get-then-del for clients without\n    // eval (the small non-atomic window is TTL-bounded).\n    try {\n      if (typeof redis.eval === 'function') {\n        await redis.eval(RELEASE_IF_OWNER, 1, key, token);\n      } else if ((await redis.get(key)) === token) {\n        await redis.del(key);\n      }\n    } catch {\n      // Best-effort: the TTL expires the lock regardless.\n    }\n  }\n  return true;\n}\n\n/**\n * A `LockRedis` backed by the shared env Redis client (see env-redis.ts) — the leader-lock counterpart to `createEnvRedisAuditSpool` /\n * `createEnvRedisTokenRevocationStore`, for a service that has no BullMQ client to\n * borrow. Returns `null` when Redis isn't configured, so a caller can degrade to\n * running on every pod (the atomic guards it wraps must still make that safe).\n * The client is a real ioredis instance; ioredis exposes `set`/`get`/`del`/`eval`,\n * satisfying `LockRedis` including the atomic CAS release.\n */\nexport function createEnvRedisLock(): LockRedis | null {\n  const inst = createEnvRedisClient<LockRedis>('leader-lock');\n  if (inst) lockLogger.info('Redis leader-lock client initialized');\n  return inst;\n}\n\n// One env-configured lock client per process, shared by every scheduler that\n// asks for a lock without supplying its own client. Reference-counted so the\n// connection is closed when the last such scheduler stops.\nlet sharedLock: LockRedis | null | undefined;\nlet sharedLockUsers = 0;\n\n/** Take a reference on the shared env lock client (`null` when Redis isn't configured). */\nexport function acquireSharedEnvLock(): LockRedis | null {\n  if (sharedLock === undefined) sharedLock = createEnvRedisLock();\n  sharedLockUsers++;\n  return sharedLock;\n}\n\n/** Drop a reference taken by {@link acquireSharedEnvLock}; the last one closes the client. */\nexport async function releaseSharedEnvLock(): Promise<void> {\n  if (sharedLockUsers === 0) return;\n  sharedLockUsers--;\n  if (sharedLockUsers > 0) return;\n  const client = sharedLock;\n  sharedLock = undefined;\n  await closeLeaderLock(client);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"leader-lock.js","sourceRoot":"","sources":["../../src/services/leader-lock.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { randomUUID } from 'crypto';\nimport { createEnvRedisClient, whenRedisReady, type ReadyAwareRedis } from './env-redis.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { errorMessage } from '../utils/response.js';\n\nconst lockLogger = createLogger('leader-lock');\n\n/**\n * Minimal Redis client surface needed for a leader lock (a subset of ioredis).\n * `set` is variadic so callers can pass `'PX', ttl, 'NX'`.\n */\nexport interface LockRedis extends ReadyAwareRedis {\n  set(key: string, value: string, ...args: unknown[]): Promise<unknown>;\n  get(key: string): Promise<string | null>;\n  del(...keys: string[]): Promise<number>;\n  /** Optional Lua eval (ioredis has it). When present, release uses an atomic\n   *  compare-and-delete so a lapsed holder can't free a successor's lock. */\n  eval?(script: string, numKeys: number, ...args: unknown[]): Promise<unknown>;\n  /** Graceful close (ioredis `quit`) — called on shutdown so the connection\n   *  doesn't keep the event loop alive. */\n  quit?(): Promise<unknown>;\n  /** Immediate close (ioredis `disconnect`) — the fallback if `quit` fails. */\n  disconnect?(): void;\n}\n\n/**\n * Best-effort close of a leader-lock Redis client on shutdown. Prefers graceful\n * `quit`; falls back to `disconnect`. No-op for a null client / one without\n * either method. Never throws.\n */\nexport async function closeLeaderLock(redis: LockRedis | null | undefined): Promise<void> {\n  if (!redis) return;\n  try {\n    if (typeof redis.quit === 'function') { await redis.quit(); return; }\n  } catch {\n    // fall through to disconnect\n  }\n  try { redis.disconnect?.(); } catch { /* best-effort */ }\n}\n\n/** Atomic \"delete only if I still own it\" — closes the get-then-del race where\n *  the lock expires and is re-acquired between the two calls. */\nconst RELEASE_IF_OWNER =\n  'if redis.call(\"get\", KEYS[1]) == ARGV[1] then return redis.call(\"del\", KEYS[1]) else return 0 end';\n\n/** Atomic \"extend only if I still own it\" — the heartbeat. */\nconst EXTEND_IF_OWNER =\n  'if redis.call(\"get\", KEYS[1]) == ARGV[1] then return redis.call(\"pexpire\", KEYS[1], ARGV[2]) else return 0 end';\n\n/** Longest a run waits for a not-yet-connected client before skipping the window. */\nconst LOCK_READY_TIMEOUT_MS = 10_000;\n\n/**\n * Default lock lifetime — a CRASH-RECOVERY window, not a run-duration cover.\n *\n * The holder heartbeats (compare-and-PEXPIRE every `ttlMs / 3`) for as long as\n * `fn` runs, so a six-hour job holds a two-minute lock perfectly well. What the\n * TTL actually decides is how long a job stays BLOCKED after the pod holding it\n * dies without releasing — the key simply sits there until it expires. Sizing the\n * TTL to the expected run time (which is what several callers used to do) turned a\n * crashed pod into hours of silent inactivity.\n *\n * Two minutes leaves three missed heartbeats of slack, so an event-loop stall or a\n * brief Redis blip does not hand the lock to a second pod mid-run, while recovery\n * after a real crash is bounded at two minutes.\n */\nexport const DEFAULT_LEADER_LOCK_TTL_MS = 120_000;\n\n/**\n * The one way to build a leader-lock key: `<service>:<job>:leader`.\n *\n * Four conventions had grown up — `plugin:vuln-rescan:leader`,\n * `platform:leader:org-purge`, a bare `ecosystem-stats:leader`, and billing's\n * unnamespaced `subscription-lifecycle` — which meant no single glob found every\n * lock. `KEYS '*:leader'` missed billing's three entirely, so an operator asking\n * \"what is held right now\" got a partial answer. The env Redis client sets no\n * `keyPrefix`, so these share one flat keyspace with cache, BullMQ and spool keys;\n * the `<service>:` segment is what keeps them apart.\n */\nexport function leaderLockKey(service: string, job: string): string {\n  return `${service}:${job}:leader`;\n}\n\n/** Why a leader-locked run was told to stop. */\nexport type LeaderLockAbortReason = 'lock-lost' | 'shutdown';\n\n/** What a leader-locked run is told while it runs. */\nexport interface LeaderLockRun {\n  /**\n   * Aborted when the lock is LOST mid-run (a heartbeat found another holder, or\n   * the key gone), or when the caller is SHUTTING DOWN. Long runs must check it\n   * between units of work and return: past a lock loss another pod may be doing\n   * the same work, and on shutdown returning promptly is what releases the lock\n   * instead of leaving it to expire.\n   *\n   * `signal.reason` is a {@link LeaderLockAbortReason}.\n   */\n  signal: AbortSignal;\n}\n\n/** Caller-supplied controls for {@link withLeaderLock}. */\nexport interface LeaderLockOptions {\n  /**\n   * Aborted by the caller to ask a running job to stop — a scheduler's `stop()`\n   * on shutdown. Merged into {@link LeaderLockRun.signal}, so a signal-aware `fn`\n   * returns and the lock is released in the `finally` rather than lingering for\n   * the rest of the TTL.\n   */\n  signal?: AbortSignal;\n}\n\n/**\n * Run `fn` only if this process wins a short-lived distributed lock — the\n * across-pods \"single runner\" guard for periodic jobs (digest flushes, etc.).\n *\n * Uses `SET key token NX PX ttl`, so exactly one holder runs per window and the\n * lock auto-expires if that holder dies mid-run (no stuck lock). While `fn`\n * runs, the holder HEARTBEATS (compare-and-PEXPIRE every `ttlMs / 3`), so a run\n * that outlasts `ttlMs` keeps the lock instead of silently letting a second pod\n * start the same work; a heartbeat that finds the lock gone aborts\n * `run.signal`. The lock is released on completion, but only if we still own\n * it — a slower predecessor never deletes a successor's lock.\n *\n * If Redis can't be reached the run is skipped (returns false) rather than\n * rejecting — callers are timers, and a Redis blip must not crash the process.\n *\n * EVERY outcome is counted, because they mean very different things and the\n * difference used to be visible only in a log line:\n *  - `leader_lock_acquired_total` — this pod ran the window. A job whose count\n *    stays flat is not running ANYWHERE, which is the condition worth alerting on.\n *  - `leader_lock_contended_total` — another pod holds it. Healthy and expected\n *    with replicas > 1; exactly one acquire per window across the fleet.\n *  - `leader_lock_unavailable_total` — Redis unreachable, so NOBODY ran this\n *    window. A Redis blip silently stopping every sweep fleet-wide was previously\n *    a WARN log and nothing else.\n *\n * @returns true if we held the lock and ran `fn`; false if another holder did or\n *   the lock couldn't be taken.\n */\nexport async function withLeaderLock(\n  redis: LockRedis,\n  key: string,\n  ttlMs: number,\n  fn: (run: LeaderLockRun) => Promise<void>,\n  opts: LeaderLockOptions = {},\n): Promise<boolean> {\n  // Asked to stop before we even tried: don't take a lock we are about to drop.\n  if (opts.signal?.aborted) return false;\n\n  const token = randomUUID();\n  let acquired: unknown;\n  try {\n    // The env client has no offline queue: a SET before the first connection\n    // completes is rejected, which made the FIRST tick after every boot a\n    // guaranteed skip. Wait (bounded) for readiness first.\n    await whenRedisReady(redis, Math.min(LOCK_READY_TIMEOUT_MS, Math.max(1, ttlMs)));\n    acquired = await redis.set(key, token, 'PX', ttlMs, 'NX');\n  } catch (err) {\n    // Redis unreachable (including before the first connection completes): no\n    // pod can prove it's the leader, so nobody runs this window. Skipping is\n    // the safe side — running here could duplicate destructive work across pods.\n    lockLogger.warn('Leader lock unavailable; skipping this run', {\n      key, error: errorMessage(err),\n    });\n    emitCounter('leader_lock_unavailable_total', { key });\n    return false;\n  }\n  if (acquired !== 'OK') {\n    emitCounter('leader_lock_contended_total', { key });\n    return false;\n  }\n  emitCounter('leader_lock_acquired_total', { key });\n\n  const lost = new AbortController();\n  // Shutdown is merged into the SAME signal a lock loss uses: from `fn`'s point of\n  // view both mean \"stop between units of work and return\". `signal.reason` says\n  // which. Registered with `once` so a long-lived caller signal doesn't retain\n  // this controller after the run.\n  const onExternalAbort = (): void => {\n    if (!lost.signal.aborted) lost.abort('shutdown' satisfies LeaderLockAbortReason);\n  };\n  opts.signal?.addEventListener('abort', onExternalAbort, { once: true });\n\n  let heartbeat: NodeJS.Timeout | undefined;\n  if (typeof redis.eval === 'function') {\n    const evalFn = redis.eval.bind(redis);\n    heartbeat = setInterval(() => {\n      evalFn(EXTEND_IF_OWNER, 1, key, token, ttlMs).then((extended) => {\n        if (Number(extended) !== 1 && !lost.signal.aborted) {\n          lockLogger.warn('Leader lock lost mid-run (another holder, or the key expired)', { key });\n          emitCounter('leader_lock_lost_total', { key });\n          lost.abort('lock-lost' satisfies LeaderLockAbortReason);\n        }\n      }).catch((err) => {\n        // A blip: the next beat retries; the TTL still covers this interval.\n        lockLogger.debug('Leader lock heartbeat failed', { key, error: errorMessage(err) });\n      });\n    }, Math.max(1, Math.floor(ttlMs / 3)));\n    heartbeat.unref?.();\n  }\n\n  try {\n    await fn({ signal: lost.signal });\n  } finally {\n    if (heartbeat) clearInterval(heartbeat);\n    opts.signal?.removeEventListener('abort', onExternalAbort);\n    // Release only if the lock is still ours — if our run overran the TTL and\n    // another holder took over, releasing here would free their lock early.\n    // Prefer an atomic CAS (Lua); fall back to get-then-del for clients without\n    // eval (the small non-atomic window is TTL-bounded).\n    try {\n      if (typeof redis.eval === 'function') {\n        await redis.eval(RELEASE_IF_OWNER, 1, key, token);\n      } else if ((await redis.get(key)) === token) {\n        await redis.del(key);\n      }\n    } catch {\n      // Best-effort: the TTL expires the lock regardless.\n    }\n  }\n  return true;\n}\n\n/**\n * A `LockRedis` backed by the shared env Redis client (see env-redis.ts) — the leader-lock counterpart to `createEnvRedisAuditSpool` /\n * `createEnvRedisTokenRevocationStore`, for a service that has no BullMQ client to\n * borrow. Returns `null` when Redis isn't configured, so a caller can degrade to\n * running on every pod (the atomic guards it wraps must still make that safe).\n * The client is a real ioredis instance; ioredis exposes `set`/`get`/`del`/`eval`,\n * satisfying `LockRedis` including the atomic CAS release.\n */\nexport function createEnvRedisLock(): LockRedis | null {\n  const inst = createEnvRedisClient<LockRedis>('leader-lock');\n  if (inst) lockLogger.info('Redis leader-lock client initialized');\n  return inst;\n}\n\n// One env-configured lock client per process, shared by every scheduler that\n// asks for a lock without supplying its own client. Reference-counted so the\n// connection is closed when the last such scheduler stops.\nlet sharedLock: LockRedis | null | undefined;\nlet sharedLockUsers = 0;\n\n/** Take a reference on the shared env lock client (`null` when Redis isn't configured). */\nexport function acquireSharedEnvLock(): LockRedis | null {\n  if (sharedLock === undefined) sharedLock = createEnvRedisLock();\n  sharedLockUsers++;\n  return sharedLock;\n}\n\n/** Drop a reference taken by {@link acquireSharedEnvLock}; the last one closes the client. */\nexport async function releaseSharedEnvLock(): Promise<void> {\n  if (sharedLockUsers === 0) return;\n  sharedLockUsers--;\n  if (sharedLockUsers > 0) return;\n  const client = sharedLock;\n  sharedLock = undefined;\n  await closeLeaderLock(client);\n}\n"]}

package/lib/services/quota.js

@@ -4,11 +4,11 @@ import { createSafeClient } from './http-client.js';
 import { getServiceAuthHeader } from '../middleware/service-tokens.js';
 import { ErrorCode } from '../types/error-codes.js';
 import { DEFAULT_TIER, isValidTier } from '../types/quota-tiers.js';
+import { envBool } from '../utils/env.js';
 import { createLogger } from '../utils/logger.js';
 import { emitCounter } from '../utils/metric-emitter.js';
 import { errorMessage, sendError, sendQuotaExceeded } from '../utils/response.js';
 import { serviceEndpoint } from '../utils/service-registry.js';
-import { envBool } from '../utils/env.js';
 /**
  * Retry options for quota calls — fail fast (a slow quota service must not stall the request).
  *
@@ -299,4 +299,4 @@ export function sendQuotaReserveDenied(res, quotaType, reservation) {
 export function decrementQuota(quotaService, orgId, quotaType, authHeader, logWarn, amount = 1, resetAtSnapshot) {
     quotaService.decrement(orgId, quotaType, authHeader, amount, resetAtSnapshot).catch((err) => logWarn('Quota rollback failed', { error: errorMessage(err) }));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quota.js","sourceRoot":"","sources":["../../src/services/quota.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Response } from 'express';\n\nimport { createSafeClient, type RequestOptions } from './http-client.js';\nimport { getServiceAuthHeader } from '../middleware/service-tokens.js';\nimport type { QuotaType, QuotaCheckResult, ServiceConfig } from '../types/common.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { DEFAULT_TIER, isValidTier, type QuotaTier } from '../types/quota-tiers.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { errorMessage, sendError, sendQuotaExceeded } from '../utils/response.js';\nimport { serviceEndpoint } from '../utils/service-registry.js';\nimport { envBool } from '../utils/env.js';\n\n/**\n * Retry options for quota calls — fail fast (a slow quota service must not stall the request).\n *\n * NEVER retry a 429. The quota service answers an over-limit org with 429\n * QUOTA_EXCEEDED and `Retry-After` = seconds until the period resets; the HTTP\n * client honors that (capped at 60s), so a single rate-limit retry stalled the\n * request well past the handler timeout, which then answered 503 and the real\n * 429 was lost. A 429 is a final answer here.\n */\nconst QUOTA_REQUEST_OPTIONS: Pick<RequestOptions, 'maxRateLimitRetries' | 'maxRetries'> = {\n  maxRateLimitRetries: 0,\n  maxRetries: 1,\n};\n\nconst logger = createLogger('quota');\n\n// RESERVE FAIL MODE — explicit, single policy.\n//\n// `reserve` gates EXPENSIVE, billable resources (pipelines, plugin builds, AI\n// calls, platform feature slots). Every quota type is a per-period FLOW counter\n// with no after-the-fact reconciliation: a unit consumed while the reservation\n// could not be confirmed is never counted, so fail-open lets an org consume\n// unbounded unmetered units for the whole length of an incident — and an\n// unconfirmed reserve (timeout, open circuit) may even have landed server-side.\n// So `reserve` fails CLOSED whenever the quota service did not CONFIRM the slot:\n//   - unreachable / timed out / circuit breaker open (no response),\n//   - a reachable-but-errored response (5xx, 4xx, malformed body),\n//   - a 429 that is NOT a genuine QUOTA_EXCEEDED (gateway / rate limiter).\n// Operators who prefer availability over enforcement opt the WHOLE set into\n// fail-open with QUOTA_RESERVE_FAIL_OPEN=true. Both outcomes emit a counter\n// (`quota_fail_closed_total` / `quota_fail_open_total`) tagged with the reason.\n// `check` (a cheap read gate) stays fail-open; `increment` is fire-and-forget.\nconst QUOTA_RESERVE_FAIL_OPEN = envBool('QUOTA_RESERVE_FAIL_OPEN', false);\n\n/**\n * Service-principal `Authorization` header for a quota call made on behalf of\n * `orgId` by the CURRENT service (`SERVICE_NAME`, the same identity the health\n * router reports).\n *\n * The quota service's mutation endpoints (`/:orgId/increment`, `/decrement`)\n * reject anything but a signed service principal or a system admin, so\n * forwarding the end user's bearer token there is always a 403. Service tokens\n * are also exempt from the quota service's per-IP rate limiter, so hot-path\n * quota traffic from a busy pod can't exhaust that pod IP's bucket and silently\n * turn enforcement off. Scoped to the target org with the lowest role (member).\n */\nexport function getQuotaServiceAuthHeader(orgId: string): string {\n  return getServiceAuthHeader({ serviceName: process.env.SERVICE_NAME || 'api', orgId, role: 'member' });\n}\n\n/**\n * Result of a synchronous quota reservation  the atomic check+increment\n * variant. `exceeded: true` means the operation was rejected at the DB\n * level; the caller should return 429 without running the gated action.\n */\nexport interface QuotaReserveResult {\n  /** True when the slot was NOT reserved — the gated action must not run. */\n  exceeded: boolean;\n  /**\n   * Set (true) by the quota CLIENT when the reservation was denied because the\n   * quota service could not CONFIRM it (unreachable / timeout / circuit open /\n   * errored) — not because the org is over its limit. Always paired with\n   * `exceeded: true`. Answer with {@link sendQuotaReserveDenied}, which maps it to\n   * 503 instead of a misleading 429 \"quota exceeded\".\n   */\n  unavailable?: boolean;\n  quota: {\n    type: QuotaType;\n    limit: number;\n    used: number;\n    remaining: number;\n    resetAt?: string;\n  };\n}\n\n/**\n * Quota service client interface.\n */\nexport interface QuotaService {\n  /** Check if quota is available (fail-open on error). */\n  check(orgId: string, quotaType: QuotaType, authHeader: string, requestId?: string): Promise<QuotaCheckResult>;\n  /** Increment quota usage. Returns a promise so callers can optionally handle errors. */\n  increment(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, requestId?: string): Promise<void>;\n  /**\n   * Atomic reserve  the same atomic check+increment as `increment`, but\n   * parses the response so callers can see whether the slot was actually\n   * reserved. Use this for expensive resources where the post-hoc fire-\n   * and-forget pattern allows concurrent over-spend.\n   *\n   * Fails CLOSED (`exceeded: true`) whenever the slot is not confirmed —\n   * unreachable, timeout, open circuit, non-ok, or a non-quota 429 — unless\n   * `QUOTA_RESERVE_FAIL_OPEN=true` (see the policy note at the top of this file).\n   */\n  reserve(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, requestId?: string): Promise<QuotaReserveResult>;\n  /**\n   * Roll back a previously reserved slot. Fire-and-forget — never throws.\n   * Pass `resetAtSnapshot` (the `quota.resetAt` observed when the slot was\n   * reserved) to make the rollback conditional: if the period rolled over\n   * between reserve and rollback, the server skips the decrement so it doesn't\n   * steal capacity from the new period.\n   */\n  decrement(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, resetAtSnapshot?: string, requestId?: string): Promise<void>;\n  /**\n   * Get the org's quota `QuotaTier`. Used by the plugin-build queue partitioning\n   * to route a build to the right per-tier queue. Fail-open returns `DEFAULT_TIER`\n   * (`developer` when billing is enabled, `unlimited` when it's disabled); a\n   * misclassified org still builds on the default queue, just without the\n   * tier-scoped scheduling boost.\n   */\n  getTier(orgId: string, authHeader: string, requestId?: string): Promise<QuotaTier>;\n  /**\n   * FAIL-CLOSED twin of {@link getTier}: the org's tier as the quota service\n   * CONFIRMED it, or `null` when it could not be confirmed (unreachable, non-ok,\n   * missing or unrecognized tier). For decisions that must never be taken on a\n   * guess — anything that revokes, downgrades or deletes on the strength of a\n   * tier (e.g. a verified-publisher grace sweep) must skip the org on `null`,\n   * never act on `DEFAULT_TIER`.\n   */\n  getTierStrict(orgId: string, authHeader: string, requestId?: string): Promise<QuotaTier | null>;\n}\n\n/**\n * Configuration for quota service client.\n */\nexport interface QuotaServiceConfig {\n  /** Quota service host (default: env QUOTA_SERVICE_HOST or 'quota') */\n  host?: string;\n  /** Quota service port (default: env QUOTA_SERVICE_PORT or 3000) */\n  port?: number;\n  /** Request timeout in milliseconds (default: 5000) */\n  timeout?: number;\n}\n\n/**\n * Apply the explicit reserve fail-mode policy to a reservation the quota service\n * did NOT confirm (see QUOTA_RESERVE_FAIL_OPEN above). Default: deny.\n */\nfunction unconfirmedReserve(\n  orgId: string,\n  quotaType: QuotaType,\n  reason: 'unreachable' | 'transient-429' | 'non-ok',\n  statusCode?: number,\n): QuotaReserveResult {\n  if (QUOTA_RESERVE_FAIL_OPEN) {\n    logger.warn('QUOTA_FAIL_OPEN: quota reserve not confirmed, allowing request', { orgId, quotaType, reason, statusCode });\n    emitCounter('quota_fail_open_total', { operation: 'reserve', reason, quotaType });\n    return { exceeded: false, quota: { type: quotaType, limit: -1, used: 0, remaining: -1 } };\n  }\n  logger.warn('QUOTA_FAIL_CLOSED: quota reserve not confirmed, denying request', { orgId, quotaType, reason, statusCode });\n  emitCounter('quota_fail_closed_total', { operation: 'reserve', reason, quotaType });\n  return { exceeded: true, unavailable: true, quota: { type: quotaType, limit: 0, used: 0, remaining: 0 } };\n}\n\n/**\n * Create a fail-open quota result (allows the request).\n */\nfunction createFailOpenResult(): QuotaCheckResult {\n  return {\n    allowed: true,\n    limit: -1,\n    used: 0,\n    remaining: -1,\n    resetAt: new Date().toISOString(),\n    unlimited: true,\n    // Tag the sentinel so fail-closed callers can tell an outage apart from a\n    // real unlimited (-1) reading. Real quota results never set this.\n    failOpen: true,\n  };\n}\n\n/**\n * Build common request headers with optional request ID for distributed tracing.\n */\nfunction buildHeaders(orgId: string, authHeader?: string, requestId?: string): Record<string, string> {\n  const headers: Record<string, string> = { 'x-org-id': orgId };\n  if (authHeader) headers.Authorization = authHeader;\n  if (requestId) headers['X-Request-Id'] = requestId;\n  return headers;\n}\n\n/**\n * Create a quota service client.\n *\n * @param config - Optional service configuration\n * @returns Quota service client\n *\n * @example\n * ```typescript\n * const quotaService = createQuotaService();\n *\n * // Check quota before processing\n * const quota = await quotaService.check(orgId, 'apiCalls', authHeader);\n * if (!quota.allowed) {\n * return res.status(429).json({ error: 'Quota exceeded' });\n * }\n *\n * // Increment quota after success\n * quotaService.increment(orgId, 'apiCalls', authHeader).catch(err => logger.warn('Quota increment failed', { error: err }));\n * ```\n */\nexport function createQuotaService(config: QuotaServiceConfig = {}): QuotaService {\n  const serviceConfig: ServiceConfig = {\n    host: config.host ?? serviceEndpoint('quota').host,\n    port: config.port ?? serviceEndpoint('quota').port,\n    timeout: config.timeout ?? 5000,\n  };\n\n  const client = createSafeClient(serviceConfig);\n\n  /** One tier read: the confirmed tier, or why there isn't one. */\n  async function readTier(\n    orgId: string, authHeader: string, requestId?: string,\n  ): Promise<{ tier: QuotaTier; reason?: undefined; statusCode?: number } | { tier: null; reason: 'unreachable' | 'non-ok' | 'invalid-tier'; statusCode?: number }> {\n    const response = await client.get<{\n      success: boolean;\n      data?: { quota?: { tier?: string } };\n      message?: string;\n    }>(`/quotas/${encodeURIComponent(orgId)}`, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n    if (!response) return { tier: null, reason: 'unreachable' };\n    if (response.statusCode !== 200 || !response.body?.success) return { tier: null, reason: 'non-ok', statusCode: response.statusCode };\n    const tier = response.body.data?.quota?.tier;\n    if (!tier || !isValidTier(tier)) return { tier: null, reason: 'invalid-tier', statusCode: response.statusCode };\n    return { tier, statusCode: response.statusCode };\n  }\n\n  return {\n    async check(orgId: string, quotaType: QuotaType, authHeader: string, requestId?: string): Promise<QuotaCheckResult> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/${encodeURIComponent(quotaType)}`;\n\n      const response = await client.get<{\n        success: boolean;\n        data?: { quotaType: string; status: QuotaCheckResult };\n        message?: string;\n      }>(path, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response) {\n        logger.warn('QUOTA_FAIL_OPEN: Quota service unreachable, allowing request', { orgId, quotaType });\n        emitCounter('quota_fail_open_total', { operation: 'check', reason: 'unreachable', quotaType });\n        return createFailOpenResult();\n      }\n\n      if (response.statusCode !== 200 || !response.body.success || !response.body.data?.status) {\n        logger.warn('QUOTA_FAIL_OPEN: Quota check returned non-ok, allowing request', {\n          orgId, quotaType, statusCode: response.statusCode, message: response.body.message,\n        });\n        emitCounter('quota_fail_open_total', { operation: 'check', reason: 'non-ok', quotaType });\n        return createFailOpenResult();\n      }\n\n      return response.body.data.status;\n    },\n\n    async increment(orgId: string, quotaType: QuotaType, authHeader: string, amount: number = 1, requestId?: string): Promise<void> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/increment`;\n\n      const response = await client\n        .post(path, { quotaType, amount }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response || response.statusCode !== 200) {\n        logger.warn('Failed to increment quota', {\n          orgId, quotaType, amount, statusCode: response?.statusCode,\n        });\n      } else {\n        logger.debug('Quota incremented', { orgId, quotaType, amount });\n      }\n    },\n\n    async reserve(orgId: string, quotaType: QuotaType, authHeader: string, amount: number = 1, requestId?: string): Promise<QuotaReserveResult> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/increment`;\n\n      // 200 carries `data.quota`; 429 (QUOTA_EXCEEDED) carries `details.quota`.\n      // Both shapes are normalized into QuotaReserveResult.\n      const response = await client.post<{\n        success: boolean;\n        data?: { quota?: QuotaReserveResult['quota'] };\n        details?: { quota?: QuotaReserveResult['quota'] };\n        /** `sendError`'s error-code field. */\n        code?: string;\n      }>(path, { quotaType, amount }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response) return unconfirmedReserve(orgId, quotaType, 'unreachable');\n\n      if (response.statusCode === 429) {\n        const q = response.body.details?.quota;\n        // Only a GENUINE quota-exceeded 429 means \"over quota\". A generic 429 —\n        // an intervening gateway or rate limiter — did not confirm anything, so\n        // it goes through the same unconfirmed-reservation policy as an outage.\n        if (response.body.code === ErrorCode.QUOTA_EXCEEDED || q) {\n          return {\n            exceeded: true,\n            quota: q ?? { type: quotaType, limit: 0, used: 0, remaining: 0 },\n          };\n        }\n        return unconfirmedReserve(orgId, quotaType, 'transient-429', response.statusCode);\n      }\n\n      if (response.statusCode !== 200 || !response.body.success) {\n        return unconfirmedReserve(orgId, quotaType, 'non-ok', response.statusCode);\n      }\n\n      const q = response.body.data?.quota;\n      return {\n        exceeded: false,\n        quota: q ?? { type: quotaType, limit: -1, used: 0, remaining: -1 },\n      };\n    },\n\n    async decrement(orgId: string, quotaType: QuotaType, authHeader: string, amount: number = 1, resetAtSnapshot?: string, requestId?: string): Promise<void> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/decrement`;\n      const response = await client\n        .post(path, { quotaType, amount, ...(resetAtSnapshot && { resetAtSnapshot }) }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response || response.statusCode !== 200) {\n        // Rollback failure is logged but never propagated  the action's own\n        // failure has already been surfaced to the caller; a stuck counter\n        // resolves on the next period reset.\n        logger.warn('Failed to decrement quota (slot will reset on next period)', {\n          orgId, quotaType, amount, statusCode: response?.statusCode,\n        });\n      } else {\n        logger.debug('Quota decremented', { orgId, quotaType, amount });\n      }\n    },\n\n    async getTier(orgId: string, authHeader: string, requestId?: string): Promise<QuotaTier> {\n      const read = await readTier(orgId, authHeader, requestId);\n      if (read.tier) return read.tier;\n      logger.warn(`QUOTA_FAIL_OPEN: tier lookup failed, defaulting to ${DEFAULT_TIER} tier`, {\n        orgId, statusCode: read.statusCode, reason: read.reason, defaultTier: DEFAULT_TIER,\n      });\n      emitCounter('quota_fail_open_total', { operation: 'tier', reason: read.reason, quotaType: 'tier' });\n      return DEFAULT_TIER;\n    },\n\n    async getTierStrict(orgId: string, authHeader: string, requestId?: string): Promise<QuotaTier | null> {\n      const read = await readTier(orgId, authHeader, requestId);\n      if (read.tier) return read.tier;\n      logger.warn('QUOTA_FAIL_CLOSED: tier could not be confirmed', { orgId, statusCode: read.statusCode, reason: read.reason });\n      emitCounter('quota_fail_closed_total', { operation: 'tier', reason: read.reason, quotaType: 'tier' });\n      return null;\n    },\n  };\n}\n\n/**\n * Fire-and-forget quota METERING increment with standardized error logging.\n *\n * Authenticates as the calling SERVICE ({@link getQuotaServiceAuthHeader}), never\n * with the end user's token: `/quotas/:orgId/increment` is service-principal /\n * system-admin only, so a forwarded user JWT was always rejected (403) and the\n * metered quota (e.g. `apiCalls`, and the `api_pack` bundle raising it) never\n * moved.\n *\n * @param quotaService - Quota service client\n * @param orgId - Organization ID whose counter is incremented\n * @param quotaType - Quota type to increment\n * @param logWarn - Logging function for warnings\n */\nexport function incrementQuota( quotaService: QuotaService,\n  orgId: string,\n  quotaType: QuotaType,\n  logWarn: (message: string, data?: unknown) => void,\n): void {\n  quotaService.increment(orgId, quotaType, getQuotaServiceAuthHeader(orgId)).catch((err: unknown) =>\n    logWarn('Quota increment failed', { error: errorMessage(err) }),\n  );\n}\n\n/**\n * Atomic reserve helper for the \"reserve + commit / rollback\" pattern.\n * Use for expensive resources (pipelines, plugins, AI calls) where the\n * fire-and-forget post-hoc `incrementQuota` allows concurrent over-spend.\n *\n * Returns the structured result so the caller can decide whether to run\n * the gated action or 429 the client.\n *\n * @example\n * ```typescript\n * const reservation = await reserveQuota(quotaService, orgId, 'pipelines', authHeader);\n * if (reservation.exceeded) return sendQuotaReserveDenied(res, 'pipelines', reservation);\n * try {\n * await doExpensiveThing();\n * } catch (err) {\n * // Pass the reserved resetAt so a period rollover doesn't get double-charged.\n * decrementQuota(quotaService, orgId, 'pipelines', authHeader, logWarn, 1, reservation.quota.resetAt);\n * throw err;\n * }\n * ```\n */\nexport function reserveQuota( quotaService: QuotaService,\n  orgId: string,\n  quotaType: QuotaType,\n  authHeader: string,\n  amount: number = 1,\n  requestId?: string,\n): Promise<QuotaReserveResult> {\n  return quotaService.reserve(orgId, quotaType, authHeader, amount, requestId);\n}\n\n/** Seconds a client should wait before retrying when quota couldn't be confirmed. */\nconst QUOTA_UNAVAILABLE_RETRY_AFTER_SECONDS = 5;\n\n/**\n * Answer a DENIED reservation (`reservation.exceeded === true`).\n *\n * - `unavailable` (the quota service couldn't confirm the slot) → **503**\n *   `SERVICE_UNAVAILABLE` with a short `Retry-After`: the org is not over its\n *   limit, so a 429 \"quota exceeded\" would send users to upgrade for an outage.\n * - otherwise → the standard 429 `QUOTA_EXCEEDED` with the X-Quota-* headers.\n */\nexport function sendQuotaReserveDenied(res: Response, quotaType: QuotaType, reservation: QuotaReserveResult): void {\n  if (reservation.unavailable) {\n    if (!res.headersSent) res.setHeader('Retry-After', QUOTA_UNAVAILABLE_RETRY_AFTER_SECONDS);\n    sendError(\n      res,\n      503,\n      `Unable to confirm ${quotaType} quota right now. Please try again shortly.`,\n      ErrorCode.SERVICE_UNAVAILABLE,\n    );\n    return;\n  }\n  sendQuotaExceeded(res, quotaType, reservation.quota, reservation.quota.resetAt);\n}\n\n/**\n * Fire-and-forget rollback for a previously reserved quota slot.\n * Logs on failure but never throws  the action that needed the rollback\n * has already failed, no point compounding the error.\n */\nexport function decrementQuota( quotaService: QuotaService,\n  orgId: string,\n  quotaType: QuotaType,\n  authHeader: string,\n  logWarn: (message: string, data?: unknown) => void,\n  amount: number = 1,\n  resetAtSnapshot?: string,\n): void {\n  quotaService.decrement(orgId, quotaType, authHeader, amount, resetAtSnapshot).catch((err: unknown) =>\n    logWarn('Quota rollback failed', { error: errorMessage(err) }),\n  );\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quota.js","sourceRoot":"","sources":["../../src/services/quota.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAItC,OAAO,EAAE,gBAAgB,EAAuB,MAAM,kBAAkB,CAAC;AACzE,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAEvE,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAkB,MAAM,yBAAyB,CAAC;AACpF,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAClF,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAE/D;;;;;;;;GAQG;AACH,MAAM,qBAAqB,GAA+D;IACxF,mBAAmB,EAAE,CAAC;IACtB,UAAU,EAAE,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;AAErC,+CAA+C;AAC/C,EAAE;AACF,8EAA8E;AAC9E,gFAAgF;AAChF,+EAA+E;AAC/E,4EAA4E;AAC5E,yEAAyE;AACzE,gFAAgF;AAChF,iFAAiF;AACjF,oEAAoE;AACpE,mEAAmE;AACnE,2EAA2E;AAC3E,4EAA4E;AAC5E,4EAA4E;AAC5E,gFAAgF;AAChF,+EAA+E;AAC/E,MAAM,uBAAuB,GAAG,OAAO,CAAC,yBAAyB,EAAE,KAAK,CAAC,CAAC;AAE1E;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,yBAAyB,CAAC,KAAa;IACrD,OAAO,oBAAoB,CAAC,EAAE,WAAW,EAAE,OAAO,CAAC,GAAG,CAAC,YAAY,IAAI,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;AACzG,CAAC;AAqFD;;;GAGG;AACH,SAAS,kBAAkB,CACzB,KAAa,EACb,SAAoB,EACpB,MAAkD,EAClD,UAAmB;IAEnB,IAAI,uBAAuB,EAAE,CAAC;QAC5B,MAAM,CAAC,IAAI,CAAC,gEAAgE,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC;QACxH,WAAW,CAAC,uBAAuB,EAAE,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;QAClF,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC;IAC5F,CAAC;IACD,MAAM,CAAC,IAAI,CAAC,iEAAiE,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC;IACzH,WAAW,CAAC,yBAAyB,EAAE,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;IACpF,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC;AAC5G,CAAC;AAED;;GAEG;AACH,SAAS,oBAAoB;IAC3B,OAAO;QACL,OAAO,EAAE,IAAI;QACb,KAAK,EAAE,CAAC,CAAC;QACT,IAAI,EAAE,CAAC;QACP,SAAS,EAAE,CAAC,CAAC;QACb,OAAO,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QACjC,SAAS,EAAE,IAAI;QACf,0EAA0E;QAC1E,kEAAkE;QAClE,QAAQ,EAAE,IAAI;KACf,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAS,YAAY,CAAC,KAAa,EAAE,UAAmB,EAAE,SAAkB;IAC1E,MAAM,OAAO,GAA2B,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC;IAC9D,IAAI,UAAU;QAAE,OAAO,CAAC,aAAa,GAAG,UAAU,CAAC;IACnD,IAAI,SAAS;QAAE,OAAO,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IACnD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAM,GAAuB,EAAE;IAChE,MAAM,aAAa,GAAkB;QACnC,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,eAAe,CAAC,OAAO,CAAC,CAAC,IAAI;QAClD,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,eAAe,CAAC,OAAO,CAAC,CAAC,IAAI;QAClD,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,IAAI;KAChC,CAAC;IAEF,MAAM,MAAM,GAAG,gBAAgB,CAAC,aAAa,CAAC,CAAC;IAE/C,iEAAiE;IACjE,KAAK,UAAU,QAAQ,CACrB,KAAa,EAAE,UAAkB,EAAE,SAAkB;QAErD,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,GAAG,CAI9B,WAAW,kBAAkB,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,OAAO,EAAE,YAAY,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,GAAG,qBAAqB,EAAE,CAAC,CAAC;QAC9H,IAAI,CAAC,QAAQ;YAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,CAAC;QAC5D,IAAI,QAAQ,CAAC,UAAU,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,OAAO;YAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,CAAC,UAAU,EAAE,CAAC;QACrI,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC;QAC7C,IAAI,CAAC,IAAI,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;YAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,UAAU,EAAE,QAAQ,CAAC,UAAU,EAAE,CAAC;QAChH,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,QAAQ,CAAC,UAAU,EAAE,CAAC;IACnD,CAAC;IAED,OAAO;QACL,KAAK,CAAC,KAAK,CAAC,KAAa,EAAE,SAAoB,EAAE,UAAkB,EAAE,SAAkB;YACrF,MAAM,IAAI,GAAG,WAAW,kBAAkB,CAAC,KAAK,CAAC,IAAI,kBAAkB,CAAC,SAAS,CAAC,EAAE,CAAC;YAErF,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,GAAG,CAI9B,IAAI,EAAE,EAAE,OAAO,EAAE,YAAY,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,GAAG,qBAAqB,EAAE,CAAC,CAAC;YAE5F,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,MAAM,CAAC,IAAI,CAAC,8DAA8D,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;gBAClG,WAAW,CAAC,uBAAuB,EAAE,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE,CAAC,CAAC;gBAC/F,OAAO,oBAAoB,EAAE,CAAC;YAChC,CAAC;YAED,IAAI,QAAQ,CAAC,UAAU,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC;gBACzF,MAAM,CAAC,IAAI,CAAC,gEAAgE,EAAE;oBAC5E,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,CAAC,IAAI,CAAC,OAAO;iBAClF,CAAC,CAAC;gBACH,WAAW,CAAC,uBAAuB,EAAE,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC;gBAC1F,OAAO,oBAAoB,EAAE,CAAC;YAChC,CAAC;YAED,OAAO,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;QACnC,CAAC;QAED,KAAK,CAAC,SAAS,CAAC,KAAa,EAAE,SAAoB,EAAE,UAAkB,EAAE,MAAM,GAAW,CAAC,EAAE,SAAkB;YAC7G,MAAM,IAAI,GAAG,WAAW,kBAAkB,CAAC,KAAK,CAAC,YAAY,CAAC;YAE9D,MAAM,QAAQ,GAAG,MAAM,MAAM;iBAC1B,IAAI,CAAC,IAAI,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,EAAE,YAAY,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,GAAG,qBAAqB,EAAE,CAAC,CAAC;YAExH,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,UAAU,KAAK,GAAG,EAAE,CAAC;gBAC7C,MAAM,CAAC,IAAI,CAAC,2BAA2B,EAAE;oBACvC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU;iBAC3D,CAAC,CAAC;YACL,CAAC;iBAAM,CAAC;gBACN,MAAM,CAAC,KAAK,CAAC,mBAAmB,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,CAAC;YAClE,CAAC;QACH,CAAC;QAED,KAAK,CAAC,OAAO,CAAC,KAAa,EAAE,SAAoB,EAAE,UAAkB,EAAE,MAAM,GAAW,CAAC,EAAE,SAAkB;YAC3G,MAAM,IAAI,GAAG,WAAW,kBAAkB,CAAC,KAAK,CAAC,YAAY,CAAC;YAE9D,0EAA0E;YAC1E,sDAAsD;YACtD,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,IAAI,CAM/B,IAAI,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,EAAE,YAAY,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,GAAG,qBAAqB,EAAE,CAAC,CAAC;YAEnH,IAAI,CAAC,QAAQ;gBAAE,OAAO,kBAAkB,CAAC,KAAK,EAAE,SAAS,EAAE,aAAa,CAAC,CAAC;YAE1E,IAAI,QAAQ,CAAC,UAAU,KAAK,GAAG,EAAE,CAAC;gBAChC,MAAM,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC;gBACvC,wEAAwE;gBACxE,wEAAwE;gBACxE,wEAAwE;gBACxE,IAAI,QAAQ,CAAC,IAAI,CAAC,IAAI,KAAK,SAAS,CAAC,cAAc,IAAI,CAAC,EAAE,CAAC;oBACzD,OAAO;wBACL,QAAQ,EAAE,IAAI;wBACd,KAAK,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE;qBACjE,CAAC;gBACJ,CAAC;gBACD,OAAO,kBAAkB,CAAC,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC;YACpF,CAAC;YAED,IAAI,QAAQ,CAAC,UAAU,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;gBAC1D,OAAO,kBAAkB,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC;YAC7E,CAAC;YAED,MAAM,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC;YACpC,OAAO;gBACL,QAAQ,EAAE,KAAK;gBACf,KAAK,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE;aACnE,CAAC;QACJ,CAAC;QAED,KAAK,CAAC,SAAS,CAAC,KAAa,EAAE,SAAoB,EAAE,UAAkB,EAAE,MAAM,GAAW,CAAC,EAAE,eAAwB,EAAE,SAAkB;YACvI,MAAM,IAAI,GAAG,WAAW,kBAAkB,CAAC,KAAK,CAAC,YAAY,CAAC;YAC9D,MAAM,QAAQ,GAAG,MAAM,MAAM;iBAC1B,IAAI,CAAC,IAAI,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,CAAC,eAAe,IAAI,EAAE,eAAe,EAAE,CAAC,EAAE,EAAE,EAAE,OAAO,EAAE,YAAY,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,GAAG,qBAAqB,EAAE,CAAC,CAAC;YAErK,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,UAAU,KAAK,GAAG,EAAE,CAAC;gBAC7C,oEAAoE;gBACpE,mEAAmE;gBACnE,qCAAqC;gBACrC,MAAM,CAAC,IAAI,CAAC,4DAA4D,EAAE;oBACxE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU;iBAC3D,CAAC,CAAC;YACL,CAAC;iBAAM,CAAC;gBACN,MAAM,CAAC,KAAK,CAAC,mBAAmB,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,CAAC;YAClE,CAAC;QACH,CAAC;QAED,KAAK,CAAC,OAAO,CAAC,KAAa,EAAE,UAAkB,EAAE,SAAkB;YACjE,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;YAC1D,IAAI,IAAI,CAAC,IAAI;gBAAE,OAAO,IAAI,CAAC,IAAI,CAAC;YAChC,MAAM,CAAC,IAAI,CAAC,sDAAsD,YAAY,OAAO,EAAE;gBACrF,KAAK,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,WAAW,EAAE,YAAY;aACnF,CAAC,CAAC;YACH,WAAW,CAAC,uBAAuB,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,CAAC;YACpG,OAAO,YAAY,CAAC;QACtB,CAAC;QAED,KAAK,CAAC,aAAa,CAAC,KAAa,EAAE,UAAkB,EAAE,SAAkB;YACvE,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;YAC1D,IAAI,IAAI,CAAC,IAAI;gBAAE,OAAO,IAAI,CAAC,IAAI,CAAC;YAChC,MAAM,CAAC,IAAI,CAAC,gDAAgD,EAAE,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;YAC3H,WAAW,CAAC,yBAAyB,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,CAAC;YACtG,OAAO,IAAI,CAAC;QACd,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,cAAc,CAAE,YAA0B,EACxD,KAAa,EACb,SAAoB,EACpB,OAAkD;IAElD,YAAY,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,yBAAyB,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAY,EAAE,EAAE,CAChG,OAAO,CAAC,wBAAwB,EAAE,EAAE,KAAK,EAAE,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC,CAChE,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,YAAY,CAAE,YAA0B,EACtD,KAAa,EACb,SAAoB,EACpB,UAAkB,EAClB,MAAM,GAAW,CAAC,EAClB,SAAkB;IAElB,OAAO,YAAY,CAAC,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;AAC/E,CAAC;AAED,qFAAqF;AACrF,MAAM,qCAAqC,GAAG,CAAC,CAAC;AAEhD;;;;;;;GAOG;AACH,MAAM,UAAU,sBAAsB,CAAC,GAAa,EAAE,SAAoB,EAAE,WAA+B;IACzG,IAAI,WAAW,CAAC,WAAW,EAAE,CAAC;QAC5B,IAAI,CAAC,GAAG,CAAC,WAAW;YAAE,GAAG,CAAC,SAAS,CAAC,aAAa,EAAE,qCAAqC,CAAC,CAAC;QAC1F,SAAS,CACP,GAAG,EACH,GAAG,EACH,qBAAqB,SAAS,6CAA6C,EAC3E,SAAS,CAAC,mBAAmB,CAC9B,CAAC;QACF,OAAO;IACT,CAAC;IACD,iBAAiB,CAAC,GAAG,EAAE,SAAS,EAAE,WAAW,CAAC,KAAK,EAAE,WAAW,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;AAClF,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAE,YAA0B,EACxD,KAAa,EACb,SAAoB,EACpB,UAAkB,EAClB,OAAkD,EAClD,MAAM,GAAW,CAAC,EAClB,eAAwB;IAExB,YAAY,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,eAAe,CAAC,CAAC,KAAK,CAAC,CAAC,GAAY,EAAE,EAAE,CACnG,OAAO,CAAC,uBAAuB,EAAE,EAAE,KAAK,EAAE,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC,CAC/D,CAAC;AACJ,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Response } from 'express';\n\nimport { createSafeClient, type RequestOptions } from './http-client.js';\nimport { getServiceAuthHeader } from '../middleware/service-tokens.js';\nimport type { QuotaType, QuotaCheckResult, ServiceConfig } from '../types/common.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { DEFAULT_TIER, isValidTier, type QuotaTier } from '../types/quota-tiers.js';\nimport { envBool } from '../utils/env.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { errorMessage, sendError, sendQuotaExceeded } from '../utils/response.js';\nimport { serviceEndpoint } from '../utils/service-registry.js';\n\n/**\n * Retry options for quota calls — fail fast (a slow quota service must not stall the request).\n *\n * NEVER retry a 429. The quota service answers an over-limit org with 429\n * QUOTA_EXCEEDED and `Retry-After` = seconds until the period resets; the HTTP\n * client honors that (capped at 60s), so a single rate-limit retry stalled the\n * request well past the handler timeout, which then answered 503 and the real\n * 429 was lost. A 429 is a final answer here.\n */\nconst QUOTA_REQUEST_OPTIONS: Pick<RequestOptions, 'maxRateLimitRetries' | 'maxRetries'> = {\n  maxRateLimitRetries: 0,\n  maxRetries: 1,\n};\n\nconst logger = createLogger('quota');\n\n// RESERVE FAIL MODE — explicit, single policy.\n//\n// `reserve` gates EXPENSIVE, billable resources (pipelines, plugin builds, AI\n// calls, platform feature slots). Every quota type is a per-period FLOW counter\n// with no after-the-fact reconciliation: a unit consumed while the reservation\n// could not be confirmed is never counted, so fail-open lets an org consume\n// unbounded unmetered units for the whole length of an incident — and an\n// unconfirmed reserve (timeout, open circuit) may even have landed server-side.\n// So `reserve` fails CLOSED whenever the quota service did not CONFIRM the slot:\n//   - unreachable / timed out / circuit breaker open (no response),\n//   - a reachable-but-errored response (5xx, 4xx, malformed body),\n//   - a 429 that is NOT a genuine QUOTA_EXCEEDED (gateway / rate limiter).\n// Operators who prefer availability over enforcement opt the WHOLE set into\n// fail-open with QUOTA_RESERVE_FAIL_OPEN=true. Both outcomes emit a counter\n// (`quota_fail_closed_total` / `quota_fail_open_total`) tagged with the reason.\n// `check` (a cheap read gate) stays fail-open; `increment` is fire-and-forget.\nconst QUOTA_RESERVE_FAIL_OPEN = envBool('QUOTA_RESERVE_FAIL_OPEN', false);\n\n/**\n * Service-principal `Authorization` header for a quota call made on behalf of\n * `orgId` by the CURRENT service (`SERVICE_NAME`, the same identity the health\n * router reports).\n *\n * The quota service's mutation endpoints (`/:orgId/increment`, `/decrement`)\n * reject anything but a signed service principal or a system admin, so\n * forwarding the end user's bearer token there is always a 403. Service tokens\n * are also exempt from the quota service's per-IP rate limiter, so hot-path\n * quota traffic from a busy pod can't exhaust that pod IP's bucket and silently\n * turn enforcement off. Scoped to the target org with the lowest role (member).\n */\nexport function getQuotaServiceAuthHeader(orgId: string): string {\n  return getServiceAuthHeader({ serviceName: process.env.SERVICE_NAME || 'api', orgId, role: 'member' });\n}\n\n/**\n * Result of a synchronous quota reservation  the atomic check+increment\n * variant. `exceeded: true` means the operation was rejected at the DB\n * level; the caller should return 429 without running the gated action.\n */\nexport interface QuotaReserveResult {\n  /** True when the slot was NOT reserved — the gated action must not run. */\n  exceeded: boolean;\n  /**\n   * Set (true) by the quota CLIENT when the reservation was denied because the\n   * quota service could not CONFIRM it (unreachable / timeout / circuit open /\n   * errored) — not because the org is over its limit. Always paired with\n   * `exceeded: true`. Answer with {@link sendQuotaReserveDenied}, which maps it to\n   * 503 instead of a misleading 429 \"quota exceeded\".\n   */\n  unavailable?: boolean;\n  quota: {\n    type: QuotaType;\n    limit: number;\n    used: number;\n    remaining: number;\n    resetAt?: string;\n  };\n}\n\n/**\n * Quota service client interface.\n */\nexport interface QuotaService {\n  /** Check if quota is available (fail-open on error). */\n  check(orgId: string, quotaType: QuotaType, authHeader: string, requestId?: string): Promise<QuotaCheckResult>;\n  /** Increment quota usage. Returns a promise so callers can optionally handle errors. */\n  increment(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, requestId?: string): Promise<void>;\n  /**\n   * Atomic reserve  the same atomic check+increment as `increment`, but\n   * parses the response so callers can see whether the slot was actually\n   * reserved. Use this for expensive resources where the post-hoc fire-\n   * and-forget pattern allows concurrent over-spend.\n   *\n   * Fails CLOSED (`exceeded: true`) whenever the slot is not confirmed —\n   * unreachable, timeout, open circuit, non-ok, or a non-quota 429 — unless\n   * `QUOTA_RESERVE_FAIL_OPEN=true` (see the policy note at the top of this file).\n   */\n  reserve(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, requestId?: string): Promise<QuotaReserveResult>;\n  /**\n   * Roll back a previously reserved slot. Fire-and-forget — never throws.\n   * Pass `resetAtSnapshot` (the `quota.resetAt` observed when the slot was\n   * reserved) to make the rollback conditional: if the period rolled over\n   * between reserve and rollback, the server skips the decrement so it doesn't\n   * steal capacity from the new period.\n   */\n  decrement(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, resetAtSnapshot?: string, requestId?: string): Promise<void>;\n  /**\n   * Get the org's quota `QuotaTier`. Used by the plugin-build queue partitioning\n   * to route a build to the right per-tier queue. Fail-open returns `DEFAULT_TIER`\n   * (`developer` when billing is enabled, `unlimited` when it's disabled); a\n   * misclassified org still builds on the default queue, just without the\n   * tier-scoped scheduling boost.\n   */\n  getTier(orgId: string, authHeader: string, requestId?: string): Promise<QuotaTier>;\n  /**\n   * FAIL-CLOSED twin of {@link getTier}: the org's tier as the quota service\n   * CONFIRMED it, or `null` when it could not be confirmed (unreachable, non-ok,\n   * missing or unrecognized tier). For decisions that must never be taken on a\n   * guess — anything that revokes, downgrades or deletes on the strength of a\n   * tier (e.g. a verified-publisher grace sweep) must skip the org on `null`,\n   * never act on `DEFAULT_TIER`.\n   */\n  getTierStrict(orgId: string, authHeader: string, requestId?: string): Promise<QuotaTier | null>;\n}\n\n/**\n * Configuration for quota service client.\n */\nexport interface QuotaServiceConfig {\n  /** Quota service host (default: env QUOTA_SERVICE_HOST or 'quota') */\n  host?: string;\n  /** Quota service port (default: env QUOTA_SERVICE_PORT or 3000) */\n  port?: number;\n  /** Request timeout in milliseconds (default: 5000) */\n  timeout?: number;\n}\n\n/**\n * Apply the explicit reserve fail-mode policy to a reservation the quota service\n * did NOT confirm (see QUOTA_RESERVE_FAIL_OPEN above). Default: deny.\n */\nfunction unconfirmedReserve(\n  orgId: string,\n  quotaType: QuotaType,\n  reason: 'unreachable' | 'transient-429' | 'non-ok',\n  statusCode?: number,\n): QuotaReserveResult {\n  if (QUOTA_RESERVE_FAIL_OPEN) {\n    logger.warn('QUOTA_FAIL_OPEN: quota reserve not confirmed, allowing request', { orgId, quotaType, reason, statusCode });\n    emitCounter('quota_fail_open_total', { operation: 'reserve', reason, quotaType });\n    return { exceeded: false, quota: { type: quotaType, limit: -1, used: 0, remaining: -1 } };\n  }\n  logger.warn('QUOTA_FAIL_CLOSED: quota reserve not confirmed, denying request', { orgId, quotaType, reason, statusCode });\n  emitCounter('quota_fail_closed_total', { operation: 'reserve', reason, quotaType });\n  return { exceeded: true, unavailable: true, quota: { type: quotaType, limit: 0, used: 0, remaining: 0 } };\n}\n\n/**\n * Create a fail-open quota result (allows the request).\n */\nfunction createFailOpenResult(): QuotaCheckResult {\n  return {\n    allowed: true,\n    limit: -1,\n    used: 0,\n    remaining: -1,\n    resetAt: new Date().toISOString(),\n    unlimited: true,\n    // Tag the sentinel so fail-closed callers can tell an outage apart from a\n    // real unlimited (-1) reading. Real quota results never set this.\n    failOpen: true,\n  };\n}\n\n/**\n * Build common request headers with optional request ID for distributed tracing.\n */\nfunction buildHeaders(orgId: string, authHeader?: string, requestId?: string): Record<string, string> {\n  const headers: Record<string, string> = { 'x-org-id': orgId };\n  if (authHeader) headers.Authorization = authHeader;\n  if (requestId) headers['X-Request-Id'] = requestId;\n  return headers;\n}\n\n/**\n * Create a quota service client.\n *\n * @param config - Optional service configuration\n * @returns Quota service client\n *\n * @example\n * ```typescript\n * const quotaService = createQuotaService();\n *\n * // Check quota before processing\n * const quota = await quotaService.check(orgId, 'apiCalls', authHeader);\n * if (!quota.allowed) {\n * return res.status(429).json({ error: 'Quota exceeded' });\n * }\n *\n * // Increment quota after success\n * quotaService.increment(orgId, 'apiCalls', authHeader).catch(err => logger.warn('Quota increment failed', { error: err }));\n * ```\n */\nexport function createQuotaService(config: QuotaServiceConfig = {}): QuotaService {\n  const serviceConfig: ServiceConfig = {\n    host: config.host ?? serviceEndpoint('quota').host,\n    port: config.port ?? serviceEndpoint('quota').port,\n    timeout: config.timeout ?? 5000,\n  };\n\n  const client = createSafeClient(serviceConfig);\n\n  /** One tier read: the confirmed tier, or why there isn't one. */\n  async function readTier(\n    orgId: string, authHeader: string, requestId?: string,\n  ): Promise<{ tier: QuotaTier; reason?: undefined; statusCode?: number } | { tier: null; reason: 'unreachable' | 'non-ok' | 'invalid-tier'; statusCode?: number }> {\n    const response = await client.get<{\n      success: boolean;\n      data?: { quota?: { tier?: string } };\n      message?: string;\n    }>(`/quotas/${encodeURIComponent(orgId)}`, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n    if (!response) return { tier: null, reason: 'unreachable' };\n    if (response.statusCode !== 200 || !response.body?.success) return { tier: null, reason: 'non-ok', statusCode: response.statusCode };\n    const tier = response.body.data?.quota?.tier;\n    if (!tier || !isValidTier(tier)) return { tier: null, reason: 'invalid-tier', statusCode: response.statusCode };\n    return { tier, statusCode: response.statusCode };\n  }\n\n  return {\n    async check(orgId: string, quotaType: QuotaType, authHeader: string, requestId?: string): Promise<QuotaCheckResult> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/${encodeURIComponent(quotaType)}`;\n\n      const response = await client.get<{\n        success: boolean;\n        data?: { quotaType: string; status: QuotaCheckResult };\n        message?: string;\n      }>(path, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response) {\n        logger.warn('QUOTA_FAIL_OPEN: Quota service unreachable, allowing request', { orgId, quotaType });\n        emitCounter('quota_fail_open_total', { operation: 'check', reason: 'unreachable', quotaType });\n        return createFailOpenResult();\n      }\n\n      if (response.statusCode !== 200 || !response.body.success || !response.body.data?.status) {\n        logger.warn('QUOTA_FAIL_OPEN: Quota check returned non-ok, allowing request', {\n          orgId, quotaType, statusCode: response.statusCode, message: response.body.message,\n        });\n        emitCounter('quota_fail_open_total', { operation: 'check', reason: 'non-ok', quotaType });\n        return createFailOpenResult();\n      }\n\n      return response.body.data.status;\n    },\n\n    async increment(orgId: string, quotaType: QuotaType, authHeader: string, amount: number = 1, requestId?: string): Promise<void> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/increment`;\n\n      const response = await client\n        .post(path, { quotaType, amount }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response || response.statusCode !== 200) {\n        logger.warn('Failed to increment quota', {\n          orgId, quotaType, amount, statusCode: response?.statusCode,\n        });\n      } else {\n        logger.debug('Quota incremented', { orgId, quotaType, amount });\n      }\n    },\n\n    async reserve(orgId: string, quotaType: QuotaType, authHeader: string, amount: number = 1, requestId?: string): Promise<QuotaReserveResult> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/increment`;\n\n      // 200 carries `data.quota`; 429 (QUOTA_EXCEEDED) carries `details.quota`.\n      // Both shapes are normalized into QuotaReserveResult.\n      const response = await client.post<{\n        success: boolean;\n        data?: { quota?: QuotaReserveResult['quota'] };\n        details?: { quota?: QuotaReserveResult['quota'] };\n        /** `sendError`'s error-code field. */\n        code?: string;\n      }>(path, { quotaType, amount }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response) return unconfirmedReserve(orgId, quotaType, 'unreachable');\n\n      if (response.statusCode === 429) {\n        const q = response.body.details?.quota;\n        // Only a GENUINE quota-exceeded 429 means \"over quota\". A generic 429 —\n        // an intervening gateway or rate limiter — did not confirm anything, so\n        // it goes through the same unconfirmed-reservation policy as an outage.\n        if (response.body.code === ErrorCode.QUOTA_EXCEEDED || q) {\n          return {\n            exceeded: true,\n            quota: q ?? { type: quotaType, limit: 0, used: 0, remaining: 0 },\n          };\n        }\n        return unconfirmedReserve(orgId, quotaType, 'transient-429', response.statusCode);\n      }\n\n      if (response.statusCode !== 200 || !response.body.success) {\n        return unconfirmedReserve(orgId, quotaType, 'non-ok', response.statusCode);\n      }\n\n      const q = response.body.data?.quota;\n      return {\n        exceeded: false,\n        quota: q ?? { type: quotaType, limit: -1, used: 0, remaining: -1 },\n      };\n    },\n\n    async decrement(orgId: string, quotaType: QuotaType, authHeader: string, amount: number = 1, resetAtSnapshot?: string, requestId?: string): Promise<void> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/decrement`;\n      const response = await client\n        .post(path, { quotaType, amount, ...(resetAtSnapshot && { resetAtSnapshot }) }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response || response.statusCode !== 200) {\n        // Rollback failure is logged but never propagated  the action's own\n        // failure has already been surfaced to the caller; a stuck counter\n        // resolves on the next period reset.\n        logger.warn('Failed to decrement quota (slot will reset on next period)', {\n          orgId, quotaType, amount, statusCode: response?.statusCode,\n        });\n      } else {\n        logger.debug('Quota decremented', { orgId, quotaType, amount });\n      }\n    },\n\n    async getTier(orgId: string, authHeader: string, requestId?: string): Promise<QuotaTier> {\n      const read = await readTier(orgId, authHeader, requestId);\n      if (read.tier) return read.tier;\n      logger.warn(`QUOTA_FAIL_OPEN: tier lookup failed, defaulting to ${DEFAULT_TIER} tier`, {\n        orgId, statusCode: read.statusCode, reason: read.reason, defaultTier: DEFAULT_TIER,\n      });\n      emitCounter('quota_fail_open_total', { operation: 'tier', reason: read.reason, quotaType: 'tier' });\n      return DEFAULT_TIER;\n    },\n\n    async getTierStrict(orgId: string, authHeader: string, requestId?: string): Promise<QuotaTier | null> {\n      const read = await readTier(orgId, authHeader, requestId);\n      if (read.tier) return read.tier;\n      logger.warn('QUOTA_FAIL_CLOSED: tier could not be confirmed', { orgId, statusCode: read.statusCode, reason: read.reason });\n      emitCounter('quota_fail_closed_total', { operation: 'tier', reason: read.reason, quotaType: 'tier' });\n      return null;\n    },\n  };\n}\n\n/**\n * Fire-and-forget quota METERING increment with standardized error logging.\n *\n * Authenticates as the calling SERVICE ({@link getQuotaServiceAuthHeader}), never\n * with the end user's token: `/quotas/:orgId/increment` is service-principal /\n * system-admin only, so a forwarded user JWT was always rejected (403) and the\n * metered quota (e.g. `apiCalls`, and the `api_pack` bundle raising it) never\n * moved.\n *\n * @param quotaService - Quota service client\n * @param orgId - Organization ID whose counter is incremented\n * @param quotaType - Quota type to increment\n * @param logWarn - Logging function for warnings\n */\nexport function incrementQuota( quotaService: QuotaService,\n  orgId: string,\n  quotaType: QuotaType,\n  logWarn: (message: string, data?: unknown) => void,\n): void {\n  quotaService.increment(orgId, quotaType, getQuotaServiceAuthHeader(orgId)).catch((err: unknown) =>\n    logWarn('Quota increment failed', { error: errorMessage(err) }),\n  );\n}\n\n/**\n * Atomic reserve helper for the \"reserve + commit / rollback\" pattern.\n * Use for expensive resources (pipelines, plugins, AI calls) where the\n * fire-and-forget post-hoc `incrementQuota` allows concurrent over-spend.\n *\n * Returns the structured result so the caller can decide whether to run\n * the gated action or 429 the client.\n *\n * @example\n * ```typescript\n * const reservation = await reserveQuota(quotaService, orgId, 'pipelines', authHeader);\n * if (reservation.exceeded) return sendQuotaReserveDenied(res, 'pipelines', reservation);\n * try {\n * await doExpensiveThing();\n * } catch (err) {\n * // Pass the reserved resetAt so a period rollover doesn't get double-charged.\n * decrementQuota(quotaService, orgId, 'pipelines', authHeader, logWarn, 1, reservation.quota.resetAt);\n * throw err;\n * }\n * ```\n */\nexport function reserveQuota( quotaService: QuotaService,\n  orgId: string,\n  quotaType: QuotaType,\n  authHeader: string,\n  amount: number = 1,\n  requestId?: string,\n): Promise<QuotaReserveResult> {\n  return quotaService.reserve(orgId, quotaType, authHeader, amount, requestId);\n}\n\n/** Seconds a client should wait before retrying when quota couldn't be confirmed. */\nconst QUOTA_UNAVAILABLE_RETRY_AFTER_SECONDS = 5;\n\n/**\n * Answer a DENIED reservation (`reservation.exceeded === true`).\n *\n * - `unavailable` (the quota service couldn't confirm the slot) → **503**\n *   `SERVICE_UNAVAILABLE` with a short `Retry-After`: the org is not over its\n *   limit, so a 429 \"quota exceeded\" would send users to upgrade for an outage.\n * - otherwise → the standard 429 `QUOTA_EXCEEDED` with the X-Quota-* headers.\n */\nexport function sendQuotaReserveDenied(res: Response, quotaType: QuotaType, reservation: QuotaReserveResult): void {\n  if (reservation.unavailable) {\n    if (!res.headersSent) res.setHeader('Retry-After', QUOTA_UNAVAILABLE_RETRY_AFTER_SECONDS);\n    sendError(\n      res,\n      503,\n      `Unable to confirm ${quotaType} quota right now. Please try again shortly.`,\n      ErrorCode.SERVICE_UNAVAILABLE,\n    );\n    return;\n  }\n  sendQuotaExceeded(res, quotaType, reservation.quota, reservation.quota.resetAt);\n}\n\n/**\n * Fire-and-forget rollback for a previously reserved quota slot.\n * Logs on failure but never throws  the action that needed the rollback\n * has already failed, no point compounding the error.\n */\nexport function decrementQuota( quotaService: QuotaService,\n  orgId: string,\n  quotaType: QuotaType,\n  authHeader: string,\n  logWarn: (message: string, data?: unknown) => void,\n  amount: number = 1,\n  resetAtSnapshot?: string,\n): void {\n  quotaService.decrement(orgId, quotaType, authHeader, amount, resetAtSnapshot).catch((err: unknown) =>\n    logWarn('Quota rollback failed', { error: errorMessage(err) }),\n  );\n}\n"]}

package/lib/services/scheduler.d.ts

@@ -1,4 +1,4 @@
-import { type LockRedis } from './leader-lock.js';
+import { type LeaderLockRun, type LockRedis } from './leader-lock.js';
 /**
  * Optional cross-pod single-runner lock for a scheduler's cycle. Without
  * `redis` the scheduler uses the process's shared env-configured lock client
@@ -16,8 +16,17 @@ export interface SchedulerOptions {
     name: string;
     /** Interval between cycles (ms). */
     intervalMs: number;
-    /** The work to run each cycle. Errors are caught + logged, never thrown. */
-    run: () => Promise<void>;
+    /**
+     * The work to run each cycle. Errors are caught + logged, never thrown.
+     *
+     * `run.signal` is aborted when a leader-locked cycle LOSES its lock mid-run, or
+     * when `stop()` is called. A job that iterates over units of work (orgs, repos,
+     * entities) must check it between units and return: past a lock loss another pod
+     * may be doing the same work, and on shutdown returning promptly is what
+     * releases the lock instead of leaving it to expire. Unlocked schedulers get a
+     * signal too — it fires on `stop()` only.
+     */
+    run: (run: LeaderLockRun) => Promise<void>;
     /** Run a cycle immediately when started. Default true. */
     runOnStart?: boolean;
     /** Delay before the first cycle (and before the interval begins), ms.
@@ -30,7 +39,14 @@ export interface SchedulerOptions {
 export interface Scheduler {
     /** Start the timer. Idempotent — repeated calls are no-ops. */
     start(): void;
-    /** Stop the timer (and cancel a pending startup delay). Safe before start. */
+    /**
+     * Stop the timer (and cancel a pending startup delay). Safe before start.
+     *
+     * Also ABORTS an in-flight cycle's `run.signal` and defers closing the shared
+     * lock client until that cycle settles: a running cycle used to keep its lock
+     * key until the TTL lapsed, so a rolling deploy mid-run parked the job for the
+     * rest of the TTL. A signal-aware `run` returns and the lock is released.
+     */
     stop(): void;
 }
 /**

package/lib/services/scheduler.js

@@ -21,6 +21,10 @@ export function createScheduler(opts) {
     /** The shared env client this scheduler holds a reference on (own-client locks don't). */
     let envLock = null;
     let holdsEnvLock = false;
+    /** Aborted by `stop()`, so an in-flight cycle can return and release its lock. */
+    let shutdown = new AbortController();
+    /** The in-flight cycle, so `stop()` can wait for it before closing the client. */
+    let inFlight = null;
     const cycle = async () => {
         // Same-pod re-entrancy guard: setInterval doesn't await the async cycle, so
         // a cycle slower than intervalMs would otherwise overlap ITSELF on this pod
@@ -32,15 +36,20 @@ export function createScheduler(opts) {
             return;
         }
         running = true;
+        const signal = shutdown.signal;
         try {
             const redis = opts.lock ? (opts.lock.redis ? opts.lock.redis() : envLock) : null;
             if (opts.lock && redis) {
-                const ran = await withLeaderLock(redis, opts.lock.key, opts.lock.ttlMs, opts.run);
+                // withLeaderLock merges `signal` into the run's own, so `run` sees a single
+                // signal for both "lock lost" and "shutting down".
+                const ran = await withLeaderLock(redis, opts.lock.key, opts.lock.ttlMs, opts.run, { signal });
                 if (!ran)
                     log.debug('Cycle skipped — another pod holds the lock');
             }
             else {
-                await opts.run();
+                // Unlocked: still give the job a signal, so `stop()` can cut a long cycle
+                // short rather than waiting for it during shutdown.
+                await opts.run({ signal });
             }
         }
         catch (err) {
@@ -50,12 +59,18 @@ export function createScheduler(opts) {
             running = false;
         }
     };
+    /** Run a cycle and publish it as `inFlight` so `stop()` can await it. */
+    const runCycle = () => {
+        const p = cycle().finally(() => { if (inFlight === p)
+            inFlight = null; });
+        inFlight = p;
+    };
     const begin = () => {
         if (stopped)
             return; // stop() called during the startup delay
         if (opts.runOnStart !== false)
-            void cycle();
-        interval = setInterval(() => void cycle(), opts.intervalMs);
+            runCycle();
+        interval = setInterval(() => runCycle(), opts.intervalMs);
         interval.unref();
     };
     return {
@@ -63,6 +78,10 @@ export function createScheduler(opts) {
             if (interval || startup)
                 return;
             stopped = false;
+            // A restart needs a fresh controller: the previous stop() aborted the old
+            // one, and an already-aborted signal would make every cycle a no-op.
+            if (shutdown.signal.aborted)
+                shutdown = new AbortController();
             if (opts.lock && !opts.lock.redis && !holdsEnvLock) {
                 envLock = acquireSharedEnvLock();
                 holdsEnvLock = true;
@@ -86,13 +105,24 @@ export function createScheduler(opts) {
                 clearInterval(interval);
                 interval = null;
             }
+            // Ask an in-flight cycle to wind up. A signal-aware `run` returns between
+            // units of work, which lets withLeaderLock's `finally` RELEASE the lock —
+            // otherwise the key sat there until the TTL lapsed and the job was parked
+            // fleet-wide for that long after every rolling deploy.
+            if (!shutdown.signal.aborted)
+                shutdown.abort('shutdown');
             if (holdsEnvLock) {
                 holdsEnvLock = false;
+                const pending = inFlight;
                 envLock = null;
-                void releaseSharedEnvLock();
+                // Closing the client under a running cycle kills its heartbeat and its
+                // release, so wait for the cycle to settle first. Bounded by the cycle
+                // itself, which is now being asked to stop.
+                void (pending ? pending.catch(() => undefined) : Promise.resolve())
+                    .then(() => releaseSharedEnvLock());
             }
             log.info('Scheduler stopped');
         },
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scheduler.js","sourceRoot":"","sources":["../../src/services/scheduler.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { acquireSharedEnvLock, releaseSharedEnvLock, withLeaderLock, type LockRedis } from './leader-lock.js';\nimport { createLogger } from '../utils/logger.js';\nimport { errorMessage } from '../utils/response.js';\n\n/**\n * Optional cross-pod single-runner lock for a scheduler's cycle. Without\n * `redis` the scheduler uses the process's shared env-configured lock client\n * (taken on `start`, released on `stop`); when Redis isn't configured the cycle\n * runs on every pod, so the work it wraps must stay safe to run concurrently.\n * A supplied `redis` factory is resolved per cycle (e.g. a BullMQ connection).\n */\nexport interface SchedulerLock {\n  key: string;\n  ttlMs: number;\n  redis?: () => LockRedis;\n}\n\nexport interface SchedulerOptions {\n  /** Log label (also the logger name). */\n  name: string;\n  /** Interval between cycles (ms). */\n  intervalMs: number;\n  /** The work to run each cycle. Errors are caught + logged, never thrown. */\n  run: () => Promise<void>;\n  /** Run a cycle immediately when started. Default true. */\n  runOnStart?: boolean;\n  /** Delay before the first cycle (and before the interval begins), ms.\n   *  Default 0. Lets a service wait for dependencies to come up. */\n  startupDelayMs?: number;\n  /** When set, each cycle runs only on the pod that wins this lock — so with\n   *  multiple replicas only one runs per window. */\n  lock?: SchedulerLock;\n}\n\nexport interface Scheduler {\n  /** Start the timer. Idempotent — repeated calls are no-ops. */\n  start(): void;\n  /** Stop the timer (and cancel a pending startup delay). Safe before start. */\n  stop(): void;\n}\n\n/**\n * A periodic background job: a single unref'd `setInterval` with start-once\n * semantics, error isolation (a throwing cycle is logged, never crashes the\n * loop), an optional startup delay, and an optional cross-pod leader lock.\n *\n * Replaces the hand-rolled timer/`unref`/`catch`/start-stop boilerplate that\n * each scheduler (scan, digest, registry GC, billing lifecycle) repeated, and\n * makes the leader lock available to all of them uniformly.\n */\nexport function createScheduler(opts: SchedulerOptions): Scheduler {\n  const log = createLogger(opts.name);\n  let interval: ReturnType<typeof setInterval> | null = null;\n  let startup: ReturnType<typeof setTimeout> | null = null;\n  let stopped = false;\n  let running = false;\n  /** The shared env client this scheduler holds a reference on (own-client locks don't). */\n  let envLock: LockRedis | null = null;\n  let holdsEnvLock = false;\n\n  const cycle = async (): Promise<void> => {\n    // Same-pod re-entrancy guard: setInterval doesn't await the async cycle, so\n    // a cycle slower than intervalMs would otherwise overlap ITSELF on this pod\n    // (double-processing, duplicate side effects). The optional leader lock only\n    // guards CROSS-pod overlap; this guards same-pod. A skipped tick just runs on\n    // the next interval.\n    if (running) {\n      log.debug('Cycle skipped — previous cycle still running (same-pod re-entrancy)');\n      return;\n    }\n    running = true;\n    try {\n      const redis = opts.lock ? (opts.lock.redis ? opts.lock.redis() : envLock) : null;\n      if (opts.lock && redis) {\n        const ran = await withLeaderLock(redis, opts.lock.key, opts.lock.ttlMs, opts.run);\n        if (!ran) log.debug('Cycle skipped — another pod holds the lock');\n      } else {\n        await opts.run();\n      }\n    } catch (err) {\n      log.error('Scheduler cycle failed', { error: errorMessage(err) });\n    } finally {\n      running = false;\n    }\n  };\n\n  const begin = (): void => {\n    if (stopped) return; // stop() called during the startup delay\n    if (opts.runOnStart !== false) void cycle();\n    interval = setInterval(() => void cycle(), opts.intervalMs);\n    interval.unref();\n  };\n\n  return {\n    start(): void {\n      if (interval || startup) return;\n      stopped = false;\n      if (opts.lock && !opts.lock.redis && !holdsEnvLock) {\n        envLock = acquireSharedEnvLock();\n        holdsEnvLock = true;\n      }\n      if (opts.startupDelayMs && opts.startupDelayMs > 0) {\n        startup = setTimeout(() => { startup = null; begin(); }, opts.startupDelayMs);\n        startup.unref();\n      } else {\n        begin();\n      }\n      log.info('Scheduler started', { intervalMs: opts.intervalMs, locked: !!opts.lock && (!!opts.lock.redis || !!envLock) });\n    },\n    stop(): void {\n      stopped = true;\n      if (startup) { clearTimeout(startup); startup = null; }\n      if (interval) { clearInterval(interval); interval = null; }\n      if (holdsEnvLock) {\n        holdsEnvLock = false;\n        envLock = null;\n        void releaseSharedEnvLock();\n      }\n      log.info('Scheduler stopped');\n    },\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scheduler.js","sourceRoot":"","sources":["../../src/services/scheduler.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { acquireSharedEnvLock, releaseSharedEnvLock, withLeaderLock, type LeaderLockRun, type LockRedis } from './leader-lock.js';\nimport { createLogger } from '../utils/logger.js';\nimport { errorMessage } from '../utils/response.js';\n\n/**\n * Optional cross-pod single-runner lock for a scheduler's cycle. Without\n * `redis` the scheduler uses the process's shared env-configured lock client\n * (taken on `start`, released on `stop`); when Redis isn't configured the cycle\n * runs on every pod, so the work it wraps must stay safe to run concurrently.\n * A supplied `redis` factory is resolved per cycle (e.g. a BullMQ connection).\n */\nexport interface SchedulerLock {\n  key: string;\n  ttlMs: number;\n  redis?: () => LockRedis;\n}\n\nexport interface SchedulerOptions {\n  /** Log label (also the logger name). */\n  name: string;\n  /** Interval between cycles (ms). */\n  intervalMs: number;\n  /**\n   * The work to run each cycle. Errors are caught + logged, never thrown.\n   *\n   * `run.signal` is aborted when a leader-locked cycle LOSES its lock mid-run, or\n   * when `stop()` is called. A job that iterates over units of work (orgs, repos,\n   * entities) must check it between units and return: past a lock loss another pod\n   * may be doing the same work, and on shutdown returning promptly is what\n   * releases the lock instead of leaving it to expire. Unlocked schedulers get a\n   * signal too — it fires on `stop()` only.\n   */\n  run: (run: LeaderLockRun) => Promise<void>;\n  /** Run a cycle immediately when started. Default true. */\n  runOnStart?: boolean;\n  /** Delay before the first cycle (and before the interval begins), ms.\n   *  Default 0. Lets a service wait for dependencies to come up. */\n  startupDelayMs?: number;\n  /** When set, each cycle runs only on the pod that wins this lock — so with\n   *  multiple replicas only one runs per window. */\n  lock?: SchedulerLock;\n}\n\nexport interface Scheduler {\n  /** Start the timer. Idempotent — repeated calls are no-ops. */\n  start(): void;\n  /**\n   * Stop the timer (and cancel a pending startup delay). Safe before start.\n   *\n   * Also ABORTS an in-flight cycle's `run.signal` and defers closing the shared\n   * lock client until that cycle settles: a running cycle used to keep its lock\n   * key until the TTL lapsed, so a rolling deploy mid-run parked the job for the\n   * rest of the TTL. A signal-aware `run` returns and the lock is released.\n   */\n  stop(): void;\n}\n\n/**\n * A periodic background job: a single unref'd `setInterval` with start-once\n * semantics, error isolation (a throwing cycle is logged, never crashes the\n * loop), an optional startup delay, and an optional cross-pod leader lock.\n *\n * Replaces the hand-rolled timer/`unref`/`catch`/start-stop boilerplate that\n * each scheduler (scan, digest, registry GC, billing lifecycle) repeated, and\n * makes the leader lock available to all of them uniformly.\n */\nexport function createScheduler(opts: SchedulerOptions): Scheduler {\n  const log = createLogger(opts.name);\n  let interval: ReturnType<typeof setInterval> | null = null;\n  let startup: ReturnType<typeof setTimeout> | null = null;\n  let stopped = false;\n  let running = false;\n  /** The shared env client this scheduler holds a reference on (own-client locks don't). */\n  let envLock: LockRedis | null = null;\n  let holdsEnvLock = false;\n  /** Aborted by `stop()`, so an in-flight cycle can return and release its lock. */\n  let shutdown = new AbortController();\n  /** The in-flight cycle, so `stop()` can wait for it before closing the client. */\n  let inFlight: Promise<void> | null = null;\n\n  const cycle = async (): Promise<void> => {\n    // Same-pod re-entrancy guard: setInterval doesn't await the async cycle, so\n    // a cycle slower than intervalMs would otherwise overlap ITSELF on this pod\n    // (double-processing, duplicate side effects). The optional leader lock only\n    // guards CROSS-pod overlap; this guards same-pod. A skipped tick just runs on\n    // the next interval.\n    if (running) {\n      log.debug('Cycle skipped — previous cycle still running (same-pod re-entrancy)');\n      return;\n    }\n    running = true;\n    const signal = shutdown.signal;\n    try {\n      const redis = opts.lock ? (opts.lock.redis ? opts.lock.redis() : envLock) : null;\n      if (opts.lock && redis) {\n        // withLeaderLock merges `signal` into the run's own, so `run` sees a single\n        // signal for both \"lock lost\" and \"shutting down\".\n        const ran = await withLeaderLock(redis, opts.lock.key, opts.lock.ttlMs, opts.run, { signal });\n        if (!ran) log.debug('Cycle skipped — another pod holds the lock');\n      } else {\n        // Unlocked: still give the job a signal, so `stop()` can cut a long cycle\n        // short rather than waiting for it during shutdown.\n        await opts.run({ signal });\n      }\n    } catch (err) {\n      log.error('Scheduler cycle failed', { error: errorMessage(err) });\n    } finally {\n      running = false;\n    }\n  };\n\n  /** Run a cycle and publish it as `inFlight` so `stop()` can await it. */\n  const runCycle = (): void => {\n    const p = cycle().finally(() => { if (inFlight === p) inFlight = null; });\n    inFlight = p;\n  };\n\n  const begin = (): void => {\n    if (stopped) return; // stop() called during the startup delay\n    if (opts.runOnStart !== false) runCycle();\n    interval = setInterval(() => runCycle(), opts.intervalMs);\n    interval.unref();\n  };\n\n  return {\n    start(): void {\n      if (interval || startup) return;\n      stopped = false;\n      // A restart needs a fresh controller: the previous stop() aborted the old\n      // one, and an already-aborted signal would make every cycle a no-op.\n      if (shutdown.signal.aborted) shutdown = new AbortController();\n      if (opts.lock && !opts.lock.redis && !holdsEnvLock) {\n        envLock = acquireSharedEnvLock();\n        holdsEnvLock = true;\n      }\n      if (opts.startupDelayMs && opts.startupDelayMs > 0) {\n        startup = setTimeout(() => { startup = null; begin(); }, opts.startupDelayMs);\n        startup.unref();\n      } else {\n        begin();\n      }\n      log.info('Scheduler started', { intervalMs: opts.intervalMs, locked: !!opts.lock && (!!opts.lock.redis || !!envLock) });\n    },\n    stop(): void {\n      stopped = true;\n      if (startup) { clearTimeout(startup); startup = null; }\n      if (interval) { clearInterval(interval); interval = null; }\n      // Ask an in-flight cycle to wind up. A signal-aware `run` returns between\n      // units of work, which lets withLeaderLock's `finally` RELEASE the lock —\n      // otherwise the key sat there until the TTL lapsed and the job was parked\n      // fleet-wide for that long after every rolling deploy.\n      if (!shutdown.signal.aborted) shutdown.abort('shutdown');\n      if (holdsEnvLock) {\n        holdsEnvLock = false;\n        const pending = inFlight;\n        envLock = null;\n        // Closing the client under a running cycle kills its heartbeat and its\n        // release, so wait for the cycle to settle first. Bounded by the cycle\n        // itself, which is now being asked to stop.\n        void (pending ? pending.catch(() => undefined) : Promise.resolve())\n          .then(() => releaseSharedEnvLock());\n      }\n      log.info('Scheduler stopped');\n    },\n  };\n}\n"]}

package/lib/services/service-keys.d.ts

@@ -22,8 +22,6 @@ export declare class ServiceKeyError extends Error {
  * audit and metric labels use, so there is one source of truth for "who am I".
  */
 export declare function serviceIdentity(): string;
-/** Whether this process signs with a mounted key (`configured`) or an in-process one. */
-export declare function serviceKeyMode(): 'configured' | 'ephemeral';
 /**
  * Whether `kid` belongs to an internal SERVICE key. This is how a bearer token
  * is routed between the two ES256 chains: both user and service tokens are
@@ -33,8 +31,6 @@ export declare function serviceKeyMode(): 'configured' | 'ephemeral';
  * takes the user chain and is rejected there.
  */
 export declare function isServiceKid(kid: string): boolean;
-/** Every service name the bundle publishes a key for. Diagnostics and tests. */
-export declare function knownServiceNames(): string[];
 /**
  * Sign `claims` as this service's internal token: ES256, `kid` = the signer's
  * thumbprint, `sub` = `service:<serviceName>`. `iat`/`exp` and the optional