@pipeline-builder/api-core 0.0.1

package/lib/services/leader-lock.js

@@ -0,0 +1,85 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { randomUUID } from 'crypto';
+import { createEnvRedisClient } from './env-redis.js';
+import { createLogger } from '../utils/logger.js';
+const lockLogger = createLogger('leader-lock');
+/**
+ * Best-effort close of a leader-lock Redis client on shutdown. Prefers graceful
+ * `quit`; falls back to `disconnect`. No-op for a null client / one without
+ * either method. Never throws.
+ */
+export async function closeLeaderLock(redis) {
+    if (!redis)
+        return;
+    try {
+        if (typeof redis.quit === 'function') {
+            await redis.quit();
+            return;
+        }
+    }
+    catch {
+        // fall through to disconnect
+    }
+    try {
+        redis.disconnect?.();
+    }
+    catch { /* best-effort */ }
+}
+/** Atomic "delete only if I still own it" — closes the get-then-del race where
+ *  the lock expires and is re-acquired between the two calls. */
+const RELEASE_IF_OWNER = 'if redis.call("get", KEYS[1]) == ARGV[1] then return redis.call("del", KEYS[1]) else return 0 end';
+/**
+ * Run `fn` only if this process wins a short-lived distributed lock — the
+ * across-pods "single runner" guard for periodic jobs (digest flushes, etc.).
+ *
+ * Uses `SET key token NX PX ttl`, so exactly one holder runs per window and the
+ * lock auto-expires if that holder dies mid-run (no stuck lock). The lock is
+ * released on completion, but only if we still own it — a slower predecessor
+ * never deletes a successor's lock. `ttlMs` should comfortably exceed one run.
+ *
+ * @returns true if we held the lock and ran `fn`; false if another holder did.
+ */
+export async function withLeaderLock(redis, key, ttlMs, fn) {
+    const token = randomUUID();
+    const acquired = await redis.set(key, token, 'PX', ttlMs, 'NX');
+    if (acquired !== 'OK')
+        return false;
+    try {
+        await fn();
+    }
+    finally {
+        // 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
+        // eval (the small non-atomic window is TTL-bounded).
+        try {
+            if (typeof redis.eval === 'function') {
+                await redis.eval(RELEASE_IF_OWNER, 1, key, token);
+            }
+            else if ((await redis.get(key)) === token) {
+                await redis.del(key);
+            }
+        }
+        catch {
+            // Best-effort: the TTL expires the lock regardless.
+        }
+    }
+    return true;
+}
+/**
+ * A `LockRedis` backed by an env-configured ioredis client (`REDIS_URL` or
+ * `REDIS_HOST`) — the leader-lock counterpart to `createEnvRedisAuditSpool` /
+ * `createEnvRedisTokenRevocationStore`, for a service that has no BullMQ client to
+ * borrow. Returns `null` when Redis isn't configured, so a caller can degrade to
+ * running on every pod (the atomic guards it wraps must still make that safe).
+ * The client is a real ioredis instance; ioredis exposes `set`/`get`/`del`/`eval`,
+ * satisfying `LockRedis` including the atomic CAS release.
+ */
+export function createEnvRedisLock() {
+    const inst = createEnvRedisClient('leader-lock');
+    if (inst)
+        lockLogger.info('Redis leader-lock client initialized');
+    return inst;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGVhZGVyLWxvY2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VydmljZXMvbGVhZGVyLWxvY2sudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQUV0QyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sUUFBUSxDQUFDO0FBQ3BDLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUVsRCxNQUFNLFVBQVUsR0FBRyxZQUFZLENBQUMsYUFBYSxDQUFDLENBQUM7QUFvQi9DOzs7O0dBSUc7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLGVBQWUsQ0FBQyxLQUFtQztJQUN2RSxJQUFJLENBQUMsS0FBSztRQUFFLE9BQU87SUFDbkIsSUFBSSxDQUFDO1FBQ0gsSUFBSSxPQUFPLEtBQUssQ0FBQyxJQUFJLEtBQUssVUFBVSxFQUFFLENBQUM7WUFBQyxNQUFNLEtBQUssQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUFDLE9BQU87UUFBQyxDQUFDO0lBQ3ZFLENBQUM7SUFBQyxNQUFNLENBQUM7UUFDUCw2QkFBNkI7SUFDL0IsQ0FBQztJQUNELElBQUksQ0FBQztRQUFDLEtBQUssQ0FBQyxVQUFVLEVBQUUsRUFBRSxDQUFDO0lBQUMsQ0FBQztJQUFDLE1BQU0sQ0FBQyxDQUFDLGlCQUFpQixDQUFDLENBQUM7QUFDM0QsQ0FBQztBQUVEO2lFQUNpRTtBQUNqRSxNQUFNLGdCQUFnQixHQUNwQixtR0FBbUcsQ0FBQztBQUV0Rzs7Ozs7Ozs7OztHQVVHO0FBQ0gsTUFBTSxDQUFDLEtBQUssVUFBVSxjQUFjLENBQ2xDLEtBQWdCLEVBQ2hCLEdBQVcsRUFDWCxLQUFhLEVBQ2IsRUFBdUI7SUFFdkIsTUFBTSxLQUFLLEdBQUcsVUFBVSxFQUFFLENBQUM7SUFDM0IsTUFBTSxRQUFRLEdBQUcsTUFBTSxLQUFLLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBRSxJQUFJLENBQUMsQ0FBQztJQUNoRSxJQUFJLFFBQVEsS0FBSyxJQUFJO1FBQUUsT0FBTyxLQUFLLENBQUM7SUFFcEMsSUFBSSxDQUFDO1FBQ0gsTUFBTSxFQUFFLEVBQUUsQ0FBQztJQUNiLENBQUM7WUFBUyxDQUFDO1FBQ1QsMEVBQTBFO1FBQzFFLHdFQUF3RTtRQUN4RSw0RUFBNEU7UUFDNUUscURBQXFEO1FBQ3JELElBQUksQ0FBQztZQUNILElBQUksT0FBTyxLQUFLLENBQUMsSUFBSSxLQUFLLFVBQVUsRUFBRSxDQUFDO2dCQUNyQyxNQUFNLEtBQUssQ0FBQyxJQUFJLENBQUMsZ0JBQWdCLEVBQUUsQ0FBQyxFQUFFLEdBQUcsRUFBRSxLQUFLLENBQUMsQ0FBQztZQUNwRCxDQUFDO2lCQUFNLElBQUksQ0FBQyxNQUFNLEtBQUssQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUMsS0FBSyxLQUFLLEVBQUUsQ0FBQztnQkFDNUMsTUFBTSxLQUFLLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQ3ZCLENBQUM7UUFDSCxDQUFDO1FBQUMsTUFBTSxDQUFDO1lBQ1Asb0RBQW9EO1FBQ3RELENBQUM7SUFDSCxDQUFDO0lBQ0QsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDO0FBRUQ7Ozs7Ozs7O0dBUUc7QUFDSCxNQUFNLFVBQVUsa0JBQWtCO0lBQ2hDLE1BQU0sSUFBSSxHQUFHLG9CQUFvQixDQUFZLGFBQWEsQ0FBQyxDQUFDO0lBQzVELElBQUksSUFBSTtRQUFFLFVBQVUsQ0FBQyxJQUFJLENBQUMsc0NBQXNDLENBQUMsQ0FBQztJQUNsRSxPQUFPLElBQUksQ0FBQztBQUNkLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuaW1wb3J0IHsgcmFuZG9tVVVJRCB9IGZyb20gJ2NyeXB0byc7XG5pbXBvcnQgeyBjcmVhdGVFbnZSZWRpc0NsaWVudCB9IGZyb20gJy4vZW52LXJlZGlzLmpzJztcbmltcG9ydCB7IGNyZWF0ZUxvZ2dlciB9IGZyb20gJy4uL3V0aWxzL2xvZ2dlci5qcyc7XG5cbmNvbnN0IGxvY2tMb2dnZXIgPSBjcmVhdGVMb2dnZXIoJ2xlYWRlci1sb2NrJyk7XG5cbi8qKlxuICogTWluaW1hbCBSZWRpcyBjbGllbnQgc3VyZmFjZSBuZWVkZWQgZm9yIGEgbGVhZGVyIGxvY2sgKGEgc3Vic2V0IG9mIGlvcmVkaXMpLlxuICogYHNldGAgaXMgdmFyaWFkaWMgc28gY2FsbGVycyBjYW4gcGFzcyBgJ1BYJywgdHRsLCAnTlgnYC5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBMb2NrUmVkaXMge1xuICBzZXQoa2V5OiBzdHJpbmcsIHZhbHVlOiBzdHJpbmcsIC4uLmFyZ3M6IHVua25vd25bXSk6IFByb21pc2U8dW5rbm93bj47XG4gIGdldChrZXk6IHN0cmluZyk6IFByb21pc2U8c3RyaW5nIHwgbnVsbD47XG4gIGRlbCguLi5rZXlzOiBzdHJpbmdbXSk6IFByb21pc2U8bnVtYmVyPjtcbiAgLyoqIE9wdGlvbmFsIEx1YSBldmFsIChpb3JlZGlzIGhhcyBpdCkuIFdoZW4gcHJlc2VudCwgcmVsZWFzZSB1c2VzIGFuIGF0b21pY1xuICAgKiAgY29tcGFyZS1hbmQtZGVsZXRlIHNvIGEgbGFwc2VkIGhvbGRlciBjYW4ndCBmcmVlIGEgc3VjY2Vzc29yJ3MgbG9jay4gKi9cbiAgZXZhbD8oc2NyaXB0OiBzdHJpbmcsIG51bUtleXM6IG51bWJlciwgLi4uYXJnczogdW5rbm93bltdKTogUHJvbWlzZTx1bmtub3duPjtcbiAgLyoqIEdyYWNlZnVsIGNsb3NlIChpb3JlZGlzIGBxdWl0YCkg4oCUIGNhbGxlZCBvbiBzaHV0ZG93biBzbyB0aGUgY29ubmVjdGlvblxuICAgKiAgZG9lc24ndCBrZWVwIHRoZSBldmVudCBsb29wIGFsaXZlLiAqL1xuICBxdWl0PygpOiBQcm9taXNlPHVua25vd24+O1xuICAvKiogSW1tZWRpYXRlIGNsb3NlIChpb3JlZGlzIGBkaXNjb25uZWN0YCkg4oCUIHRoZSBmYWxsYmFjayBpZiBgcXVpdGAgZmFpbHMuICovXG4gIGRpc2Nvbm5lY3Q/KCk6IHZvaWQ7XG59XG5cbi8qKlxuICogQmVzdC1lZmZvcnQgY2xvc2Ugb2YgYSBsZWFkZXItbG9jayBSZWRpcyBjbGllbnQgb24gc2h1dGRvd24uIFByZWZlcnMgZ3JhY2VmdWxcbiAqIGBxdWl0YDsgZmFsbHMgYmFjayB0byBgZGlzY29ubmVjdGAuIE5vLW9wIGZvciBhIG51bGwgY2xpZW50IC8gb25lIHdpdGhvdXRcbiAqIGVpdGhlciBtZXRob2QuIE5ldmVyIHRocm93cy5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGNsb3NlTGVhZGVyTG9jayhyZWRpczogTG9ja1JlZGlzIHwgbnVsbCB8IHVuZGVmaW5lZCk6IFByb21pc2U8dm9pZD4ge1xuICBpZiAoIXJlZGlzKSByZXR1cm47XG4gIHRyeSB7XG4gICAgaWYgKHR5cGVvZiByZWRpcy5xdWl0ID09PSAnZnVuY3Rpb24nKSB7IGF3YWl0IHJlZGlzLnF1aXQoKTsgcmV0dXJuOyB9XG4gIH0gY2F0Y2gge1xuICAgIC8vIGZhbGwgdGhyb3VnaCB0byBkaXNjb25uZWN0XG4gIH1cbiAgdHJ5IHsgcmVkaXMuZGlzY29ubmVjdD8uKCk7IH0gY2F0Y2ggeyAvKiBiZXN0LWVmZm9ydCAqLyB9XG59XG5cbi8qKiBBdG9taWMgXCJkZWxldGUgb25seSBpZiBJIHN0aWxsIG93biBpdFwiIOKAlCBjbG9zZXMgdGhlIGdldC10aGVuLWRlbCByYWNlIHdoZXJlXG4gKiAgdGhlIGxvY2sgZXhwaXJlcyBhbmQgaXMgcmUtYWNxdWlyZWQgYmV0d2VlbiB0aGUgdHdvIGNhbGxzLiAqL1xuY29uc3QgUkVMRUFTRV9JRl9PV05FUiA9XG4gICdpZiByZWRpcy5jYWxsKFwiZ2V0XCIsIEtFWVNbMV0pID09IEFSR1ZbMV0gdGhlbiByZXR1cm4gcmVkaXMuY2FsbChcImRlbFwiLCBLRVlTWzFdKSBlbHNlIHJldHVybiAwIGVuZCc7XG5cbi8qKlxuICogUnVuIGBmbmAgb25seSBpZiB0aGlzIHByb2Nlc3Mgd2lucyBhIHNob3J0LWxpdmVkIGRpc3RyaWJ1dGVkIGxvY2sg4oCUIHRoZVxuICogYWNyb3NzLXBvZHMgXCJzaW5nbGUgcnVubmVyXCIgZ3VhcmQgZm9yIHBlcmlvZGljIGpvYnMgKGRpZ2VzdCBmbHVzaGVzLCBldGMuKS5cbiAqXG4gKiBVc2VzIGBTRVQga2V5IHRva2VuIE5YIFBYIHR0bGAsIHNvIGV4YWN0bHkgb25lIGhvbGRlciBydW5zIHBlciB3aW5kb3cgYW5kIHRoZVxuICogbG9jayBhdXRvLWV4cGlyZXMgaWYgdGhhdCBob2xkZXIgZGllcyBtaWQtcnVuIChubyBzdHVjayBsb2NrKS4gVGhlIGxvY2sgaXNcbiAqIHJlbGVhc2VkIG9uIGNvbXBsZXRpb24sIGJ1dCBvbmx5IGlmIHdlIHN0aWxsIG93biBpdCDigJQgYSBzbG93ZXIgcHJlZGVjZXNzb3JcbiAqIG5ldmVyIGRlbGV0ZXMgYSBzdWNjZXNzb3IncyBsb2NrLiBgdHRsTXNgIHNob3VsZCBjb21mb3J0YWJseSBleGNlZWQgb25lIHJ1bi5cbiAqXG4gKiBAcmV0dXJucyB0cnVlIGlmIHdlIGhlbGQgdGhlIGxvY2sgYW5kIHJhbiBgZm5gOyBmYWxzZSBpZiBhbm90aGVyIGhvbGRlciBkaWQuXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiB3aXRoTGVhZGVyTG9jayhcbiAgcmVkaXM6IExvY2tSZWRpcyxcbiAga2V5OiBzdHJpbmcsXG4gIHR0bE1zOiBudW1iZXIsXG4gIGZuOiAoKSA9PiBQcm9taXNlPHZvaWQ+LFxuKTogUHJvbWlzZTxib29sZWFuPiB7XG4gIGNvbnN0IHRva2VuID0gcmFuZG9tVVVJRCgpO1xuICBjb25zdCBhY3F1aXJlZCA9IGF3YWl0IHJlZGlzLnNldChrZXksIHRva2VuLCAnUFgnLCB0dGxNcywgJ05YJyk7XG4gIGlmIChhY3F1aXJlZCAhPT0gJ09LJykgcmV0dXJuIGZhbHNlO1xuXG4gIHRyeSB7XG4gICAgYXdhaXQgZm4oKTtcbiAgfSBmaW5hbGx5IHtcbiAgICAvLyBSZWxlYXNlIG9ubHkgaWYgdGhlIGxvY2sgaXMgc3RpbGwgb3VycyDigJQgaWYgb3VyIHJ1biBvdmVycmFuIHRoZSBUVEwgYW5kXG4gICAgLy8gYW5vdGhlciBob2xkZXIgdG9vayBvdmVyLCByZWxlYXNpbmcgaGVyZSB3b3VsZCBmcmVlIHRoZWlyIGxvY2sgZWFybHkuXG4gICAgLy8gUHJlZmVyIGFuIGF0b21pYyBDQVMgKEx1YSk7IGZhbGwgYmFjayB0byBnZXQtdGhlbi1kZWwgZm9yIGNsaWVudHMgd2l0aG91dFxuICAgIC8vIGV2YWwgKHRoZSBzbWFsbCBub24tYXRvbWljIHdpbmRvdyBpcyBUVEwtYm91bmRlZCkuXG4gICAgdHJ5IHtcbiAgICAgIGlmICh0eXBlb2YgcmVkaXMuZXZhbCA9PT0gJ2Z1bmN0aW9uJykge1xuICAgICAgICBhd2FpdCByZWRpcy5ldmFsKFJFTEVBU0VfSUZfT1dORVIsIDEsIGtleSwgdG9rZW4pO1xuICAgICAgfSBlbHNlIGlmICgoYXdhaXQgcmVkaXMuZ2V0KGtleSkpID09PSB0b2tlbikge1xuICAgICAgICBhd2FpdCByZWRpcy5kZWwoa2V5KTtcbiAgICAgIH1cbiAgICB9IGNhdGNoIHtcbiAgICAgIC8vIEJlc3QtZWZmb3J0OiB0aGUgVFRMIGV4cGlyZXMgdGhlIGxvY2sgcmVnYXJkbGVzcy5cbiAgICB9XG4gIH1cbiAgcmV0dXJuIHRydWU7XG59XG5cbi8qKlxuICogQSBgTG9ja1JlZGlzYCBiYWNrZWQgYnkgYW4gZW52LWNvbmZpZ3VyZWQgaW9yZWRpcyBjbGllbnQgKGBSRURJU19VUkxgIG9yXG4gKiBgUkVESVNfSE9TVGApIOKAlCB0aGUgbGVhZGVyLWxvY2sgY291bnRlcnBhcnQgdG8gYGNyZWF0ZUVudlJlZGlzQXVkaXRTcG9vbGAgL1xuICogYGNyZWF0ZUVudlJlZGlzVG9rZW5SZXZvY2F0aW9uU3RvcmVgLCBmb3IgYSBzZXJ2aWNlIHRoYXQgaGFzIG5vIEJ1bGxNUSBjbGllbnQgdG9cbiAqIGJvcnJvdy4gUmV0dXJucyBgbnVsbGAgd2hlbiBSZWRpcyBpc24ndCBjb25maWd1cmVkLCBzbyBhIGNhbGxlciBjYW4gZGVncmFkZSB0b1xuICogcnVubmluZyBvbiBldmVyeSBwb2QgKHRoZSBhdG9taWMgZ3VhcmRzIGl0IHdyYXBzIG11c3Qgc3RpbGwgbWFrZSB0aGF0IHNhZmUpLlxuICogVGhlIGNsaWVudCBpcyBhIHJlYWwgaW9yZWRpcyBpbnN0YW5jZTsgaW9yZWRpcyBleHBvc2VzIGBzZXRgL2BnZXRgL2BkZWxgL2BldmFsYCxcbiAqIHNhdGlzZnlpbmcgYExvY2tSZWRpc2AgaW5jbHVkaW5nIHRoZSBhdG9taWMgQ0FTIHJlbGVhc2UuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjcmVhdGVFbnZSZWRpc0xvY2soKTogTG9ja1JlZGlzIHwgbnVsbCB7XG4gIGNvbnN0IGluc3QgPSBjcmVhdGVFbnZSZWRpc0NsaWVudDxMb2NrUmVkaXM+KCdsZWFkZXItbG9jaycpO1xuICBpZiAoaW5zdCkgbG9ja0xvZ2dlci5pbmZvKCdSZWRpcyBsZWFkZXItbG9jayBjbGllbnQgaW5pdGlhbGl6ZWQnKTtcbiAgcmV0dXJuIGluc3Q7XG59XG4iXX0=

package/lib/services/quota.d.ts

@@ -0,0 +1,130 @@
+import type { QuotaType, QuotaCheckResult } from '../types/common.js';
+import { type QuotaTier } from '../types/quota-tiers.js';
+/**
+ * Result of a synchronous quota reservation  the atomic check+increment
+ * variant. `exceeded: true` means the operation was rejected at the DB
+ * level; the caller should return 429 without running the gated action.
+ */
+export interface QuotaReserveResult {
+    exceeded: boolean;
+    quota: {
+        type: QuotaType;
+        limit: number;
+        used: number;
+        remaining: number;
+        resetAt?: string;
+    };
+}
+/**
+ * Quota service client interface.
+ */
+export interface QuotaService {
+    /** Check if quota is available (fail-open on error). */
+    check(orgId: string, quotaType: QuotaType, authHeader: string, requestId?: string): Promise<QuotaCheckResult>;
+    /** Increment quota usage. Returns a promise so callers can optionally handle errors. */
+    increment(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, requestId?: string): Promise<void>;
+    /**
+     * Atomic reserve  the same atomic check+increment as `increment`, but
+     * parses the response so callers can see whether the slot was actually
+     * reserved. Use this for expensive resources where the post-hoc fire-
+     * and-forget pattern allows concurrent over-spend.
+     *
+     * Fail-open semantics on transport errors: returns `exceeded: false` so
+     * the caller can proceed and the request isn't blocked by quota-service
+     * outages (matches `check()`).
+     */
+    reserve(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, requestId?: string): Promise<QuotaReserveResult>;
+    /**
+     * Roll back a previously reserved slot. Fire-and-forget — never throws.
+     * Pass `resetAtSnapshot` (the `quota.resetAt` observed when the slot was
+     * reserved) to make the rollback conditional: if the period rolled over
+     * between reserve and rollback, the server skips the decrement so it doesn't
+     * steal capacity from the new period.
+     */
+    decrement(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, resetAtSnapshot?: string, requestId?: string): Promise<void>;
+    /** Update quota limits. Returns true on success. */
+    updateLimits(orgId: string, limits: Partial<Record<QuotaType, number>>, authHeader: string, requestId?: string): Promise<boolean>;
+    /** Reset quota usage. Returns true on success. */
+    reset(orgId: string, quotaType?: QuotaType, authHeader?: string, requestId?: string): Promise<boolean>;
+    /**
+     * Get the org's quota `QuotaTier`. Used by the plugin-build queue partitioning
+     * to route a build to the right per-tier queue. Fail-open returns `DEFAULT_TIER`
+     * (`developer` when billing is enabled, `unlimited` when it's disabled); a
+     * misclassified org still builds on the default queue, just without the
+     * tier-scoped scheduling boost.
+     */
+    getTier(orgId: string, authHeader: string, requestId?: string): Promise<QuotaTier>;
+}
+/**
+ * Configuration for quota service client.
+ */
+export interface QuotaServiceConfig {
+    /** Quota service host (default: env QUOTA_SERVICE_HOST or 'quota') */
+    host?: string;
+    /** Quota service port (default: env QUOTA_SERVICE_PORT or 3000) */
+    port?: number;
+    /** Request timeout in milliseconds (default: 5000) */
+    timeout?: number;
+}
+/**
+ * Create a quota service client.
+ *
+ * @param config - Optional service configuration
+ * @returns Quota service client
+ *
+ * @example
+ * ```typescript
+ * const quotaService = createQuotaService();
+ *
+ * // Check quota before processing
+ * const quota = await quotaService.check(orgId, 'apiCalls', authHeader);
+ * if (!quota.allowed) {
+ * return res.status(429).json({ error: 'Quota exceeded' });
+ * }
+ *
+ * // Increment quota after success
+ * quotaService.increment(orgId, 'apiCalls', authHeader).catch(err => logger.warn('Quota increment failed', { error: err }));
+ * ```
+ */
+export declare function createQuotaService(config?: QuotaServiceConfig): QuotaService;
+/**
+ * Fire-and-forget quota increment with standardized error logging.
+ *
+ * Wraps `quotaService.increment()` with a `.catch()` that logs a warning.
+ * Eliminates the identical one-liner repeated across every read route.
+ *
+ * @param quotaService - Quota service client
+ * @param orgId - Organization ID
+ * @param quotaType - Quota type to increment
+ * @param authHeader - Authorization header value
+ * @param logWarn - Logging function for warnings
+ */
+export declare function incrementQuota(quotaService: QuotaService, orgId: string, quotaType: QuotaType, authHeader: string, logWarn: (message: string, data?: unknown) => void): void;
+/**
+ * Atomic reserve helper for the "reserve + commit / rollback" pattern.
+ * Use for expensive resources (pipelines, plugins, AI calls) where the
+ * fire-and-forget post-hoc `incrementQuota` allows concurrent over-spend.
+ *
+ * Returns the structured result so the caller can decide whether to run
+ * the gated action or 429 the client.
+ *
+ * @example
+ * ```typescript
+ * const reservation = await reserveQuota(quotaService, orgId, 'pipelines', authHeader);
+ * if (reservation.exceeded) return sendQuotaExceeded(res, 'pipelines', reservation.quota);
+ * try {
+ * await doExpensiveThing();
+ * } catch (err) {
+ * // Pass the reserved resetAt so a period rollover doesn't get double-charged.
+ * decrementQuota(quotaService, orgId, 'pipelines', authHeader, logWarn, 1, reservation.quota.resetAt);
+ * throw err;
+ * }
+ * ```
+ */
+export declare function reserveQuota(quotaService: QuotaService, orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, requestId?: string): Promise<QuotaReserveResult>;
+/**
+ * Fire-and-forget rollback for a previously reserved quota slot.
+ * Logs on failure but never throws  the action that needed the rollback
+ * has already failed, no point compounding the error.
+ */
+export declare function decrementQuota(quotaService: QuotaService, orgId: string, quotaType: QuotaType, authHeader: string, logWarn: (message: string, data?: unknown) => void, amount?: number, resetAtSnapshot?: string): void;

package/lib/services/quota.js

@@ -0,0 +1,264 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { createSafeClient } from './http-client.js';
+import { DEFAULT_TIER, isValidTier } from '../types/quota-tiers.js';
+import { createLogger } from '../utils/logger.js';
+import { emitCounter } from '../utils/metric-emitter.js';
+/** Retry options for quota calls  fail fast since quota is fail-open. */
+const QUOTA_REQUEST_OPTIONS = {
+    maxRateLimitRetries: 1,
+    maxRetries: 1,
+};
+const logger = createLogger('quota');
+// `reserve` gates EXPENSIVE resources (plugin builds, pipelines). When the
+// quota service is reachable but returns an error (often an OVERLOADED service),
+// failing open would pile unmetered expensive work onto it and bypass quota
+// entirely — the textbook fail-open blow-up. So `reserve` fails CLOSED on an
+// errored response by default. Operators who prefer availability over
+// enforcement can opt back into fail-open with QUOTA_RESERVE_FAIL_OPEN=true.
+// (A genuinely UNREACHABLE service still fails open — that's a confirmed outage,
+// not an overload signal.)
+const QUOTA_RESERVE_FAIL_OPEN = process.env.QUOTA_RESERVE_FAIL_OPEN === 'true';
+/**
+ * Create a fail-open quota result (allows the request).
+ */
+function createFailOpenResult() {
+    return {
+        allowed: true,
+        limit: -1,
+        used: 0,
+        remaining: -1,
+        resetAt: new Date().toISOString(),
+        unlimited: true,
+        // Tag the sentinel so fail-closed callers can tell an outage apart from a
+        // real unlimited (-1) reading. Real quota results never set this.
+        failOpen: true,
+    };
+}
+/**
+ * Build common request headers with optional request ID for distributed tracing.
+ */
+function buildHeaders(orgId, authHeader, requestId) {
+    const headers = { 'x-org-id': orgId };
+    if (authHeader)
+        headers.Authorization = authHeader;
+    if (requestId)
+        headers['X-Request-Id'] = requestId;
+    return headers;
+}
+/**
+ * Create a quota service client.
+ *
+ * @param config - Optional service configuration
+ * @returns Quota service client
+ *
+ * @example
+ * ```typescript
+ * const quotaService = createQuotaService();
+ *
+ * // Check quota before processing
+ * const quota = await quotaService.check(orgId, 'apiCalls', authHeader);
+ * if (!quota.allowed) {
+ * return res.status(429).json({ error: 'Quota exceeded' });
+ * }
+ *
+ * // Increment quota after success
+ * quotaService.increment(orgId, 'apiCalls', authHeader).catch(err => logger.warn('Quota increment failed', { error: err }));
+ * ```
+ */
+export function createQuotaService(config = {}) {
+    const serviceConfig = {
+        host: config.host ?? process.env.QUOTA_SERVICE_HOST ?? 'quota',
+        port: config.port ?? parseInt(process.env.QUOTA_SERVICE_PORT ?? '3000', 10),
+        timeout: config.timeout ?? 5000,
+    };
+    const client = createSafeClient(serviceConfig);
+    return {
+        async check(orgId, quotaType, authHeader, requestId) {
+            const path = `/quotas/${encodeURIComponent(orgId)}/${encodeURIComponent(quotaType)}`;
+            const response = await client.get(path, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });
+            if (!response) {
+                logger.warn('QUOTA_FAIL_OPEN: Quota service unreachable, allowing request', { orgId, quotaType });
+                emitCounter('quota_fail_open_total', { operation: 'check', reason: 'unreachable', quotaType });
+                return createFailOpenResult();
+            }
+            if (response.statusCode !== 200 || !response.body.success || !response.body.data?.status) {
+                logger.warn('QUOTA_FAIL_OPEN: Quota check returned non-ok, allowing request', {
+                    orgId, quotaType, statusCode: response.statusCode, message: response.body.message,
+                });
+                emitCounter('quota_fail_open_total', { operation: 'check', reason: 'non-ok', quotaType });
+                return createFailOpenResult();
+            }
+            return response.body.data.status;
+        },
+        async increment(orgId, quotaType, authHeader, amount = 1, requestId) {
+            const path = `/quotas/${encodeURIComponent(orgId)}/increment`;
+            const response = await client
+                .post(path, { quotaType, amount }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });
+            if (!response || response.statusCode !== 200) {
+                logger.warn('Failed to increment quota', {
+                    orgId, quotaType, amount, statusCode: response?.statusCode,
+                });
+            }
+            else {
+                logger.debug('Quota incremented', { orgId, quotaType, amount });
+            }
+        },
+        async reserve(orgId, quotaType, authHeader, amount = 1, requestId) {
+            const path = `/quotas/${encodeURIComponent(orgId)}/increment`;
+            // 200 carries `data.quota`; 429 (QUOTA_EXCEEDED) carries `details.quota`.
+            // Both shapes are normalized into QuotaReserveResult.
+            const response = await client.post(path, { quotaType, amount }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });
+            if (!response) {
+                logger.warn('QUOTA_FAIL_OPEN: Quota service unreachable on reserve, allowing request', { orgId, quotaType });
+                emitCounter('quota_fail_open_total', { operation: 'reserve', reason: 'unreachable', quotaType });
+                return { exceeded: false, quota: { type: quotaType, limit: -1, used: 0, remaining: -1 } };
+            }
+            if (response.statusCode === 429) {
+                const q = response.body.details?.quota;
+                // Only a GENUINE quota-exceeded 429 means "over quota". A generic 429 —
+                // the quota service's OWN rate limiter (RATE_LIMIT_EXCEEDED) or an
+                // intervening gateway during a spike — must NOT be surfaced as
+                // quota-exceeded: that would falsely block legitimate work behind a
+                // transient rate limit. Require the QUOTA_EXCEEDED error code (or the
+                // quota payload) and otherwise fall through to the non-ok
+                // fail-open/closed policy below (the right handling for a transient 429).
+                if (response.body.errorCode === 'QUOTA_EXCEEDED' || q) {
+                    return {
+                        exceeded: true,
+                        quota: q ?? { type: quotaType, limit: 0, used: 0, remaining: 0 },
+                    };
+                }
+                // A non-QUOTA_EXCEEDED 429 is a TRANSIENT signal (the quota service's own
+                // rate limiter, or a gateway during a spike) — the tenant is NOT over quota,
+                // so fail OPEN (as for an unreachable service) rather than falsely blocking
+                // legitimate work. Do not fall through to the fail-closed non-ok default.
+                logger.warn('QUOTA_FAIL_OPEN: transient 429 on reserve (not quota-exceeded), allowing request', { orgId, quotaType });
+                emitCounter('quota_fail_open_total', { operation: 'reserve', reason: 'transient-429', quotaType });
+                return { exceeded: false, quota: { type: quotaType, limit: -1, used: 0, remaining: -1 } };
+            }
+            if (response.statusCode !== 200 || !response.body.success) {
+                if (QUOTA_RESERVE_FAIL_OPEN) {
+                    logger.warn('QUOTA_FAIL_OPEN: Quota reserve returned non-ok, allowing request', {
+                        orgId, quotaType, statusCode: response.statusCode,
+                    });
+                    emitCounter('quota_fail_open_total', { operation: 'reserve', reason: 'non-ok', quotaType });
+                    return { exceeded: false, quota: { type: quotaType, limit: -1, used: 0, remaining: -1 } };
+                }
+                // Service reachable but didn't confirm the reservation → fail CLOSED.
+                logger.warn('QUOTA_FAIL_CLOSED: Quota reserve returned non-ok, denying request', {
+                    orgId, quotaType, statusCode: response.statusCode,
+                });
+                emitCounter('quota_fail_closed_total', { operation: 'reserve', reason: 'non-ok', quotaType });
+                return { exceeded: true, quota: { type: quotaType, limit: 0, used: 0, remaining: 0 } };
+            }
+            const q = response.body.data?.quota;
+            return {
+                exceeded: false,
+                quota: q ?? { type: quotaType, limit: -1, used: 0, remaining: -1 },
+            };
+        },
+        async decrement(orgId, quotaType, authHeader, amount = 1, resetAtSnapshot, requestId) {
+            const path = `/quotas/${encodeURIComponent(orgId)}/decrement`;
+            const response = await client
+                .post(path, { quotaType, amount, ...(resetAtSnapshot && { resetAtSnapshot }) }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });
+            if (!response || response.statusCode !== 200) {
+                // Rollback failure is logged but never propagated  the action's own
+                // failure has already been surfaced to the caller; a stuck counter
+                // resolves on the next period reset.
+                logger.warn('Failed to decrement quota (slot will reset on next period)', {
+                    orgId, quotaType, amount, statusCode: response?.statusCode,
+                });
+            }
+            else {
+                logger.debug('Quota decremented', { orgId, quotaType, amount });
+            }
+        },
+        async updateLimits(orgId, limits, authHeader, requestId) {
+            const path = `/quotas/${encodeURIComponent(orgId)}`;
+            const response = await client.put(path, limits, { headers: buildHeaders(orgId, authHeader, requestId) });
+            if (!response || response.statusCode !== 200) {
+                logger.warn('Failed to update quota limits', {
+                    orgId, limits, statusCode: response?.statusCode,
+                });
+                return false;
+            }
+            logger.info('Quota limits updated', { orgId, limits });
+            return true;
+        },
+        async getTier(orgId, authHeader, requestId) {
+            const path = `/quotas/${encodeURIComponent(orgId)}`;
+            const response = await client.get(path, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });
+            if (!response || response.statusCode !== 200 || !response.body.success) {
+                logger.warn(`QUOTA_FAIL_OPEN: tier lookup failed, defaulting to ${DEFAULT_TIER} tier`, {
+                    orgId, statusCode: response?.statusCode, defaultTier: DEFAULT_TIER,
+                });
+                emitCounter('quota_fail_open_total', { operation: 'tier', reason: response ? 'non-ok' : 'unreachable', quotaType: 'tier' });
+                return DEFAULT_TIER;
+            }
+            const tier = response.body.data?.quota?.tier;
+            return tier && isValidTier(tier) ? tier : DEFAULT_TIER;
+        },
+        async reset(orgId, quotaType, authHeader, requestId) {
+            const path = `/quotas/${encodeURIComponent(orgId)}/reset`;
+            const body = quotaType ? { quotaType } : {};
+            const response = await client.post(path, body, { headers: buildHeaders(orgId, authHeader ?? '', requestId) });
+            if (!response || response.statusCode !== 200) {
+                logger.warn('Failed to reset quota', {
+                    orgId, quotaType, statusCode: response?.statusCode,
+                });
+                return false;
+            }
+            logger.info('Quota reset', { orgId, quotaType: quotaType ?? 'all' });
+            return true;
+        },
+    };
+}
+/**
+ * Fire-and-forget quota increment with standardized error logging.
+ *
+ * Wraps `quotaService.increment()` with a `.catch()` that logs a warning.
+ * Eliminates the identical one-liner repeated across every read route.
+ *
+ * @param quotaService - Quota service client
+ * @param orgId - Organization ID
+ * @param quotaType - Quota type to increment
+ * @param authHeader - Authorization header value
+ * @param logWarn - Logging function for warnings
+ */
+export function incrementQuota(quotaService, orgId, quotaType, authHeader, logWarn) {
+    quotaService.increment(orgId, quotaType, authHeader).catch((err) => logWarn('Quota increment failed', { error: err instanceof Error ? err.message : String(err) }));
+}
+/**
+ * Atomic reserve helper for the "reserve + commit / rollback" pattern.
+ * Use for expensive resources (pipelines, plugins, AI calls) where the
+ * fire-and-forget post-hoc `incrementQuota` allows concurrent over-spend.
+ *
+ * Returns the structured result so the caller can decide whether to run
+ * the gated action or 429 the client.
+ *
+ * @example
+ * ```typescript
+ * const reservation = await reserveQuota(quotaService, orgId, 'pipelines', authHeader);
+ * if (reservation.exceeded) return sendQuotaExceeded(res, 'pipelines', reservation.quota);
+ * try {
+ * await doExpensiveThing();
+ * } catch (err) {
+ * // Pass the reserved resetAt so a period rollover doesn't get double-charged.
+ * decrementQuota(quotaService, orgId, 'pipelines', authHeader, logWarn, 1, reservation.quota.resetAt);
+ * throw err;
+ * }
+ * ```
+ */
+export function reserveQuota(quotaService, orgId, quotaType, authHeader, amount = 1, requestId) {
+    return quotaService.reserve(orgId, quotaType, authHeader, amount, requestId);
+}
+/**
+ * Fire-and-forget rollback for a previously reserved quota slot.
+ * Logs on failure but never throws  the action that needed the rollback
+ * has already failed, no point compounding the error.
+ */
+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: err instanceof Error ? err.message : String(err) }));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quota.js","sourceRoot":"","sources":["../../src/services/quota.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,gBAAgB,EAAuB,MAAM,kBAAkB,CAAC;AAEzE,OAAO,EAAE,YAAY,EAAE,WAAW,EAAkB,MAAM,yBAAyB,CAAC;AACpF,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEzD,yEAAyE;AACzE,MAAM,qBAAqB,GAA+D;IACxF,mBAAmB,EAAE,CAAC;IACtB,UAAU,EAAE,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;AAErC,2EAA2E;AAC3E,iFAAiF;AACjF,4EAA4E;AAC5E,6EAA6E;AAC7E,sEAAsE;AACtE,6EAA6E;AAC7E,iFAAiF;AACjF,2BAA2B;AAC3B,MAAM,uBAAuB,GAAG,OAAO,CAAC,GAAG,CAAC,uBAAuB,KAAK,MAAM,CAAC;AAuE/E;;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,OAAO,CAAC,GAAG,CAAC,kBAAkB,IAAI,OAAO;QAC9D,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,IAAI,MAAM,EAAE,EAAE,CAAC;QAC3E,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,IAAI;KAChC,CAAC;IAEF,MAAM,MAAM,GAAG,gBAAgB,CAAC,aAAa,CAAC,CAAC;IAE/C,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,CAK/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,EAAE,CAAC;gBACd,MAAM,CAAC,IAAI,CAAC,yEAAyE,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;gBAC7G,WAAW,CAAC,uBAAuB,EAAE,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE,CAAC,CAAC;gBACjG,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;YAC5F,CAAC;YAED,IAAI,QAAQ,CAAC,UAAU,KAAK,GAAG,EAAE,CAAC;gBAChC,MAAM,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC;gBACvC,wEAAwE;gBACxE,mEAAmE;gBACnE,+DAA+D;gBAC/D,oEAAoE;gBACpE,sEAAsE;gBACtE,0DAA0D;gBAC1D,0EAA0E;gBAC1E,IAAI,QAAQ,CAAC,IAAI,CAAC,SAAS,KAAK,gBAAgB,IAAI,CAAC,EAAE,CAAC;oBACtD,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,0EAA0E;gBAC1E,6EAA6E;gBAC7E,4EAA4E;gBAC5E,0EAA0E;gBAC1E,MAAM,CAAC,IAAI,CAAC,kFAAkF,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;gBACtH,WAAW,CAAC,uBAAuB,EAAE,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,CAAC,CAAC;gBACnG,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;YAC5F,CAAC;YAED,IAAI,QAAQ,CAAC,UAAU,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;gBAC1D,IAAI,uBAAuB,EAAE,CAAC;oBAC5B,MAAM,CAAC,IAAI,CAAC,kEAAkE,EAAE;wBAC9E,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,CAAC,UAAU;qBAClD,CAAC,CAAC;oBACH,WAAW,CAAC,uBAAuB,EAAE,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC;oBAC5F,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;gBAC5F,CAAC;gBACD,sEAAsE;gBACtE,MAAM,CAAC,IAAI,CAAC,mEAAmE,EAAE;oBAC/E,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,CAAC,UAAU;iBAClD,CAAC,CAAC;gBACH,WAAW,CAAC,yBAAyB,EAAE,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC;gBAC9F,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC;YACzF,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,YAAY,CAAE,KAAa,EAC/B,MAA0C,EAC1C,UAAkB,EAClB,SAAkB;YAElB,MAAM,IAAI,GAAG,WAAW,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAAC;YAEpD,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,YAAY,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,CAAC,CAAC;YAEzG,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,UAAU,KAAK,GAAG,EAAE,CAAC;gBAC7C,MAAM,CAAC,IAAI,CAAC,+BAA+B,EAAE;oBAC3C,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU;iBAChD,CAAC,CAAC;gBACH,OAAO,KAAK,CAAC;YACf,CAAC;YAED,MAAM,CAAC,IAAI,CAAC,sBAAsB,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;YACvD,OAAO,IAAI,CAAC;QACd,CAAC;QAED,KAAK,CAAC,OAAO,CAAC,KAAa,EAAE,UAAkB,EAAE,SAAkB;YACjE,MAAM,IAAI,GAAG,WAAW,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAAC;YAEpD,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,IAAI,QAAQ,CAAC,UAAU,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;gBACvE,MAAM,CAAC,IAAI,CAAC,sDAAsD,YAAY,OAAO,EAAE;oBACrF,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY;iBACnE,CAAC,CAAC;gBACH,WAAW,CAAC,uBAAuB,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,aAAa,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,CAAC;gBAC5H,OAAO,YAAY,CAAC;YACtB,CAAC;YAED,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC;YAC7C,OAAO,IAAI,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA,CAAC,CAAC,YAAY,CAAC;QACxD,CAAC;QAED,KAAK,CAAC,KAAK,CAAC,KAAa,EAAE,SAAqB,EAAE,UAAmB,EAAE,SAAkB;YACvF,MAAM,IAAI,GAAG,WAAW,kBAAkB,CAAC,KAAK,CAAC,QAAQ,CAAC;YAE1D,MAAM,IAAI,GAAG,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAA,CAAC,CAAC,EAAE,CAAC;YAC3C,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,YAAY,CAAC,KAAK,EAAE,UAAU,IAAI,EAAE,EAAE,SAAS,CAAC,EAAE,CAAC,CAAC;YAE9G,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,UAAU,KAAK,GAAG,EAAE,CAAC;gBAC7C,MAAM,CAAC,IAAI,CAAC,uBAAuB,EAAE;oBACnC,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU;iBACnD,CAAC,CAAC;gBACH,OAAO,KAAK,CAAC;YACf,CAAC;YAED,MAAM,CAAC,IAAI,CAAC,aAAa,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,IAAI,KAAK,EAAE,CAAC,CAAC;YACrE,OAAO,IAAI,CAAC;QACd,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,cAAc,CAAE,YAA0B,EACxD,KAAa,EACb,SAAoB,EACpB,UAAkB,EAClB,OAAkD;IAElD,YAAY,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC,KAAK,CAAC,CAAC,GAAY,EAAE,EAAE,CAC1E,OAAO,CAAC,wBAAwB,EAAE,EAAE,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAA,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAC9F,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;;;;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,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAA,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAC7F,CAAC;AACJ,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createSafeClient, type RequestOptions } from './http-client.js';\nimport type { QuotaType, QuotaCheckResult, ServiceConfig } from '../types/common.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';\n\n/** Retry options for quota calls  fail fast since quota is fail-open. */\nconst QUOTA_REQUEST_OPTIONS: Pick<RequestOptions, 'maxRateLimitRetries' | 'maxRetries'> = {\n  maxRateLimitRetries: 1,\n  maxRetries: 1,\n};\n\nconst logger = createLogger('quota');\n\n// `reserve` gates EXPENSIVE resources (plugin builds, pipelines). When the\n// quota service is reachable but returns an error (often an OVERLOADED service),\n// failing open would pile unmetered expensive work onto it and bypass quota\n// entirely — the textbook fail-open blow-up. So `reserve` fails CLOSED on an\n// errored response by default. Operators who prefer availability over\n// enforcement can opt back into fail-open with QUOTA_RESERVE_FAIL_OPEN=true.\n// (A genuinely UNREACHABLE service still fails open — that's a confirmed outage,\n// not an overload signal.)\nconst QUOTA_RESERVE_FAIL_OPEN = process.env.QUOTA_RESERVE_FAIL_OPEN === 'true';\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  exceeded: 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   * Fail-open semantics on transport errors: returns `exceeded: false` so\n   * the caller can proceed and the request isn't blocked by quota-service\n   * outages (matches `check()`).\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  /** Update quota limits. Returns true on success. */\n  updateLimits(orgId: string, limits: Partial<Record<QuotaType, number>>, authHeader: string, requestId?: string): Promise<boolean>;\n  /** Reset quota usage. Returns true on success. */\n  reset(orgId: string, quotaType?: QuotaType, authHeader?: string, requestId?: string): Promise<boolean>;\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\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 * 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 ?? process.env.QUOTA_SERVICE_HOST ?? 'quota',\n    port: config.port ?? parseInt(process.env.QUOTA_SERVICE_PORT ?? '3000', 10),\n    timeout: config.timeout ?? 5000,\n  };\n\n  const client = createSafeClient(serviceConfig);\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        errorCode?: string;\n      }>(path, { quotaType, amount }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response) {\n        logger.warn('QUOTA_FAIL_OPEN: Quota service unreachable on reserve, allowing request', { orgId, quotaType });\n        emitCounter('quota_fail_open_total', { operation: 'reserve', reason: 'unreachable', quotaType });\n        return { exceeded: false, quota: { type: quotaType, limit: -1, used: 0, remaining: -1 } };\n      }\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        // the quota service's OWN rate limiter (RATE_LIMIT_EXCEEDED) or an\n        // intervening gateway during a spike — must NOT be surfaced as\n        // quota-exceeded: that would falsely block legitimate work behind a\n        // transient rate limit. Require the QUOTA_EXCEEDED error code (or the\n        // quota payload) and otherwise fall through to the non-ok\n        // fail-open/closed policy below (the right handling for a transient 429).\n        if (response.body.errorCode === 'QUOTA_EXCEEDED' || q) {\n          return {\n            exceeded: true,\n            quota: q ?? { type: quotaType, limit: 0, used: 0, remaining: 0 },\n          };\n        }\n        // A non-QUOTA_EXCEEDED 429 is a TRANSIENT signal (the quota service's own\n        // rate limiter, or a gateway during a spike) — the tenant is NOT over quota,\n        // so fail OPEN (as for an unreachable service) rather than falsely blocking\n        // legitimate work. Do not fall through to the fail-closed non-ok default.\n        logger.warn('QUOTA_FAIL_OPEN: transient 429 on reserve (not quota-exceeded), allowing request', { orgId, quotaType });\n        emitCounter('quota_fail_open_total', { operation: 'reserve', reason: 'transient-429', quotaType });\n        return { exceeded: false, quota: { type: quotaType, limit: -1, used: 0, remaining: -1 } };\n      }\n\n      if (response.statusCode !== 200 || !response.body.success) {\n        if (QUOTA_RESERVE_FAIL_OPEN) {\n          logger.warn('QUOTA_FAIL_OPEN: Quota reserve returned non-ok, allowing request', {\n            orgId, quotaType, statusCode: response.statusCode,\n          });\n          emitCounter('quota_fail_open_total', { operation: 'reserve', reason: 'non-ok', quotaType });\n          return { exceeded: false, quota: { type: quotaType, limit: -1, used: 0, remaining: -1 } };\n        }\n        // Service reachable but didn't confirm the reservation → fail CLOSED.\n        logger.warn('QUOTA_FAIL_CLOSED: Quota reserve returned non-ok, denying request', {\n          orgId, quotaType, statusCode: response.statusCode,\n        });\n        emitCounter('quota_fail_closed_total', { operation: 'reserve', reason: 'non-ok', quotaType });\n        return { exceeded: true, quota: { type: quotaType, limit: 0, used: 0, remaining: 0 } };\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 updateLimits( orgId: string,\n      limits: Partial<Record<QuotaType, number>>,\n      authHeader: string,\n      requestId?: string,\n    ): Promise<boolean> {\n      const path = `/quotas/${encodeURIComponent(orgId)}`;\n\n      const response = await client.put(path, limits, { headers: buildHeaders(orgId, authHeader, requestId) });\n\n      if (!response || response.statusCode !== 200) {\n        logger.warn('Failed to update quota limits', {\n          orgId, limits, statusCode: response?.statusCode,\n        });\n        return false;\n      }\n\n      logger.info('Quota limits updated', { orgId, limits });\n      return true;\n    },\n\n    async getTier(orgId: string, authHeader: string, requestId?: string): Promise<QuotaTier> {\n      const path = `/quotas/${encodeURIComponent(orgId)}`;\n\n      const response = await client.get<{\n        success: boolean;\n        data?: { quota?: { tier?: string } };\n        message?: string;\n      }>(path, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response || response.statusCode !== 200 || !response.body.success) {\n        logger.warn(`QUOTA_FAIL_OPEN: tier lookup failed, defaulting to ${DEFAULT_TIER} tier`, {\n          orgId, statusCode: response?.statusCode, defaultTier: DEFAULT_TIER,\n        });\n        emitCounter('quota_fail_open_total', { operation: 'tier', reason: response ? 'non-ok' : 'unreachable', quotaType: 'tier' });\n        return DEFAULT_TIER;\n      }\n\n      const tier = response.body.data?.quota?.tier;\n      return tier && isValidTier(tier) ? tier: DEFAULT_TIER;\n    },\n\n    async reset(orgId: string, quotaType?: QuotaType, authHeader?: string, requestId?: string): Promise<boolean> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/reset`;\n\n      const body = quotaType ? { quotaType }: {};\n      const response = await client.post(path, body, { headers: buildHeaders(orgId, authHeader ?? '', requestId) });\n\n      if (!response || response.statusCode !== 200) {\n        logger.warn('Failed to reset quota', {\n          orgId, quotaType, statusCode: response?.statusCode,\n        });\n        return false;\n      }\n\n      logger.info('Quota reset', { orgId, quotaType: quotaType ?? 'all' });\n      return true;\n    },\n  };\n}\n\n/**\n * Fire-and-forget quota increment with standardized error logging.\n *\n * Wraps `quotaService.increment()` with a `.catch()` that logs a warning.\n * Eliminates the identical one-liner repeated across every read route.\n *\n * @param quotaService - Quota service client\n * @param orgId - Organization ID\n * @param quotaType - Quota type to increment\n * @param authHeader - Authorization header value\n * @param logWarn - Logging function for warnings\n */\nexport function incrementQuota( quotaService: QuotaService,\n  orgId: string,\n  quotaType: QuotaType,\n  authHeader: string,\n  logWarn: (message: string, data?: unknown) => void,\n): void {\n  quotaService.increment(orgId, quotaType, authHeader).catch((err: unknown) =>\n    logWarn('Quota increment failed', { error: err instanceof Error ? err.message: String(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 sendQuotaExceeded(res, 'pipelines', reservation.quota);\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/**\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: err instanceof Error ? err.message: String(err) }),\n  );\n}\n"]}