@pipeline-builder/api-core 5.2.5 → 5.2.7

package/lib/utils/aws-scrub.js

@@ -5,8 +5,8 @@
  * outbound payload (audit `details`, ingested event `detail`, error messages).
  *
  * HARD CONSTRAINT: an AWS account id must NEVER be persisted anywhere in this
- * system — `orgId` is the marketplace `customerIdentifier`, never an AWS account
- * id. AWS surfaces (CodePipeline/CodeBuild failure messages, KMS/role ARNs) leak
+ * system — `orgId` is the platform org id (a Marketplace customer is keyed on its
+ * license ARN, in subscription metadata), never an AWS account id. AWS surfaces (CodePipeline/CodeBuild failure messages, KMS/role ARNs) leak
  * the account id as the 5th ARN segment or as a bare 12-digit token, so scrub at
  * every boundary that writes untrusted AWS-derived text. Defense-in-depth: apply
  * this even when an upstream (e.g. the events Lambda) is expected to have
@@ -64,4 +64,4 @@ export function scrubAwsIdentifiers(value) {
     }
     return value;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXdzLXNjcnViLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL2F3cy1zY3J1Yi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDOzs7Ozs7Ozs7OztHQVdHO0FBRUgsTUFBTSxRQUFRLEdBQUcsWUFBWSxDQUFDO0FBRTlCOzs7O0dBSUc7QUFDSCxNQUFNLGlCQUFpQixHQUFHLHNCQUFzQixDQUFDO0FBRWpELG9GQUFvRjtBQUNwRixNQUFNLGNBQWMsR0FBRyxVQUFVLENBQUM7QUFFbEMsbUdBQW1HO0FBQ25HLE1BQU0sVUFBVSw2QkFBNkIsQ0FBQyxLQUFhO0lBQ3pELE9BQU8sS0FBSyxDQUFDLE9BQU8sQ0FBQyxpQkFBaUIsRUFBRSxRQUFRLENBQUMsQ0FBQztBQUNwRCxDQUFDO0FBRUQ7Ozs7Ozs7R0FPRztBQUNILE1BQU0sVUFBVSxtQkFBbUIsQ0FBSSxLQUFRO0lBQzdDLElBQUksT0FBTyxLQUFLLEtBQUssUUFBUSxFQUFFLENBQUM7UUFDOUIsT0FBTyw2QkFBNkIsQ0FBQyxLQUFLLENBQWlCLENBQUM7SUFDOUQsQ0FBQztJQUNELElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQ3pCLE9BQU8sS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsbUJBQW1CLENBQUMsQ0FBQyxDQUFDLENBQWlCLENBQUM7SUFDbEUsQ0FBQztJQUNELElBQUksS0FBSyxJQUFJLE9BQU8sS0FBSyxLQUFLLFFBQVEsRUFBRSxDQUFDO1FBQ3ZDLDJFQUEyRTtRQUMzRSwwRUFBMEU7UUFDMUUsNkVBQTZFO1FBQzdFLCtFQUErRTtRQUMvRSw4RUFBOEU7UUFDOUUsMEVBQTBFO1FBQzFFLG9FQUFvRTtRQUNwRSxNQUFNLEtBQUssR0FBRyxNQUFNLENBQUMsY0FBYyxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQzNDLElBQUksS0FBSyxLQUFLLE1BQU0sQ0FBQyxTQUFTLElBQUksS0FBSyxLQUFLLElBQUk7WUFBRSxPQUFPLEtBQUssQ0FBQztRQUMvRCxNQUFNLEdBQUcsR0FBNEIsRUFBRSxDQUFDO1FBQ3hDLEtBQUssTUFBTSxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsSUFBSSxNQUFNLENBQUMsT0FBTyxDQUFDLEtBQWdDLENBQUMsRUFBRSxDQUFDO1lBQ3RFLElBQUksY0FBYyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxLQUFLLFFBQVEsSUFBSSxPQUFPLENBQUMsS0FBSyxRQUFRLENBQUMsRUFBRSxDQUFDO2dCQUMvRSxHQUFHLENBQUMsQ0FBQyxDQUFDLEdBQUcsUUFBUSxDQUFDO1lBQ3BCLENBQUM7aUJBQU0sQ0FBQztnQkFDTixHQUFHLENBQUMsQ0FBQyxDQUFDLEdBQUcsbUJBQW1CLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFDbEMsQ0FBQztRQUNILENBQUM7UUFDRCxPQUFPLEdBQVEsQ0FBQztJQUNsQixDQUFDO0lBQ0QsT0FBTyxLQUFLLENBQUM7QUFDZixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMjYgUGlwZWxpbmUgQnVpbGRlciBDb250cmlidXRvcnNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5cbi8qKlxuICogUmVkYWN0IEFXUyBhY2NvdW50IGlkZW50aWZpZXJzIGZyb20gdmFsdWVzIGhlYWRlZCBmb3IgYSBEVVJBQkxFIHN0b3JlIG9yIGFuXG4gKiBvdXRib3VuZCBwYXlsb2FkIChhdWRpdCBgZGV0YWlsc2AsIGluZ2VzdGVkIGV2ZW50IGBkZXRhaWxgLCBlcnJvciBtZXNzYWdlcykuXG4gKlxuICogSEFSRCBDT05TVFJBSU5UOiBhbiBBV1MgYWNjb3VudCBpZCBtdXN0IE5FVkVSIGJlIHBlcnNpc3RlZCBhbnl3aGVyZSBpbiB0aGlzXG4gKiBzeXN0ZW0g4oCUIGBvcmdJZGAgaXMgdGhlIG1hcmtldHBsYWNlIGBjdXN0b21lcklkZW50aWZpZXJgLCBuZXZlciBhbiBBV1MgYWNjb3VudFxuICogaWQuIEFXUyBzdXJmYWNlcyAoQ29kZVBpcGVsaW5lL0NvZGVCdWlsZCBmYWlsdXJlIG1lc3NhZ2VzLCBLTVMvcm9sZSBBUk5zKSBsZWFrXG4gKiB0aGUgYWNjb3VudCBpZCBhcyB0aGUgNXRoIEFSTiBzZWdtZW50IG9yIGFzIGEgYmFyZSAxMi1kaWdpdCB0b2tlbiwgc28gc2NydWIgYXRcbiAqIGV2ZXJ5IGJvdW5kYXJ5IHRoYXQgd3JpdGVzIHVudHJ1c3RlZCBBV1MtZGVyaXZlZCB0ZXh0LiBEZWZlbnNlLWluLWRlcHRoOiBhcHBseVxuICogdGhpcyBldmVuIHdoZW4gYW4gdXBzdHJlYW0gKGUuZy4gdGhlIGV2ZW50cyBMYW1iZGEpIGlzIGV4cGVjdGVkIHRvIGhhdmVcbiAqIHN0cmlwcGVkIGl0IOKAlCB0aGUgcGVyc2lzdGVuY2UgYm91bmRhcnkgbXVzdCBub3QgdHJ1c3QgdXBzdHJlYW0uXG4gKi9cblxuY29uc3QgUkVEQUNURUQgPSAnW1JFREFDVEVEXSc7XG5cbi8qKlxuICogQSAxMi1kaWdpdCBydW4gaXMgdGhlIEFXUyBhY2NvdW50LWlkIHNoYXBlIChhbmQgdGhlIGFjY291bnQgc2VnbWVudCBvZiBldmVyeVxuICogQVJOKS4gQm91bmRlZCBieSBub24tZGlnaXRzIHNvIHdlIG5ldmVyIGNsaXAgaW5zaWRlIGEgbG9uZ2VyIG51bWJlciAoZS5nLiBhXG4gKiAxMy1kaWdpdCBtaWxsaXNlY29uZCB0aW1lc3RhbXAgaXMgbGVmdCBpbnRhY3QpLlxuICovXG5jb25zdCBBV1NfQUNDT1VOVF9JRF9SRSA9IC8oPzwhXFxkKVxcZHsxMn0oPyFcXGQpL2c7XG5cbi8qKiBLZXlzIHRoYXQgbmFtZSBhbiBBV1MgYWNjb3VudCBpZCBvdXRyaWdodCDigJQgdGhlaXIgdmFsdWUgaXMgZHJvcHBlZCB3aG9sZXNhbGUuICovXG5jb25zdCBBQ0NPVU5UX0tFWV9SRSA9IC9hY2NvdW50L2k7XG5cbi8qKiBSZWRhY3QgZXZlcnkgQVdTLWFjY291bnQtaWQtc2hhcGVkIHRva2VuIChpbmNsLiB0aGUgYWNjb3VudCBmaWVsZCBvZiBhbnkgQVJOKSBmcm9tIGEgc3RyaW5nLiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHNjcnViQXdzSWRlbnRpZmllcnNGcm9tU3RyaW5nKGlucHV0OiBzdHJpbmcpOiBzdHJpbmcge1xuICByZXR1cm4gaW5wdXQucmVwbGFjZShBV1NfQUNDT1VOVF9JRF9SRSwgUkVEQUNURUQpO1xufVxuXG4vKipcbiAqIERlZXAtc2NydWIgYSB2YWx1ZSAoc3RyaW5nIC8gYXJyYXkgLyBwbGFpbiBvYmplY3QpIG9mIEFXUyBhY2NvdW50IGlkZW50aWZpZXJzLFxuICogcmV0dXJuaW5nIGEgc2NydWJiZWQgY29weSDigJQgdGhlIGlucHV0IGlzIG5ldmVyIG11dGF0ZWQuIFN0cmluZyB2YWx1ZXMgaGF2ZVxuICogYWNjb3VudC1pZCB0b2tlbnMgcmVkYWN0ZWQ7IGFueSBrZXkgbWF0Y2hpbmcge0BsaW5rIEFDQ09VTlRfS0VZX1JFfSB3aXRoIGFcbiAqIHN0cmluZy9udW1iZXIgdmFsdWUgaXMgcmVkYWN0ZWQgd2hvbGVzYWxlLiBOb24tc3RyaW5nIHByaW1pdGl2ZXMgcGFzcyB0aHJvdWdoXG4gKiB1bmNoYW5nZWQgKGEgYmFyZSBudW1iZXIgaXMgb25seSByZWRhY3RlZCB3aGVuIGl0IHNpdHMgdW5kZXIgYW4gYWNjb3VudC1uYW1lZFxuICoga2V5LCB0byBhdm9pZCBjbG9iYmVyaW5nIGxlZ2l0aW1hdGUgbnVtZXJpYyBmaWVsZHMpLlxuICovXG5leHBvcnQgZnVuY3Rpb24gc2NydWJBd3NJZGVudGlmaWVyczxUPih2YWx1ZTogVCk6IFQge1xuICBpZiAodHlwZW9mIHZhbHVlID09PSAnc3RyaW5nJykge1xuICAgIHJldHVybiBzY3J1YkF3c0lkZW50aWZpZXJzRnJvbVN0cmluZyh2YWx1ZSkgYXMgdW5rbm93biBhcyBUO1xuICB9XG4gIGlmIChBcnJheS5pc0FycmF5KHZhbHVlKSkge1xuICAgIHJldHVybiB2YWx1ZS5tYXAoKHYpID0+IHNjcnViQXdzSWRlbnRpZmllcnModikpIGFzIHVua25vd24gYXMgVDtcbiAgfVxuICBpZiAodmFsdWUgJiYgdHlwZW9mIHZhbHVlID09PSAnb2JqZWN0Jykge1xuICAgIC8vIFJlY3Vyc2UgcGxhaW4gQU5EIG51bGwtcHJvdG90eXBlIG9iamVjdHMgKGRhdGEgYmFncykuIEEgRGF0ZS9CdWZmZXIvTWFwL1xuICAgIC8vIGNsYXNzIGluc3RhbmNlIGlzIE5PVCBhIHBsYWluIG9iamVjdCwgYW5kIHdhbGtpbmcgaXQgdmlhIE9iamVjdC5lbnRyaWVzXG4gICAgLy8gd291bGQgY2xvYmJlciBpdCB0byBge31gIChvciBhIGJ5dGUgbWFwKSDigJQgc2lsZW50bHkgZGVzdHJveWluZyBlLmcuIGEgRGF0ZVxuICAgIC8vIGhlbGQgaW4gYXVkaXQgYGRldGFpbHNgLiBCdXQgYSBudWxsLXByb3RvdHlwZSBvYmplY3QgKGBPYmplY3QuY3JlYXRlKG51bGwpYCxcbiAgICAvLyBzb21lIEpTT04ucGFyc2UgcmV2aXZlcnMsIEJTT04gZG9jcykgaXMgYSBwbGFpbiBkYXRhIGJhZyB0aGF0IG11c3Qgc3RpbGwgYmVcbiAgICAvLyBzY3J1YmJlZCDigJQgc2tpcHBpbmcgaXQgd2FzIGEgaG9sZSBhdCB0aGUgdmVyeSBwZXJzaXN0ZW5jZSBib3VuZGFyeSB0aGlzXG4gICAgLy8gbW9kdWxlIGd1YXJkcy4gTGVhdmUgb25seSBwcm90b3R5cGVkIG5vbi1wbGFpbiBvYmplY3RzIHVudG91Y2hlZC5cbiAgICBjb25zdCBwcm90byA9IE9iamVjdC5nZXRQcm90b3R5cGVPZih2YWx1ZSk7XG4gICAgaWYgKHByb3RvICE9PSBPYmplY3QucHJvdG90eXBlICYmIHByb3RvICE9PSBudWxsKSByZXR1cm4gdmFsdWU7XG4gICAgY29uc3Qgb3V0OiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPiA9IHt9O1xuICAgIGZvciAoY29uc3QgW2ssIHZdIG9mIE9iamVjdC5lbnRyaWVzKHZhbHVlIGFzIFJlY29yZDxzdHJpbmcsIHVua25vd24+KSkge1xuICAgICAgaWYgKEFDQ09VTlRfS0VZX1JFLnRlc3QoaykgJiYgKHR5cGVvZiB2ID09PSAnc3RyaW5nJyB8fCB0eXBlb2YgdiA9PT0gJ251bWJlcicpKSB7XG4gICAgICAgIG91dFtrXSA9IFJFREFDVEVEO1xuICAgICAgfSBlbHNlIHtcbiAgICAgICAgb3V0W2tdID0gc2NydWJBd3NJZGVudGlmaWVycyh2KTtcbiAgICAgIH1cbiAgICB9XG4gICAgcmV0dXJuIG91dCBhcyBUO1xuICB9XG4gIHJldHVybiB2YWx1ZTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/compliance-attributes.js

@@ -65,4 +65,4 @@ export function toComplianceAttributes(value) {
     }
     return value; // primitives, Date, null — untouched
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/concurrency-gate.d.ts

@@ -0,0 +1,98 @@
+/**
+ * A FIFO bound on how many things run at once in ONE process.
+ *
+ * WHY IT IS SHARED. Two services need the same bound for the same reason: a
+ * resource they own is consumed by work several producers queue, and the
+ * producers' count is set elsewhere. The image registry signs images (each
+ * attest hands cosign a 7-17 MiB SBOM against a 1 GiB container), and a plugin
+ * replica runs builds (its six per-tier workers share ONE buildkitd sidecar).
+ * Both learned it the same way: 32 concurrent signs OOMKilled the registry and
+ * took every push with it, because `/token` is the registry login.
+ *
+ * The queue hand-off below has one subtlety worth having a single copy of:
+ * `release` passes the slot straight to the next waiter instead of decrementing
+ * first, because a dip to `limit - 1` would admit an extra caller past the
+ * ceiling. That is the kind of off-by-one that a second implementation gets
+ * wrong silently.
+ *
+ * WAITING, NOT REFUSING. Over the limit a caller queues; nothing here refuses or
+ * times out. Refusing turns a capacity limit into a failure of the work, which
+ * is a mistake this codebase has already paid for once (a per-org build slot
+ * that failed terminally after a 30-minute wait lost 80 of 119 plugins). The
+ * caller's own deadline is what bounds the wait.
+ */
+export interface ConcurrencyGateOptions {
+    /** Read per call, so an env- or config-driven limit can change without a restart. */
+    limit: () => number;
+    /** Called when a caller has to wait, before it does. */
+    onQueued?: (waiting: number, limit: number) => void;
+    /** Called whenever occupancy changes, for a gauge. */
+    onOccupancy?: (inFlight: number) => void;
+}
+export interface ConcurrencyGate {
+    /** Run `fn` holding a slot. */
+    run<T>(fn: () => Promise<T>): Promise<T>;
+    /** Current occupancy — for metrics and tests. */
+    state(): {
+        inFlight: number;
+        waiting: number;
+    };
+    /** Test seam: drop a queue left behind by a failed assertion. */
+    reset(): void;
+}
+export declare function createConcurrencyGate(opts: ConcurrencyGateOptions): ConcurrencyGate;
+/** Occupancy a {@link KeyedConcurrencyGateOptions.admits} predicate decides on. */
+export interface KeyedOccupancy<K> {
+    /** Slots in use across every key. */
+    total: number;
+    /** Slots in use per key. Keys at zero may be absent. */
+    perKey: ReadonlyMap<K, number>;
+}
+export interface KeyedConcurrencyGateOptions<K> {
+    /** The TOTAL ceiling, read per call. No key may push occupancy past it. */
+    limit: () => number;
+    /**
+     * May a caller for `key` start right now?
+     *
+     * Called only when the total ceiling has room, so this expresses the per-key
+     * policy alone — a guaranteed floor, a cap, a borrowing allowance. It must be
+     * a pure function of the occupancy it is handed: it is re-evaluated on every
+     * release, and a predicate that consults anything else (a clock, a counter it
+     * mutates) makes admission order unreproducible.
+     */
+    admits: (key: K, occupancy: KeyedOccupancy<K>) => boolean;
+    onQueued?: (key: K, waiting: number, limit: number) => void;
+    onOccupancy?: (occupancy: KeyedOccupancy<K>) => void;
+}
+export interface KeyedConcurrencyGate<K> {
+    run<T>(key: K, fn: () => Promise<T>): Promise<T>;
+    state(): {
+        inFlight: number;
+        waiting: number;
+        perKey: ReadonlyMap<K, number>;
+    };
+    reset(): void;
+}
+/**
+ * A FIFO bound with a TOTAL ceiling plus a per-key admission policy.
+ *
+ * WHY A SECOND SHAPE instead of nesting two of the gates above. Stacking a
+ * per-key gate inside the total gate DEADLOCKS: a caller holding a total slot
+ * while it waits for a key slot can hold every total slot, and nothing will
+ * ever release one. Admission has to be ONE decision, which is what this is.
+ *
+ * THE HAND-OFF DIFFERS FROM THE COUNT GATE ABOVE, deliberately. There, release
+ * passes the slot straight to the head of the queue, because for a pure count
+ * any waiter is admissible. Here the head may NOT be — it could be a caller
+ * whose key is over its floor while the borrowing allowance is full. So release
+ * decrements first and then scans the queue for the first waiter the predicate
+ * now admits. Occupancy may therefore dip below the ceiling while callers wait,
+ * which is correct: those callers are not admissible, and admitting them anyway
+ * is exactly the bound this exists to enforce.
+ *
+ * ORDER. Relative order is preserved among waiters the predicate admits, so
+ * callers sharing a key are strictly FIFO. Across keys it is not: a waiter that
+ * cannot start is skipped rather than blocking the queue behind it, which is the
+ * point — a blocked borrower must not stall a caller that is within its floor.
+ */
+export declare function createKeyedConcurrencyGate<K>(opts: KeyedConcurrencyGateOptions<K>): KeyedConcurrencyGate<K>;

package/lib/utils/concurrency-gate.js

@@ -0,0 +1,110 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+export function createConcurrencyGate(opts) {
+    let inFlight = 0;
+    const waiting = [];
+    const occupancy = () => opts.onOccupancy?.(inFlight);
+    function release() {
+        const next = waiting.shift();
+        if (next) {
+            // Straight hand-off: see the note above about never dipping below the
+            // ceiling between a release and the next admission.
+            next();
+            return;
+        }
+        inFlight -= 1;
+        occupancy();
+    }
+    return {
+        async run(fn) {
+            const limit = opts.limit();
+            if (inFlight >= limit) {
+                opts.onQueued?.(waiting.length + 1, limit);
+                await new Promise((resolve) => { waiting.push(resolve); });
+            }
+            else {
+                inFlight += 1;
+            }
+            occupancy();
+            try {
+                return await fn();
+            }
+            finally {
+                release();
+            }
+        },
+        state: () => ({ inFlight, waiting: waiting.length }),
+        reset: () => { inFlight = 0; waiting.length = 0; },
+    };
+}
+/**
+ * A FIFO bound with a TOTAL ceiling plus a per-key admission policy.
+ *
+ * WHY A SECOND SHAPE instead of nesting two of the gates above. Stacking a
+ * per-key gate inside the total gate DEADLOCKS: a caller holding a total slot
+ * while it waits for a key slot can hold every total slot, and nothing will
+ * ever release one. Admission has to be ONE decision, which is what this is.
+ *
+ * THE HAND-OFF DIFFERS FROM THE COUNT GATE ABOVE, deliberately. There, release
+ * passes the slot straight to the head of the queue, because for a pure count
+ * any waiter is admissible. Here the head may NOT be — it could be a caller
+ * whose key is over its floor while the borrowing allowance is full. So release
+ * decrements first and then scans the queue for the first waiter the predicate
+ * now admits. Occupancy may therefore dip below the ceiling while callers wait,
+ * which is correct: those callers are not admissible, and admitting them anyway
+ * is exactly the bound this exists to enforce.
+ *
+ * ORDER. Relative order is preserved among waiters the predicate admits, so
+ * callers sharing a key are strictly FIFO. Across keys it is not: a waiter that
+ * cannot start is skipped rather than blocking the queue behind it, which is the
+ * point — a blocked borrower must not stall a caller that is within its floor.
+ */
+export function createKeyedConcurrencyGate(opts) {
+    let total = 0;
+    const perKey = new Map();
+    const waiting = [];
+    const snapshot = () => ({ total, perKey });
+    const occupancy = () => opts.onOccupancy?.(snapshot());
+    const bump = (key, by) => {
+        const next = (perKey.get(key) ?? 0) + by;
+        if (next <= 0)
+            perKey.delete(key);
+        else
+            perKey.set(key, next);
+        total += by;
+    };
+    const admissible = (key) => total < opts.limit() && opts.admits(key, snapshot());
+    function release(key) {
+        bump(key, -1);
+        // Scan in arrival order for the first waiter that may now start. Not the
+        // blind hand-off of the count gate — see the note above.
+        const index = waiting.findIndex((w) => admissible(w.key));
+        if (index !== -1) {
+            const [next] = waiting.splice(index, 1);
+            bump(next.key, 1);
+            next.admit();
+        }
+        occupancy();
+    }
+    return {
+        async run(key, fn) {
+            if (admissible(key)) {
+                bump(key, 1);
+            }
+            else {
+                opts.onQueued?.(key, waiting.length + 1, opts.limit());
+                await new Promise((resolve) => { waiting.push({ key, admit: resolve }); });
+            }
+            occupancy();
+            try {
+                return await fn();
+            }
+            finally {
+                release(key);
+            }
+        },
+        state: () => ({ inFlight: total, waiting: waiting.length, perKey }),
+        reset: () => { total = 0; perKey.clear(); waiting.length = 0; },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"concurrency-gate.js","sources":["../../src/utils/concurrency-gate.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AA4CtC,MAAM,UAAU,qBAAqB,CAAC,IAA4B;IAChE,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,MAAM,OAAO,GAAsB,EAAE,CAAC;IAEtC,MAAM,SAAS,GAAG,GAAS,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,CAAC;IAE3D,SAAS,OAAO;QACd,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;QAC7B,IAAI,IAAI,EAAE,CAAC;YACT,sEAAsE;YACtE,oDAAoD;YACpD,IAAI,EAAE,CAAC;YACP,OAAO;QACT,CAAC;QACD,QAAQ,IAAI,CAAC,CAAC;QACd,SAAS,EAAE,CAAC;IACd,CAAC;IAED,OAAO;QACL,KAAK,CAAC,GAAG,CAAI,EAAoB;YAC/B,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;YAC3B,IAAI,QAAQ,IAAI,KAAK,EAAE,CAAC;gBACtB,IAAI,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;gBAC3C,MAAM,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACnE,CAAC;iBAAM,CAAC;gBACN,QAAQ,IAAI,CAAC,CAAC;YAChB,CAAC;YACD,SAAS,EAAE,CAAC;YACZ,IAAI,CAAC;gBACH,OAAO,MAAM,EAAE,EAAE,CAAC;YACpB,CAAC;oBAAS,CAAC;gBACT,OAAO,EAAE,CAAC;YACZ,CAAC;QACH,CAAC;QACD,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC;QACpD,KAAK,EAAE,GAAG,EAAE,GAAG,QAAQ,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;KACnD,CAAC;AACJ,CAAC;AAqCD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,0BAA0B,CAAI,IAAoC;IAChF,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,MAAM,MAAM,GAAG,IAAI,GAAG,EAAa,CAAC;IACpC,MAAM,OAAO,GAAyC,EAAE,CAAC;IAEzD,MAAM,QAAQ,GAAG,GAAsB,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;IAC9D,MAAM,SAAS,GAAG,GAAS,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAC;IAE7D,MAAM,IAAI,GAAG,CAAC,GAAM,EAAE,EAAU,EAAQ,EAAE;QACxC,MAAM,IAAI,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,CAAC;QACzC,IAAI,IAAI,IAAI,CAAC;YAAE,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;;YAAM,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QAC9D,KAAK,IAAI,EAAE,CAAC;IACd,CAAC,CAAC;IAEF,MAAM,UAAU,GAAG,CAAC,GAAM,EAAW,EAAE,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,EAAE,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAC;IAE7F,SAAS,OAAO,CAAC,GAAM;QACrB,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QACd,yEAAyE;QACzE,yDAAyD;QACzD,MAAM,KAAK,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAC1D,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;YACjB,MAAM,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YACxC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;YAClB,IAAI,CAAC,KAAK,EAAE,CAAC;QACf,CAAC;QACD,SAAS,EAAE,CAAC;IACd,CAAC;IAED,OAAO;QACL,KAAK,CAAC,GAAG,CAAI,GAAM,EAAE,EAAoB;YACvC,IAAI,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;gBACpB,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;YACf,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;gBACvD,MAAM,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACnF,CAAC;YACD,SAAS,EAAE,CAAC;YACZ,IAAI,CAAC;gBACH,OAAO,MAAM,EAAE,EAAE,CAAC;YACpB,CAAC;oBAAS,CAAC;gBACT,OAAO,CAAC,GAAG,CAAC,CAAC;YACf,CAAC;QACH,CAAC;QACD,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;QACnE,KAAK,EAAE,GAAG,EAAE,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;KAChE,CAAC;AACJ,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * A FIFO bound on how many things run at once in ONE process.\n *\n * WHY IT IS SHARED. Two services need the same bound for the same reason: a\n * resource they own is consumed by work several producers queue, and the\n * producers' count is set elsewhere. The image registry signs images (each\n * attest hands cosign a 7-17 MiB SBOM against a 1 GiB container), and a plugin\n * replica runs builds (its six per-tier workers share ONE buildkitd sidecar).\n * Both learned it the same way: 32 concurrent signs OOMKilled the registry and\n * took every push with it, because `/token` is the registry login.\n *\n * The queue hand-off below has one subtlety worth having a single copy of:\n * `release` passes the slot straight to the next waiter instead of decrementing\n * first, because a dip to `limit - 1` would admit an extra caller past the\n * ceiling. That is the kind of off-by-one that a second implementation gets\n * wrong silently.\n *\n * WAITING, NOT REFUSING. Over the limit a caller queues; nothing here refuses or\n * times out. Refusing turns a capacity limit into a failure of the work, which\n * is a mistake this codebase has already paid for once (a per-org build slot\n * that failed terminally after a 30-minute wait lost 80 of 119 plugins). The\n * caller's own deadline is what bounds the wait.\n */\n\nexport interface ConcurrencyGateOptions {\n  /** Read per call, so an env- or config-driven limit can change without a restart. */\n  limit: () => number;\n  /** Called when a caller has to wait, before it does. */\n  onQueued?: (waiting: number, limit: number) => void;\n  /** Called whenever occupancy changes, for a gauge. */\n  onOccupancy?: (inFlight: number) => void;\n}\n\nexport interface ConcurrencyGate {\n  /** Run `fn` holding a slot. */\n  run<T>(fn: () => Promise<T>): Promise<T>;\n  /** Current occupancy — for metrics and tests. */\n  state(): { inFlight: number; waiting: number };\n  /** Test seam: drop a queue left behind by a failed assertion. */\n  reset(): void;\n}\n\nexport function createConcurrencyGate(opts: ConcurrencyGateOptions): ConcurrencyGate {\n  let inFlight = 0;\n  const waiting: Array<() => void> = [];\n\n  const occupancy = (): void => opts.onOccupancy?.(inFlight);\n\n  function release(): void {\n    const next = waiting.shift();\n    if (next) {\n      // Straight hand-off: see the note above about never dipping below the\n      // ceiling between a release and the next admission.\n      next();\n      return;\n    }\n    inFlight -= 1;\n    occupancy();\n  }\n\n  return {\n    async run<T>(fn: () => Promise<T>): Promise<T> {\n      const limit = opts.limit();\n      if (inFlight >= limit) {\n        opts.onQueued?.(waiting.length + 1, limit);\n        await new Promise<void>((resolve) => { waiting.push(resolve); });\n      } else {\n        inFlight += 1;\n      }\n      occupancy();\n      try {\n        return await fn();\n      } finally {\n        release();\n      }\n    },\n    state: () => ({ inFlight, waiting: waiting.length }),\n    reset: () => { inFlight = 0; waiting.length = 0; },\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Keyed variant: one ceiling, per-key floors, and borrowing\n// ---------------------------------------------------------------------------\n\n/** Occupancy a {@link KeyedConcurrencyGateOptions.admits} predicate decides on. */\nexport interface KeyedOccupancy<K> {\n  /** Slots in use across every key. */\n  total: number;\n  /** Slots in use per key. Keys at zero may be absent. */\n  perKey: ReadonlyMap<K, number>;\n}\n\nexport interface KeyedConcurrencyGateOptions<K> {\n  /** The TOTAL ceiling, read per call. No key may push occupancy past it. */\n  limit: () => number;\n  /**\n   * May a caller for `key` start right now?\n   *\n   * Called only when the total ceiling has room, so this expresses the per-key\n   * policy alone — a guaranteed floor, a cap, a borrowing allowance. It must be\n   * a pure function of the occupancy it is handed: it is re-evaluated on every\n   * release, and a predicate that consults anything else (a clock, a counter it\n   * mutates) makes admission order unreproducible.\n   */\n  admits: (key: K, occupancy: KeyedOccupancy<K>) => boolean;\n  onQueued?: (key: K, waiting: number, limit: number) => void;\n  onOccupancy?: (occupancy: KeyedOccupancy<K>) => void;\n}\n\nexport interface KeyedConcurrencyGate<K> {\n  run<T>(key: K, fn: () => Promise<T>): Promise<T>;\n  state(): { inFlight: number; waiting: number; perKey: ReadonlyMap<K, number> };\n  reset(): void;\n}\n\n/**\n * A FIFO bound with a TOTAL ceiling plus a per-key admission policy.\n *\n * WHY A SECOND SHAPE instead of nesting two of the gates above. Stacking a\n * per-key gate inside the total gate DEADLOCKS: a caller holding a total slot\n * while it waits for a key slot can hold every total slot, and nothing will\n * ever release one. Admission has to be ONE decision, which is what this is.\n *\n * THE HAND-OFF DIFFERS FROM THE COUNT GATE ABOVE, deliberately. There, release\n * passes the slot straight to the head of the queue, because for a pure count\n * any waiter is admissible. Here the head may NOT be — it could be a caller\n * whose key is over its floor while the borrowing allowance is full. So release\n * decrements first and then scans the queue for the first waiter the predicate\n * now admits. Occupancy may therefore dip below the ceiling while callers wait,\n * which is correct: those callers are not admissible, and admitting them anyway\n * is exactly the bound this exists to enforce.\n *\n * ORDER. Relative order is preserved among waiters the predicate admits, so\n * callers sharing a key are strictly FIFO. Across keys it is not: a waiter that\n * cannot start is skipped rather than blocking the queue behind it, which is the\n * point — a blocked borrower must not stall a caller that is within its floor.\n */\nexport function createKeyedConcurrencyGate<K>(opts: KeyedConcurrencyGateOptions<K>): KeyedConcurrencyGate<K> {\n  let total = 0;\n  const perKey = new Map<K, number>();\n  const waiting: Array<{ key: K; admit: () => void }> = [];\n\n  const snapshot = (): KeyedOccupancy<K> => ({ total, perKey });\n  const occupancy = (): void => opts.onOccupancy?.(snapshot());\n\n  const bump = (key: K, by: number): void => {\n    const next = (perKey.get(key) ?? 0) + by;\n    if (next <= 0) perKey.delete(key); else perKey.set(key, next);\n    total += by;\n  };\n\n  const admissible = (key: K): boolean => total < opts.limit() && opts.admits(key, snapshot());\n\n  function release(key: K): void {\n    bump(key, -1);\n    // Scan in arrival order for the first waiter that may now start. Not the\n    // blind hand-off of the count gate — see the note above.\n    const index = waiting.findIndex((w) => admissible(w.key));\n    if (index !== -1) {\n      const [next] = waiting.splice(index, 1);\n      bump(next.key, 1);\n      next.admit();\n    }\n    occupancy();\n  }\n\n  return {\n    async run<T>(key: K, fn: () => Promise<T>): Promise<T> {\n      if (admissible(key)) {\n        bump(key, 1);\n      } else {\n        opts.onQueued?.(key, waiting.length + 1, opts.limit());\n        await new Promise<void>((resolve) => { waiting.push({ key, admit: resolve }); });\n      }\n      occupancy();\n      try {\n        return await fn();\n      } finally {\n        release(key);\n      }\n    },\n    state: () => ({ inFlight: total, waiting: waiting.length, perKey }),\n    reset: () => { total = 0; perKey.clear(); waiting.length = 0; },\n  };\n}\n"]}

package/lib/utils/concurrency.js

@@ -38,4 +38,4 @@ export function sleep(ms, opts = {}) {
             timer.unref?.();
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uY3VycmVuY3kuanMiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9jb25jdXJyZW5jeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDOzs7Ozs7O0dBT0c7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLGFBQWEsQ0FDakMsS0FBVSxFQUNWLEtBQWEsRUFDYixNQUE4QztJQUU5QyxJQUFJLEtBQUssR0FBRyxDQUFDO1FBQUUsTUFBTSxJQUFJLEtBQUssQ0FBQyxtQ0FBbUMsQ0FBQyxDQUFDO0lBQ3BFLElBQUksS0FBSyxDQUFDLE1BQU0sS0FBSyxDQUFDO1FBQUUsT0FBTyxFQUFFLENBQUM7SUFFbEMsTUFBTSxPQUFPLEdBQUcsSUFBSSxLQUFLLENBQUksS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQzNDLElBQUksU0FBUyxHQUFHLENBQUMsQ0FBQztJQUVsQixNQUFNLE9BQU8sR0FBRyxLQUFLLENBQUMsSUFBSSxDQUFDLEVBQUUsTUFBTSxFQUFFLElBQUksQ0FBQyxHQUFHLENBQUMsS0FBSyxFQUFFLEtBQUssQ0FBQyxNQUFNLENBQUMsRUFBRSxFQUFFLEtBQUssSUFBSSxFQUFFO1FBQy9FLE9BQU8sSUFBSSxFQUFFLENBQUM7WUFDWixNQUFNLENBQUMsR0FBRyxTQUFTLEVBQUUsQ0FBQztZQUN0QixJQUFJLENBQUMsSUFBSSxLQUFLLENBQUMsTUFBTTtnQkFBRSxPQUFPO1lBQzlCLE9BQU8sQ0FBQyxDQUFDLENBQUMsR0FBRyxNQUFNLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUM7UUFDekMsQ0FBQztJQUNILENBQUMsQ0FBQyxDQUFDO0lBRUgsTUFBTSxPQUFPLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQzNCLE9BQU8sT0FBTyxDQUFDO0FBQ2pCLENBQUM7QUFFRDs7O0dBR0c7QUFDSCxNQUFNLFVBQVUsS0FBSyxDQUFDLEVBQVUsRUFBRSxJQUFJLEdBQXdCLEVBQUU7SUFDOUQsT0FBTyxJQUFJLE9BQU8sQ0FBQyxDQUFDLE9BQU8sRUFBRSxFQUFFO1FBQzdCLE1BQU0sS0FBSyxHQUFHLFVBQVUsQ0FBQyxPQUFPLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFDdEMsc0VBQXNFO1FBQ3RFLElBQUksSUFBSSxDQUFDLEtBQUs7WUFBRSxLQUFLLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FBQztJQUNsQyxDQUFDLENBQUMsQ0FBQztBQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuLyoqXG4gKiBSdW4gYHdvcmtlcmAgb3ZlciBgaXRlbXNgIHdpdGggYXQgbW9zdCBgbGltaXRgIGludm9jYXRpb25zIGluIGZsaWdodC5cbiAqIFByZXNlcnZlcyBvcmRlciBpbiB0aGUgcmV0dXJuZWQgYXJyYXkuIFJlamVjdHMgb24gdGhlIGZpcnN0IGVycm9yLlxuICpcbiAqIFVzZSB0aGlzIGFueXdoZXJlIHdlIGZhbiBvdXQgTiBIVFRQIGNhbGxzIGFuZCB3YW50IHRvIGNhcCBjb25jdXJyZW5jeVxuICogKGUuZy4gcmVnaXN0cnkgYmxvYiBtb3VudHMsIHBhcmFsbGVsIG1hbmlmZXN0IGZldGNoZXMpLiBIYW5kLXJvbGxlZCB0b1xuICogYXZvaWQgYWRkaW5nIGEgZGVwIOKAlCBrZWVwcyB0aGUgYnVuZGxlL2Zvb3RwcmludCB0aW55LlxuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gcnVuQ29uY3VycmVudDxULCBSPihcbiAgaXRlbXM6IFRbXSxcbiAgbGltaXQ6IG51bWJlcixcbiAgd29ya2VyOiAoaXRlbTogVCwgaW5kZXg6IG51bWJlcikgPT4gUHJvbWlzZTxSPixcbik6IFByb21pc2U8UltdPiB7XG4gIGlmIChsaW1pdCA8IDEpIHRocm93IG5ldyBFcnJvcigncnVuQ29uY3VycmVudDogbGltaXQgbXVzdCBiZSA+PSAxJyk7XG4gIGlmIChpdGVtcy5sZW5ndGggPT09IDApIHJldHVybiBbXTtcblxuICBjb25zdCByZXN1bHRzID0gbmV3IEFycmF5PFI+KGl0ZW1zLmxlbmd0aCk7XG4gIGxldCBuZXh0SW5kZXggPSAwO1xuXG4gIGNvbnN0IHJ1bm5lcnMgPSBBcnJheS5mcm9tKHsgbGVuZ3RoOiBNYXRoLm1pbihsaW1pdCwgaXRlbXMubGVuZ3RoKSB9LCBhc3luYyAoKSA9PiB7XG4gICAgd2hpbGUgKHRydWUpIHtcbiAgICAgIGNvbnN0IGkgPSBuZXh0SW5kZXgrKztcbiAgICAgIGlmIChpID49IGl0ZW1zLmxlbmd0aCkgcmV0dXJuO1xuICAgICAgcmVzdWx0c1tpXSA9IGF3YWl0IHdvcmtlcihpdGVtc1tpXSwgaSk7XG4gICAgfVxuICB9KTtcblxuICBhd2FpdCBQcm9taXNlLmFsbChydW5uZXJzKTtcbiAgcmV0dXJuIHJlc3VsdHM7XG59XG5cbi8qKlxuICogUmVzb2x2ZSBhZnRlciBgbXNgLiBXaXRoIGB1bnJlZmAsIHRoZSBwZW5kaW5nIHRpbWVyIG5ldmVyIGtlZXBzIGEgZHJhaW5pbmdcbiAqIHByb2Nlc3MgYWxpdmUgKGEgYmFja29mZiB3YWl0IG11c3Qgbm90IGJsb2NrIHNodXRkb3duKS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHNsZWVwKG1zOiBudW1iZXIsIG9wdHM6IHsgdW5yZWY/OiBib29sZWFuIH0gPSB7fSk6IFByb21pc2U8dm9pZD4ge1xuICByZXR1cm4gbmV3IFByb21pc2UoKHJlc29sdmUpID0+IHtcbiAgICBjb25zdCB0aW1lciA9IHNldFRpbWVvdXQocmVzb2x2ZSwgbXMpO1xuICAgIC8vIGB1bnJlZmAgaXMgYWJzZW50IG9uIHRoZSB0aW1lciBzaGltIHNvbWUgdGVzdCBlbnZpcm9ubWVudHMgaW5zdGFsbC5cbiAgICBpZiAob3B0cy51bnJlZikgdGltZXIudW5yZWY/LigpO1xuICB9KTtcbn1cbiJdfQ==

package/lib/utils/crash-handlers.js

@@ -33,4 +33,4 @@ export function installCrashHandlers(log = createLogger('process')) {
         fatal('Unhandled promise rejection', reason instanceof Error ? reason : new Error(String(reason)));
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/date.js

@@ -19,4 +19,4 @@
  * would hide a corrupt row behind a plausible-looking response.
  */
 export const isoOrNull = (d) => (d ? new Date(d).toISOString() : null);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZS5qcyIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL2RhdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQUV0Qyw0Q0FBNEM7QUFFNUM7Ozs7Ozs7Ozs7Ozs7Ozs7R0FnQkc7QUFDSCxNQUFNLENBQUMsTUFBTSxTQUFTLEdBQUcsQ0FBQyxDQUE0QyxFQUFpQixFQUFFLENBQ3ZGLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxXQUFXLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuLyoqIERhdGUgY29lcmNpb25zIGZvciB0aGUgSlNPTiBib3VuZGFyeS4gKi9cblxuLyoqXG4gKiBBIG51bGxhYmxlIHRpbWVzdGFtcCBhcyBhbiBJU08tODYwMSBzdHJpbmcsIG9yIGBudWxsYCB3aGVuIHRoZXJlIGlzIG5vIGRhdGUuXG4gKlxuICogVGhlIHNoYXBlIGV2ZXJ5IEFQSSByZXNwb25zZSBuZWVkcyBhdCB0aGUgRELihpJKU09OIGJvdW5kYXJ5OiBQb3N0Z3JlcyBhbmRcbiAqIE1vbmdvIGhhbmQgYmFjayBgRGF0ZSB8IG51bGxgLCB0aGUgd2lyZSB3YW50cyBgc3RyaW5nIHwgbnVsbGAsIGFuZCBhIGJhcmVcbiAqIGByb3cueD8udG9JU09TdHJpbmcoKSA/PyBudWxsYCBicmVha3MgdGhlIG1vbWVudCB0aGUgZHJpdmVyIHJldHVybnMgYSBzdHJpbmdcbiAqIGluc3RlYWQgKE1vbmdvIGFnZ3JlZ2F0aW9uIG91dHB1dCwgYSBgOjp0ZXh0YCBjYXN0LCBhIGNhY2hlZCByb3cgcmVoeWRyYXRlZFxuICogZnJvbSBKU09OKS4gTm9ybWFsaXppbmcgdGhyb3VnaCBgbmV3IERhdGUoZClgIGhhbmRsZXMgYm90aC5cbiAqXG4gKiBGYWxzeSBpbiwgYG51bGxgIG91dCDigJQgd2hpY2ggZm9sZHMgdGhlIGVwb2NoIChgbmV3IERhdGUoMClgKSB0byBgbnVsbGAgdG9vLlxuICogVGhhdCBpcyBpbnRlbnRpb25hbCBhbmQgbWF0Y2hlcyBldmVyeSBoYW5kLXJvbGxlZCBjb3B5IHRoaXMgcmVwbGFjZXM6IGFcbiAqIHplcm8gdGltZXN0YW1wIGluIHRoaXMgY29kZWJhc2UgbWVhbnMgXCJ1bnNldFwiLCBuZXZlciAxOTcwLlxuICpcbiAqIFRocm93cyBgUmFuZ2VFcnJvcmAgb24gYW4gdW5wYXJzZWFibGUgc3RyaW5nLCBkZWxpYmVyYXRlbHk6IGEgbWFsZm9ybWVkXG4gKiB0aW1lc3RhbXAgaXMgYSBkYXRhLWludGVncml0eSBwcm9ibGVtLCBhbmQgc2lsZW50bHkgc2VydmluZyBgbnVsbGAgZm9yIGl0XG4gKiB3b3VsZCBoaWRlIGEgY29ycnVwdCByb3cgYmVoaW5kIGEgcGxhdXNpYmxlLWxvb2tpbmcgcmVzcG9uc2UuXG4gKi9cbmV4cG9ydCBjb25zdCBpc29Pck51bGwgPSAoZDogRGF0ZSB8IHN0cmluZyB8IG51bWJlciB8IG51bGwgfCB1bmRlZmluZWQpOiBzdHJpbmcgfCBudWxsID0+XG4gIChkID8gbmV3IERhdGUoZCkudG9JU09TdHJpbmcoKSA6IG51bGwpO1xuIl19

package/lib/utils/dsse.js

@@ -52,4 +52,4 @@ export function extractPredicate(stdout, predicateType) {
     }
     return predicate;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHNzZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9kc3NlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLCtDQUErQztBQUMvQyxzQ0FBc0M7QUFFdEM7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBaUJHO0FBRUgsb0ZBQW9GO0FBQ3BGLE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUFHLDJCQUEyQixDQUFDO0FBRS9EOzs7Ozs7Ozs7O0dBVUc7QUFDSCxNQUFNLFVBQVUsZ0JBQWdCLENBQUMsTUFBYyxFQUFFLGFBQXFCO0lBQ3BFLElBQUksU0FBUyxHQUFtQyxJQUFJLENBQUM7SUFDckQsS0FBSyxNQUFNLElBQUksSUFBSSxNQUFNLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7UUFDdEMsTUFBTSxPQUFPLEdBQUcsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO1FBQzVCLElBQUksQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQztZQUFFLFNBQVM7UUFDdkMsSUFBSSxDQUFDO1lBQ0gsTUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQXlCLENBQUM7WUFDN0QsSUFBSSxDQUFDLFFBQVEsQ0FBQyxPQUFPO2dCQUFFLFNBQVM7WUFDaEMsTUFBTSxTQUFTLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxPQUFPLEVBQUUsUUFBUSxDQUFDLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxDQUdyRixDQUFDO1lBQ0YsSUFBSSxTQUFTLENBQUMsYUFBYSxLQUFLLGFBQWEsSUFBSSxTQUFTLENBQUMsU0FBUyxJQUFJLE9BQU8sU0FBUyxDQUFDLFNBQVMsS0FBSyxRQUFRLEVBQUUsQ0FBQztnQkFDaEgsU0FBUyxHQUFHLFNBQVMsQ0FBQyxTQUFvQyxDQUFDO1lBQzdELENBQUM7UUFDSCxDQUFDO1FBQUMsTUFBTSxDQUFDO1lBQ1Asd0JBQXdCO1FBQzFCLENBQUM7SUFDSCxDQUFDO0lBQ0QsT0FBTyxTQUFTLENBQUM7QUFDbkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG4vKipcbiAqIERTU0UtZW52ZWxvcGUgcGFyc2luZyBmb3IgY29zaWduIGF0dGVzdGF0aW9uIG91dHB1dC5cbiAqXG4gKiBgY29zaWduIHZlcmlmeS1hdHRlc3RhdGlvbmAgcHJpbnRzIG9uZSBEU1NFIGVudmVsb3BlIHBlciBWRVJJRklFRCBhdHRlc3RhdGlvbixcbiAqIG9uZSBKU09OIG9iamVjdCBwZXIgbGluZTpcbiAqIGB7IHBheWxvYWRUeXBlLCBwYXlsb2FkOiBiYXNlNjQoaW4tdG90byBzdGF0ZW1lbnQpLCBzaWduYXR1cmVzIH1gLlxuICogU2lnbmF0dXJlIHZlcmlmaWNhdGlvbiBoYXMgYWxyZWFkeSBoYXBwZW5lZCBpbiBjb3NpZ24gYnkgdGhlIHRpbWUgd2Ugc2VlIHRoaXNcbiAqIOKAlCB0aGlzIG1vZHVsZSBvbmx5IGRlY29kZXMgd2hhdCBjb3NpZ24gdm91Y2hlZCBmb3IuXG4gKlxuICogVGhpcyBsaXZlcyBpbiBhcGktY29yZSBiZWNhdXNlIEJPVEggdGhlIHBsdWdpbiBzZXJ2aWNlIChidWlsZC10aW1lIFNCT00gcmVhZClcbiAqIGFuZCB0aGUgaW1hZ2UtcmVnaXN0cnkgc2VydmljZSAocmVnaXN0cnktc2lkZSBzaWduZWQtU0JPTSByZWFkKSBwYXJzZSB0aGUgc2FtZVxuICogb3V0cHV0LiBUd28gaGFuZC1jb3BpZWQgcGFyc2UgbG9vcHMgaW4gc3VwcGx5LWNoYWluIHZlcmlmaWNhdGlvbiBjb2RlIGlzIGFcbiAqIHNlY3VyaXR5IHJpc2ssIG5vdCB1bnRpZGluZXNzOiBhIGZpeCBhcHBsaWVkIHRvIG9uZSBjb3B5IHNpbGVudGx5IGxlYXZlcyB0aGVcbiAqIG90aGVyIGFjY2VwdGluZyB3aGF0IGl0IHNob3VsZCBub3QuXG4gKlxuICogQ2FsbGVycyBrZWVwIHRoZWlyIE9XTiBub3QtZm91bmQgcG9saWN5IG9uIHRvcCAodGhyb3cgdnMuIHJldHVybiBudWxsKSDigJRcbiAqIHRoYXQgaXMgYSBwZXItc2VydmljZSBkZWNpc2lvbiwgdGhlIHBhcnNlIGlzIG5vdC5cbiAqL1xuXG4vKiogaW4tdG90byBwcmVkaWNhdGUgdHlwZSBmb3IgYW4gU1BEWCBTQk9NLCBhcyBjb3NpZ24ncyBgLS10eXBlIHNwZHhqc29uYCBlbWl0cy4gKi9cbmV4cG9ydCBjb25zdCBTUERYX1BSRURJQ0FURV9UWVBFID0gJ2h0dHBzOi8vc3BkeC5kZXYvRG9jdW1lbnQnO1xuXG4vKipcbiAqIFJldHVybiB0aGUgcHJlZGljYXRlIG9mIHRoZSBMQVNUIGVudmVsb3BlIGluIGBzdGRvdXRgIHdob3NlIGluLXRvdG8gc3RhdGVtZW50XG4gKiBjYXJyaWVzIGBwcmVkaWNhdGVUeXBlYCwgb3IgbnVsbCB3aGVuIG5vbmUgZG9lcy5cbiAqXG4gKiBMQVNULCBub3QgZmlyc3Q6IGEgcmVidWlsZCByZS1hdHRlc3RzIHRoZSBzYW1lIGRpZ2VzdCBhbmQgY29zaWduIGxpc3RzXG4gKiBhdHRlc3RhdGlvbnMgb2xkZXN0LWZpcnN0LCBzbyB0aGUgbmV3ZXN0IGF0dGVzdGF0aW9uIGlzIHRoZSBmaW5hbCBsaW5lLlxuICpcbiAqIExpbmVzIHRoYXQgYXJlIG5vdCBwYXJzZWFibGUgZW52ZWxvcGVzIGFyZSBza2lwcGVkIHJhdGhlciB0aGFuIGZhdGFsIOKAlCBjb3NpZ25cbiAqIHByaW50cyBub3RoaW5nIGVsc2Ugb24gc3Rkb3V0IHRvZGF5LCBidXQgc3RyYXkgb3V0cHV0IG11c3Qgbm90IHR1cm4gYSB2YWxpZFxuICogYXR0ZXN0YXRpb24gaW50byBhIHZlcmlmaWNhdGlvbiBmYWlsdXJlLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZXh0cmFjdFByZWRpY2F0ZShzdGRvdXQ6IHN0cmluZywgcHJlZGljYXRlVHlwZTogc3RyaW5nKTogUmVjb3JkPHN0cmluZywgdW5rbm93bj4gfCBudWxsIHtcbiAgbGV0IHByZWRpY2F0ZTogUmVjb3JkPHN0cmluZywgdW5rbm93bj4gfCBudWxsID0gbnVsbDtcbiAgZm9yIChjb25zdCBsaW5lIG9mIHN0ZG91dC5zcGxpdCgnXFxuJykpIHtcbiAgICBjb25zdCB0cmltbWVkID0gbGluZS50cmltKCk7XG4gICAgaWYgKCF0cmltbWVkLnN0YXJ0c1dpdGgoJ3snKSkgY29udGludWU7XG4gICAgdHJ5IHtcbiAgICAgIGNvbnN0IGVudmVsb3BlID0gSlNPTi5wYXJzZSh0cmltbWVkKSBhcyB7IHBheWxvYWQ/OiBzdHJpbmcgfTtcbiAgICAgIGlmICghZW52ZWxvcGUucGF5bG9hZCkgY29udGludWU7XG4gICAgICBjb25zdCBzdGF0ZW1lbnQgPSBKU09OLnBhcnNlKEJ1ZmZlci5mcm9tKGVudmVsb3BlLnBheWxvYWQsICdiYXNlNjQnKS50b1N0cmluZygndXRmLTgnKSkgYXMge1xuICAgICAgICBwcmVkaWNhdGVUeXBlPzogc3RyaW5nO1xuICAgICAgICBwcmVkaWNhdGU/OiB1bmtub3duO1xuICAgICAgfTtcbiAgICAgIGlmIChzdGF0ZW1lbnQucHJlZGljYXRlVHlwZSA9PT0gcHJlZGljYXRlVHlwZSAmJiBzdGF0ZW1lbnQucHJlZGljYXRlICYmIHR5cGVvZiBzdGF0ZW1lbnQucHJlZGljYXRlID09PSAnb2JqZWN0Jykge1xuICAgICAgICBwcmVkaWNhdGUgPSBzdGF0ZW1lbnQucHJlZGljYXRlIGFzIFJlY29yZDxzdHJpbmcsIHVua25vd24+O1xuICAgICAgfVxuICAgIH0gY2F0Y2gge1xuICAgICAgLy8gTm90IGFuIGVudmVsb3BlIGxpbmUuXG4gICAgfVxuICB9XG4gIHJldHVybiBwcmVkaWNhdGU7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/env.d.ts

@@ -8,6 +8,17 @@
  * than re-derived (see `MAX_PAGE_LIMIT` / `DEFAULT_PAGE_LIMIT` in
  * `validation/common-schemas.ts`).
  */
+/**
+ * A camelCase name as the env-var fragment that configures it:
+ * `apiCalls` → `API_CALLS`, `supportPremiumContacts` → `SUPPORT_PREMIUM_CONTACTS`.
+ *
+ * Here, in the env module, because the two callers are in different PACKAGES —
+ * `quota-tiers.ts` builds `QUOTA_TIER_<TIER>_<LIMIT>` and api/quota's config
+ * builds `QUOTA_DEFAULT_<TYPE>` — and each had its own copy of the same regex.
+ * Two spellings of one transform is a drift waiting to happen: "fixing" either
+ * one would silently rename half of an operator's configured knobs.
+ */
+export declare function envNameFragment(name: string): string;
 /**
  * Parse an integer env var. Unset / blank / not a clean integer string → `def`.
  * Optional `min`/`max` clamp the result (applied after the default).

package/lib/utils/env.js

@@ -10,6 +10,19 @@
  * than re-derived (see `MAX_PAGE_LIMIT` / `DEFAULT_PAGE_LIMIT` in
  * `validation/common-schemas.ts`).
  */
+/**
+ * A camelCase name as the env-var fragment that configures it:
+ * `apiCalls` → `API_CALLS`, `supportPremiumContacts` → `SUPPORT_PREMIUM_CONTACTS`.
+ *
+ * Here, in the env module, because the two callers are in different PACKAGES —
+ * `quota-tiers.ts` builds `QUOTA_TIER_<TIER>_<LIMIT>` and api/quota's config
+ * builds `QUOTA_DEFAULT_<TYPE>` — and each had its own copy of the same regex.
+ * Two spellings of one transform is a drift waiting to happen: "fixing" either
+ * one would silently rename half of an operator's configured knobs.
+ */
+export function envNameFragment(name) {
+    return name.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase();
+}
 /**
  * Parse an integer env var. Unset / blank / not a clean integer string → `def`.
  * Optional `min`/`max` clamp the result (applied after the default).
@@ -80,4 +93,4 @@ export function isReadReplicaConfigured() {
         return false;
     return envStr('DB_READ_HOST', '').trim().length > 0;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW52LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL2Vudi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDOzs7Ozs7Ozs7R0FTRztBQUVIOzs7Ozs7O0dBT0c7QUFDSCxNQUFNLFVBQVUsTUFBTSxDQUFDLElBQVksRUFBRSxHQUFXLEVBQUUsSUFBcUM7SUFDckYsTUFBTSxHQUFHLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUM5QixNQUFNLE9BQU8sR0FBRyxHQUFHLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxDQUFDO0lBQ2xDLElBQUksQ0FBQyxHQUFHLE9BQU8sS0FBSyxFQUFFLElBQUksWUFBWSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxPQUFPLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQztJQUMxRixJQUFJLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUM7UUFBRSxDQUFDLEdBQUcsR0FBRyxDQUFDO0lBQ2pDLElBQUksSUFBSSxFQUFFLEdBQUcsS0FBSyxTQUFTO1FBQUUsQ0FBQyxHQUFHLElBQUksQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDLENBQUMsQ0FBQztJQUN2RCxJQUFJLElBQUksRUFBRSxHQUFHLEtBQUssU0FBUztRQUFFLENBQUMsR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQyxDQUFDLENBQUM7SUFDdkQsT0FBTyxDQUFDLENBQUM7QUFDWCxDQUFDO0FBRUQ7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLE9BQU8sQ0FBQyxJQUFZLEVBQUUsR0FBWTtJQUNoRCxNQUFNLEdBQUcsR0FBRyxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzlCLElBQUksR0FBRyxLQUFLLFNBQVMsSUFBSSxHQUFHLENBQUMsSUFBSSxFQUFFLEtBQUssRUFBRTtRQUFFLE9BQU8sR0FBRyxDQUFDO0lBQ3ZELE1BQU0sQ0FBQyxHQUFHLEdBQUcsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxXQUFXLEVBQUUsQ0FBQztJQUNuQyxJQUFJLENBQUMsS0FBSyxNQUFNLElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDLEtBQUssS0FBSztRQUFFLE9BQU8sSUFBSSxDQUFDO0lBQzFELElBQUksQ0FBQyxLQUFLLE9BQU8sSUFBSSxDQUFDLEtBQUssR0FBRyxJQUFJLENBQUMsS0FBSyxJQUFJO1FBQUUsT0FBTyxLQUFLLENBQUM7SUFDM0QsT0FBTyxHQUFHLENBQUM7QUFDYixDQUFDO0FBRUQsb0RBQW9EO0FBQ3BELE1BQU0sVUFBVSxNQUFNLENBQUMsSUFBWSxFQUFFLEdBQVc7SUFDOUMsTUFBTSxHQUFHLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUM5QixPQUFPLEdBQUcsS0FBSyxTQUFTLElBQUksR0FBRyxDQUFDLElBQUksRUFBRSxLQUFLLEVBQUUsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUM7QUFDNUQsQ0FBQztBQUVEOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0F3Qkc7QUFDSCxNQUFNLFVBQVUsdUJBQXVCO0lBQ3JDLElBQUksQ0FBQyxPQUFPLENBQUMsaUJBQWlCLEVBQUUsSUFBSSxDQUFDO1FBQUUsT0FBTyxLQUFLLENBQUM7SUFDcEQsT0FBTyxNQUFNLENBQUMsY0FBYyxFQUFFLEVBQUUsQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUM7QUFDdEQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG4vKipcbiAqIFR5cGVkIGVudmlyb25tZW50LXZhcmlhYmxlIHJlYWRlcnMgd2l0aCBjb25zaXN0ZW50IHBhcnNpbmcgKyBkZWZhdWx0cy5cbiAqXG4gKiBIYW5kLXJvbGxlZCBgcGFyc2VJbnQocHJvY2Vzcy5lbnYuWCB8fCAn4oCmJywgMTApYCAvIGBwcm9jZXNzLmVudi5YID09PSAndHJ1ZSdgXG4gKiBkcmlmdHMgKHRoZSBzYW1lIHZhciBwYXJzZWQgd2l0aCBkaWZmZXJlbnQgZGVmYXVsdHMgaW4gZGlmZmVyZW50IHBhY2thZ2VzKVxuICogYW5kIHNpbGVudGx5IHJldHVybnMgdGhlIGRlZmF1bHQgb24gYSB0eXBvJ2QgbmFtZS4gVGhlc2UgaGVscGVycyBjZW50cmFsaXplIHRoZSBwYXJzaW5nIHNvIGEgdmFsdWVcbiAqIGlzIHJlYWQgdGhlIHNhbWUgd2F5IGV2ZXJ5d2hlcmUsIGFuZCBtYWtlIHNoYXJlZCBjb25zdGFudHMgaW1wb3J0YWJsZSByYXRoZXJcbiAqIHRoYW4gcmUtZGVyaXZlZCAoc2VlIGBNQVhfUEFHRV9MSU1JVGAgLyBgREVGQVVMVF9QQUdFX0xJTUlUYCBpblxuICogYHZhbGlkYXRpb24vY29tbW9uLXNjaGVtYXMudHNgKS5cbiAqL1xuXG4vKipcbiAqIFBhcnNlIGFuIGludGVnZXIgZW52IHZhci4gVW5zZXQgLyBibGFuayAvIG5vdCBhIGNsZWFuIGludGVnZXIgc3RyaW5nIOKGkiBgZGVmYC5cbiAqIE9wdGlvbmFsIGBtaW5gL2BtYXhgIGNsYW1wIHRoZSByZXN1bHQgKGFwcGxpZWQgYWZ0ZXIgdGhlIGRlZmF1bHQpLlxuICpcbiAqIFNUUklDVCBvbiBwdXJwb3NlOiBgcGFyc2VJbnRgIGFjY2VwdHMgYDUwLjVgICjihpIgNTApIGFuZCBgMTJhYmNgICjihpIgMTIpLCB3aGljaFxuICogaXMgaG93IGEgdHlwbydkIHF1b3RhIGxpbWl0IG9yIHRpbWVvdXQgc2lsZW50bHkgc2hpcHMgYSB2YWx1ZSBub2JvZHkgd3JvdGUuXG4gKiBBbnl0aGluZyB0aGF0IGlzbid0IGAtP1xcZCtgIGZhbGxzIGJhY2sgdG8gdGhlIGNvZGUgZGVmYXVsdCBpbnN0ZWFkLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZW52SW50KG5hbWU6IHN0cmluZywgZGVmOiBudW1iZXIsIG9wdHM/OiB7IG1pbj86IG51bWJlcjsgbWF4PzogbnVtYmVyIH0pOiBudW1iZXIge1xuICBjb25zdCByYXcgPSBwcm9jZXNzLmVudltuYW1lXTtcbiAgY29uc3QgdHJpbW1lZCA9IHJhdz8udHJpbSgpID8/ICcnO1xuICBsZXQgbiA9IHRyaW1tZWQgIT09ICcnICYmIC9eWystXT9cXGQrJC8udGVzdCh0cmltbWVkKSA/IE51bWJlci5wYXJzZUludCh0cmltbWVkLCAxMCkgOiBkZWY7XG4gIGlmICghTnVtYmVyLmlzRmluaXRlKG4pKSBuID0gZGVmO1xuICBpZiAob3B0cz8ubWluICE9PSB1bmRlZmluZWQpIG4gPSBNYXRoLm1heChvcHRzLm1pbiwgbik7XG4gIGlmIChvcHRzPy5tYXggIT09IHVuZGVmaW5lZCkgbiA9IE1hdGgubWluKG9wdHMubWF4LCBuKTtcbiAgcmV0dXJuIG47XG59XG5cbi8qKlxuICogUGFyc2UgYSBib29sZWFuIGVudiB2YXIuIGB0cnVlYC9gMWAvYHllc2Ag4oaSIHRydWUsIGBmYWxzZWAvYDBgL2Bub2Ag4oaSIGZhbHNlXG4gKiAoY2FzZS1pbnNlbnNpdGl2ZSk7IHVuc2V0IC8gYmxhbmsgLyB1bnJlY29nbml6ZWQg4oaSIGBkZWZgLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZW52Qm9vbChuYW1lOiBzdHJpbmcsIGRlZjogYm9vbGVhbik6IGJvb2xlYW4ge1xuICBjb25zdCByYXcgPSBwcm9jZXNzLmVudltuYW1lXTtcbiAgaWYgKHJhdyA9PT0gdW5kZWZpbmVkIHx8IHJhdy50cmltKCkgPT09ICcnKSByZXR1cm4gZGVmO1xuICBjb25zdCB2ID0gcmF3LnRyaW0oKS50b0xvd2VyQ2FzZSgpO1xuICBpZiAodiA9PT0gJ3RydWUnIHx8IHYgPT09ICcxJyB8fCB2ID09PSAneWVzJykgcmV0dXJuIHRydWU7XG4gIGlmICh2ID09PSAnZmFsc2UnIHx8IHYgPT09ICcwJyB8fCB2ID09PSAnbm8nKSByZXR1cm4gZmFsc2U7XG4gIHJldHVybiBkZWY7XG59XG5cbi8qKiBSZWFkIGEgc3RyaW5nIGVudiB2YXI7IHVuc2V0IC8gYmxhbmsg4oaSIGBkZWZgLiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGVudlN0cihuYW1lOiBzdHJpbmcsIGRlZjogc3RyaW5nKTogc3RyaW5nIHtcbiAgY29uc3QgcmF3ID0gcHJvY2Vzcy5lbnZbbmFtZV07XG4gIHJldHVybiByYXcgPT09IHVuZGVmaW5lZCB8fCByYXcudHJpbSgpID09PSAnJyA/IGRlZiA6IHJhdztcbn1cblxuLyoqXG4gKiBJcyBhIFBvc3RncmVzIHJlYWQgcmVwbGljYSBjb25maWd1cmVkIEFORCBzd2l0Y2hlZCBvbj9cbiAqXG4gKiBMaXZlcyBpbiBhcGktY29yZSwgbm90IHBpcGVsaW5lLWRhdGEsIGV2ZW4gdGhvdWdoIHRoZSByZWFkIFBPT0wgZG9lcy4gSXQgaXNcbiAqIHB1cmUgZW52IGxvZ2ljIHdpdGggbm8gZGF0YWJhc2UgZGVwZW5kZW5jeSwgYW5kIEJPVEggcGFja2FnZXMgbmVlZCBpdDpcbiAqIHBpcGVsaW5lLWRhdGEgdG8gZGVjaWRlIHdoZXRoZXIgdG8gYnVpbGQgdGhlIHBvb2wsIGFuZCBhcGktc2VydmVyJ3NcbiAqIHRlbmFudC1jb250ZXh0IG1pZGRsZXdhcmUgdG8gZGVjaWRlIHdoZXRoZXIgdGhlIGNyb3NzLXJlcXVlc3Qgd3JpdGUgcGluIGlzIGluXG4gKiBwbGF5IGF0IGFsbC5cbiAqXG4gKiBXSFkgVEhBVCBQTEFDRU1FTlQgSVMgTE9BRC1CRUFSSU5HLCBub3QgdGFzdGUuIGFwaS1zZXJ2ZXIncyBtaWRkbGV3YXJlIHJ1bnMgaW5cbiAqIEVWRVJZIHNlcnZpY2UsIGFuZCA5MSB0ZXN0IHN1aXRlcyBzdHViIGBAcGlwZWxpbmUtYnVpbGRlci9waXBlbGluZS1kYXRhYCB3aXRoXG4gKiBgc3R1Yk1vZHVsZWAsIHdoaWNoIFRIUk9XUyBvbiBhY2Nlc3MgdG8gYW4gZXhwb3J0IHRoZSBzdWl0ZSBkaWQgbm90IG92ZXJyaWRlIOKAlFxuICogZGVsaWJlcmF0ZWx5LCB0byBmb3JjZSBleHBsaWNpdG5lc3MuIFNvIHJlYWNoaW5nIGludG8gcGlwZWxpbmUtZGF0YSBmcm9tIHRoZVxuICogbWlkZGxld2FyZSB0dXJuZWQgZXZlcnkgb25lIG9mIHRob3NlIHN1aXRlcyBpbnRvIGEgNTAwLCBhbmQgcGF0Y2hpbmcgOTEgc3R1YnNcbiAqIHdvdWxkIG9ubHkgZGVmZXIgdGhlIG5leHQgb25lLiBhcGktY29yZSdzIG1vY2tzIHNwcmVhZCBgcmVxdWlyZUFjdHVhbGAsIHNvIGFcbiAqIHN5bWJvbCBoZXJlIGlzIGF2YWlsYWJsZSB0byBhbGwgb2YgdGhlbSB3aXRob3V0IGEgc2luZ2xlIHN0dWIgZWRpdC5cbiAqXG4gKiBgREJfUkVBRF9FTkFCTEVEPWZhbHNlYCBpcyB0aGUgS0lMTCBTV0lUQ0g6IGl0IGZvcmNlcyBldmVyeSByZWFkIGJhY2sgdG8gdGhlXG4gKiBwcmltYXJ5IHdpdGhvdXQgYSByZWRlcGxveSBvciBhIG1hbmlmZXN0IGNoYW5nZSwgd2hpY2ggdGhlIHVuc2V0LWhvc3QgZmFsbGJhY2tcbiAqIGRvZXMgbm90IGNvdmVyLiBVbnNldCBob3N0IGFuc3dlcnMgXCJ0aGVyZSBpcyBubyByZXBsaWNhXCI7IHRoZSBraWxsIHN3aXRjaFxuICogYW5zd2VycyBcInRoZXJlIGlzIG9uZSBhbmQgSSBkbyBub3QgdHJ1c3QgaXRcIi5cbiAqXG4gKiBgLnRyaW0oKWAgbWF0dGVyczogYERCX1JFQURfSE9TVD1cIiBcImAgZnJvbSBhIHN0cmF5IHNwYWNlIG11c3Qgbm90IHJlYWQgYXNcbiAqIFwiYSByZXBsaWNhIGV4aXN0c1wiLlxuICovXG5leHBvcnQgZnVuY3Rpb24gaXNSZWFkUmVwbGljYUNvbmZpZ3VyZWQoKTogYm9vbGVhbiB7XG4gIGlmICghZW52Qm9vbCgnREJfUkVBRF9FTkFCTEVEJywgdHJ1ZSkpIHJldHVybiBmYWxzZTtcbiAgcmV0dXJuIGVudlN0cignREJfUkVBRF9IT1NUJywgJycpLnRyaW0oKS5sZW5ndGggPiAwO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"env.js","sources":["../../src/utils/env.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;GASG;AAEH;;;;;;;;;GASG;AACH,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,OAAO,IAAI,CAAC,OAAO,CAAC,oBAAoB,EAAE,OAAO,CAAC,CAAC,WAAW,EAAE,CAAC;AACnE,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,MAAM,CAAC,IAAY,EAAE,GAAW,EAAE,IAAqC;IACrF,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC9B,MAAM,OAAO,GAAG,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IAClC,IAAI,CAAC,GAAG,OAAO,KAAK,EAAE,IAAI,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;IAC1F,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;QAAE,CAAC,GAAG,GAAG,CAAC;IACjC,IAAI,IAAI,EAAE,GAAG,KAAK,SAAS;QAAE,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IACvD,IAAI,IAAI,EAAE,GAAG,KAAK,SAAS;QAAE,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IACvD,OAAO,CAAC,CAAC;AACX,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,OAAO,CAAC,IAAY,EAAE,GAAY;IAChD,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC9B,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE;QAAE,OAAO,GAAG,CAAC;IACvD,MAAM,CAAC,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IACnC,IAAI,CAAC,KAAK,MAAM,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,KAAK;QAAE,OAAO,IAAI,CAAC;IAC1D,IAAI,CAAC,KAAK,OAAO,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC3D,OAAO,GAAG,CAAC;AACb,CAAC;AAED,oDAAoD;AACpD,MAAM,UAAU,MAAM,CAAC,IAAY,EAAE,GAAW;IAC9C,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC9B,OAAO,GAAG,KAAK,SAAS,IAAI,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;AAC5D,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,uBAAuB;IACrC,IAAI,CAAC,OAAO,CAAC,iBAAiB,EAAE,IAAI,CAAC;QAAE,OAAO,KAAK,CAAC;IACpD,OAAO,MAAM,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC;AACtD,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Typed environment-variable readers with consistent parsing + defaults.\n *\n * Hand-rolled `parseInt(process.env.X || '…', 10)` / `process.env.X === 'true'`\n * drifts (the same var parsed with different defaults in different packages)\n * and silently returns the default on a typo'd name. These helpers centralize the parsing so a value\n * is read the same way everywhere, and make shared constants importable rather\n * than re-derived (see `MAX_PAGE_LIMIT` / `DEFAULT_PAGE_LIMIT` in\n * `validation/common-schemas.ts`).\n */\n\n/**\n * A camelCase name as the env-var fragment that configures it:\n * `apiCalls` → `API_CALLS`, `supportPremiumContacts` → `SUPPORT_PREMIUM_CONTACTS`.\n *\n * Here, in the env module, because the two callers are in different PACKAGES —\n * `quota-tiers.ts` builds `QUOTA_TIER_<TIER>_<LIMIT>` and api/quota's config\n * builds `QUOTA_DEFAULT_<TYPE>` — and each had its own copy of the same regex.\n * Two spellings of one transform is a drift waiting to happen: \"fixing\" either\n * one would silently rename half of an operator's configured knobs.\n */\nexport function envNameFragment(name: string): string {\n  return name.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase();\n}\n\n/**\n * Parse an integer env var. Unset / blank / not a clean integer string → `def`.\n * Optional `min`/`max` clamp the result (applied after the default).\n *\n * STRICT on purpose: `parseInt` accepts `50.5` (→ 50) and `12abc` (→ 12), which\n * is how a typo'd quota limit or timeout silently ships a value nobody wrote.\n * Anything that isn't `-?\\d+` falls back to the code default instead.\n */\nexport function envInt(name: string, def: number, opts?: { min?: number; max?: number }): number {\n  const raw = process.env[name];\n  const trimmed = raw?.trim() ?? '';\n  let n = trimmed !== '' && /^[+-]?\\d+$/.test(trimmed) ? Number.parseInt(trimmed, 10) : def;\n  if (!Number.isFinite(n)) n = def;\n  if (opts?.min !== undefined) n = Math.max(opts.min, n);\n  if (opts?.max !== undefined) n = Math.min(opts.max, n);\n  return n;\n}\n\n/**\n * Parse a boolean env var. `true`/`1`/`yes` → true, `false`/`0`/`no` → false\n * (case-insensitive); unset / blank / unrecognized → `def`.\n */\nexport function envBool(name: string, def: boolean): boolean {\n  const raw = process.env[name];\n  if (raw === undefined || raw.trim() === '') return def;\n  const v = raw.trim().toLowerCase();\n  if (v === 'true' || v === '1' || v === 'yes') return true;\n  if (v === 'false' || v === '0' || v === 'no') return false;\n  return def;\n}\n\n/** Read a string env var; unset / blank → `def`. */\nexport function envStr(name: string, def: string): string {\n  const raw = process.env[name];\n  return raw === undefined || raw.trim() === '' ? def : raw;\n}\n\n/**\n * Is a Postgres read replica configured AND switched on?\n *\n * Lives in api-core, not pipeline-data, even though the read POOL does. It is\n * pure env logic with no database dependency, and BOTH packages need it:\n * pipeline-data to decide whether to build the pool, and api-server's\n * tenant-context middleware to decide whether the cross-request write pin is in\n * play at all.\n *\n * WHY THAT PLACEMENT IS LOAD-BEARING, not taste. api-server's middleware runs in\n * EVERY service, and 91 test suites stub `@pipeline-builder/pipeline-data` with\n * `stubModule`, which THROWS on access to an export the suite did not override —\n * deliberately, to force explicitness. So reaching into pipeline-data from the\n * middleware turned every one of those suites into a 500, and patching 91 stubs\n * would only defer the next one. api-core's mocks spread `requireActual`, so a\n * symbol here is available to all of them without a single stub edit.\n *\n * `DB_READ_ENABLED=false` is the KILL SWITCH: it forces every read back to the\n * primary without a redeploy or a manifest change, which the unset-host fallback\n * does not cover. Unset host answers \"there is no replica\"; the kill switch\n * answers \"there is one and I do not trust it\".\n *\n * `.trim()` matters: `DB_READ_HOST=\" \"` from a stray space must not read as\n * \"a replica exists\".\n */\nexport function isReadReplicaConfigured(): boolean {\n  if (!envBool('DB_READ_ENABLED', true)) return false;\n  return envStr('DB_READ_HOST', '').trim().length > 0;\n}\n"]}

package/lib/utils/headers.js

@@ -18,4 +18,4 @@ export function getHeaderString(value) {
     }
     return value;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVhZGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9oZWFkZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLCtDQUErQztBQUMvQyxzQ0FBc0M7QUFPdEM7Ozs7Ozs7Ozs7O0dBV0c7QUFDSCxNQUFNLFVBQVUsZUFBZSxDQUFDLEtBQWtCO0lBQ2hELElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQ3pCLE9BQU8sS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ2xCLENBQUM7SUFDRCxPQUFPLEtBQUssQ0FBQztBQUNmLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuLyoqXG4gKiBFeHByZXNzIDUgaGVhZGVyIHR5cGUuXG4gKi9cbnR5cGUgSGVhZGVyVmFsdWUgPSBzdHJpbmcgfCBzdHJpbmdbXSB8IHVuZGVmaW5lZDtcblxuLyoqXG4gKiBFeHRyYWN0IGEgc2luZ2xlIHN0cmluZyBmcm9tIGEgaGVhZGVyIHZhbHVlIHRoYXQgbWF5IGJlIHN0cmluZyB8IHN0cmluZ1tdIHwgdW5kZWZpbmVkLlxuICpcbiAqIEBwYXJhbSB2YWx1ZSAtIEhlYWRlciB2YWx1ZSBmcm9tIEV4cHJlc3MgcmVxdWVzdFxuICogQHJldHVybnMgRmlyc3QgdmFsdWUgaWYgYXJyYXksIHRoZSB2YWx1ZSBpZiBzdHJpbmcsIG9yIHVuZGVmaW5lZFxuICpcbiAqIEBleGFtcGxlXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiBjb25zdCBvcmdJZCA9IGdldEhlYWRlclN0cmluZyhyZXEuaGVhZGVyc1sneC1vcmctaWQnXSk7XG4gKiBjb25zdCBhdXRoID0gZ2V0SGVhZGVyU3RyaW5nKHJlcS5oZWFkZXJzLmF1dGhvcml6YXRpb24pO1xuICogYGBgXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXRIZWFkZXJTdHJpbmcodmFsdWU6IEhlYWRlclZhbHVlKTogc3RyaW5nIHwgdW5kZWZpbmVkIHtcbiAgaWYgKEFycmF5LmlzQXJyYXkodmFsdWUpKSB7XG4gICAgcmV0dXJuIHZhbHVlWzBdO1xuICB9XG4gIHJldHVybiB2YWx1ZTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVhZGVycy5qcyIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL2hlYWRlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQU90Qzs7Ozs7Ozs7Ozs7R0FXRztBQUNILE1BQU0sVUFBVSxlQUFlLENBQUMsS0FBa0I7SUFDaEQsSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUM7UUFDekIsT0FBTyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDbEIsQ0FBQztJQUNELE9BQU8sS0FBSyxDQUFDO0FBQ2YsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG4vKipcbiAqIEV4cHJlc3MgNSBoZWFkZXIgdHlwZS5cbiAqL1xudHlwZSBIZWFkZXJWYWx1ZSA9IHN0cmluZyB8IHN0cmluZ1tdIHwgdW5kZWZpbmVkO1xuXG4vKipcbiAqIEV4dHJhY3QgYSBzaW5nbGUgc3RyaW5nIGZyb20gYSBoZWFkZXIgdmFsdWUgdGhhdCBtYXkgYmUgc3RyaW5nIHwgc3RyaW5nW10gfCB1bmRlZmluZWQuXG4gKlxuICogQHBhcmFtIHZhbHVlIC0gSGVhZGVyIHZhbHVlIGZyb20gRXhwcmVzcyByZXF1ZXN0XG4gKiBAcmV0dXJucyBGaXJzdCB2YWx1ZSBpZiBhcnJheSwgdGhlIHZhbHVlIGlmIHN0cmluZywgb3IgdW5kZWZpbmVkXG4gKlxuICogQGV4YW1wbGVcbiAqIGBgYHR5cGVzY3JpcHRcbiAqIGNvbnN0IG9yZ0lkID0gZ2V0SGVhZGVyU3RyaW5nKHJlcS5oZWFkZXJzWyd4LW9yZy1pZCddKTtcbiAqIGNvbnN0IGF1dGggPSBnZXRIZWFkZXJTdHJpbmcocmVxLmhlYWRlcnMuYXV0aG9yaXphdGlvbik7XG4gKiBgYGBcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldEhlYWRlclN0cmluZyh2YWx1ZTogSGVhZGVyVmFsdWUpOiBzdHJpbmcgfCB1bmRlZmluZWQge1xuICBpZiAoQXJyYXkuaXNBcnJheSh2YWx1ZSkpIHtcbiAgICByZXR1cm4gdmFsdWVbMF07XG4gIH1cbiAgcmV0dXJuIHZhbHVlO1xufVxuIl19

package/lib/utils/identity.js

@@ -128,4 +128,4 @@ export function getIdentity(req) {
         role: user?.role || getHeaderString(req.headers['x-user-role']),
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"identity.js","sourceRoot":"","sources":["../../src/utils/identity.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAiB/C;;;;;;;;;;GAUG;AACH,MAAM,UAAU,cAAc,CAAC,KAAgC;IAC7D,OAAO,KAAK,EAAE,IAAI,EAAE,CAAC,WAAW,EAAE,IAAI,SAAS,CAAC;AAClD,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,QAAQ,CAAC;AAExC;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,WAAW,CAAC;AAE9C;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,cAAc,CAAC;AAEpD;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,OAAO,CAAC,EAA8B;IACpD,OAAO,EAAE,CAAC,MAAM,IAAI,eAAe,CAAC;AACtC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,WAAW,CAAC,GAAgB;IAC1C,oEAAoE;IACpE,uEAAuE;IACvE,uEAAuE;IACvE,oDAAoD;IACpD,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC;IACtB,6EAA6E;IAC7E,wDAAwD;IACxD,8EAA8E;IAC9E,0EAA0E;IAC1E,6EAA6E;IAC7E,0EAA0E;IAC1E,sEAAsE;IACtE,yEAAyE;IACzE,4EAA4E;IAC5E,wEAAwE;IACxE,0EAA0E;IAC1E,2EAA2E;IAC3E,gEAAgE;IAChE,MAAM,aAAa,GAAG,IAAI,EAAE,aAAa,CAAC;IAC1C,MAAM,WAAW,GAAG,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;IAC7D,MAAM,eAAe,GAAG,CAAC,IAAI,IAAI,aAAa,KAAK,SAAS,CAAC;IAC7D,MAAM,QAAQ,GAAG,IAAI,EAAE,cAAc,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IACrF,4EAA4E;IAC5E,8EAA8E;IAC9E,8EAA8E;IAC9E,wDAAwD;IACxD,MAAM,KAAK,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAC;IACvC,OAAO;QACL,KAAK;QACL,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;QAC9D,SAAS,EAAE,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;QACvD,IAAI,EAAE,IAAI,EAAE,IAAI,IAAI,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;KAChE,CAAC;AACJ,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { getHeaderString } from './headers.js';\nimport type { HttpRequest } from '../types/http.js';\n\n/**\n * Identity information extracted from request headers.\n */\nexport interface RequestIdentity {\n  /** Organization ID from x-org-id header */\n  readonly orgId?: string;\n  /** User ID from x-user-id header */\n  readonly userId?: string;\n  /** Request ID from x-request-id header */\n  readonly requestId?: string;\n  /** User role from x-user-role header (decoded from JWT) */\n  readonly role?: string;\n}\n\n/**\n * Canonical org-id normalization: trim + lowercase, empty ⇒ undefined.\n *\n * The SINGLE spelling rule for a tenant id across the fleet. Org ids are\n * 24-hex ObjectId strings (plus the `'system'` sentinel), and hex is\n * case-insensitive — so `Acme`-style casing differences resolve to the SAME\n * Mongo document while string comparisons (`activeOrgId === targetOrgId`, an\n * RLS GUC vs a WHERE clause, a cache key) silently disagree. Everything that\n * compares or keys on an org id normalizes through here so the comparison and\n * the lookup can never drift apart.\n */\nexport function normalizeOrgId(orgId: string | undefined | null): string | undefined {\n  return orgId?.trim().toLowerCase() || undefined;\n}\n\n/**\n * The actor id written when nothing in the request attributes the action to a\n * person — an internal service hop, a scheduler tick, a token whose subject\n * never resolved. One spelling, because the audit trail is queried by it.\n */\nexport const SYSTEM_ACTOR_ID = 'system';\n\n/**\n * The actor id written for an UNAUTHENTICATED actor: an anonymous public plugin\n * submission (docs/plugin-publishing.md — the event carries\n * `details.submissionId` for correlation and is recorded against the system\n * org; the submitter's email, hashed or otherwise, never appears in the audit\n * trail) and platform's pre-auth `device.authorize.start` (a device-login code\n * requested before anyone has signed in). Distinct from {@link SYSTEM_ACTOR_ID}, which means \"no person\n * involved\", not \"a person we don't know\".\n */\nexport const ANONYMOUS_ACTOR_ID = 'anonymous';\n\n/**\n * The actor id written for work the EXPANSION-OFFERS agent did on its own\n * (docs/plans/sales-agent.md D14).\n *\n * Distinct from {@link SYSTEM_ACTOR_ID} because \"why did this account get this\n * offer?\" is the only question anybody will ask about that feature, and the\n * generic system actor makes it unanswerable: the trail shows system work, of\n * which this deployment does a great deal, and nothing would separate an offer\n * the agent decided from a seed, a backfill or an operator script.\n *\n * It also makes the agent's work revocable AS A SET — \"withdraw everything the\n * agent did in the last hour\" is a query on this value rather than an\n * archaeology exercise, which is the control an operator wants on the morning a\n * rule turns out to be wrong.\n *\n * An ACTOR, not a network identity: the agent runs inside billing until Phase 5\n * extracts it, so its service principal is still `billing`. This names who\n * decided, which is what the audit trail is queried by.\n */\nexport const OFFERS_AGENT_ACTOR_ID = 'offers-agent';\n\n/**\n * The actor id to stamp on an audit event, from a route context.\n *\n * One resolver so every route agrees on the fallback: per-route\n * `req.user.sub ?? …` fallbacks disagree, and the same unattributable write\n * would land in the trail under different actors depending on the route.\n *\n * `rc.userId` is already the normalized identity `withRoute` resolved (JWT\n * `sub`, else the `x-user-id` hop header — see {@link getIdentity}), so this is\n * the same value the rest of the request is scoped by, and the ONE place the\n * \"unattributable\" sentinel is chosen. Accepts anything carrying a `userId`,\n * which the route context does — pass `rc`, or `{ userId }` when the handler\n * destructures.\n */\nexport function actorId(rc: { userId?: string | null }): string {\n  return rc.userId || SYSTEM_ACTOR_ID;\n}\n\n/**\n * Extract identity information from request headers.\n *\n * Extracts common identity headers used for multi-tenant authentication:\n * - x-org-id: Organization identifier (INTERNAL SERVICE hops only, see below)\n * - x-user-id: User identifier\n * - x-request-id: Request trace identifier\n * - x-user-role: User role\n *\n * @param req - HTTP request object\n * @returns Identity object with orgId, userId, requestId, and role\n *\n * @example\n * ```typescript\n * app.post('/api/resource', requireAuth, async (req, res) => {\n *   const identity = getIdentity(req);\n *\n *   if (!identity.orgId) {\n *     return sendError(res, 400, 'x-org-id header required');\n *   }\n *\n *   // Use identity.orgId, identity.userId, etc.\n * });\n * ```\n */\nexport function getIdentity(req: HttpRequest): RequestIdentity {\n  // Prefer JWT-verified claims (req.user) over raw headers to prevent\n  // spoofing. Headers are only used as fallback or for fields not in the\n  // JWT (e.g. requestId). The JWT payload uses `sub` for the user id per\n  // OIDC convention; that's our authoritative source.\n  const user = req.user;\n  // The `x-org-id` header is CLIENT-SETTABLE, so it is only ever honored for a\n  // principal that has no tenant of its own to speak for:\n  //   - an INTERNAL SERVICE principal (`principalType: 'service'`), whose token\n  //     names the signing service rather than the tenant it is acting for —\n  //     that is the S2S hop convention (the cascade, the quota client, …); and\n  //   - a request with no verified principal at all (`attachRequestContext`\n  //     runs before `requireAuth`, which recomputes this from the JWT).\n  // For a USER or SERVICE-ACCOUNT principal the JWT is the ONLY authority.\n  // Platform can mint a user token with no `organizationId` (a person between\n  // orgs, mid-invite, mid-onboarding); a `user?.organizationId || header`\n  // fallback would let such a token name any tenant it liked — a value that\n  // flows straight into the RLS tenant GUC. Absent ⇒ undefined ⇒ the route's\n  // `requireOrgId` refuses the call, which is the correct answer.\n  const principalType = user?.principalType;\n  const headerOrgId = getHeaderString(req.headers['x-org-id']);\n  const mayUseHeaderOrg = !user || principalType === 'service';\n  const rawOrgId = user?.organizationId || (mayUseHeaderOrg ? headerOrgId : undefined);\n  // Normalized ONCE here (see normalizeOrgId) so the RLS GUC (`identityScope`\n  // reads this `identity.orgId`) and the app-layer WHERE clauses (route-wrapper\n  // / app-factory) always agree on tenant. A mismatch — GUC set to `Acme` while\n  // WHERE queries `acme` — would silently return no rows.\n  const orgId = normalizeOrgId(rawOrgId);\n  return {\n    orgId,\n    userId: user?.sub || getHeaderString(req.headers['x-user-id']),\n    requestId: getHeaderString(req.headers['x-request-id']),\n    role: user?.role || getHeaderString(req.headers['x-user-role']),\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"identity.js","sources":["../../src/utils/identity.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAiB/C;;;;;;;;;;GAUG;AACH,MAAM,UAAU,cAAc,CAAC,KAAgC;IAC7D,OAAO,KAAK,EAAE,IAAI,EAAE,CAAC,WAAW,EAAE,IAAI,SAAS,CAAC;AAClD,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,QAAQ,CAAC;AAExC;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,WAAW,CAAC;AAE9C;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,cAAc,CAAC;AAEpD;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,OAAO,CAAC,EAA8B;IACpD,OAAO,EAAE,CAAC,MAAM,IAAI,eAAe,CAAC;AACtC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,WAAW,CAAC,GAAgB;IAC1C,oEAAoE;IACpE,uEAAuE;IACvE,uEAAuE;IACvE,oDAAoD;IACpD,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC;IACtB,6EAA6E;IAC7E,wDAAwD;IACxD,8EAA8E;IAC9E,0EAA0E;IAC1E,6EAA6E;IAC7E,0EAA0E;IAC1E,sEAAsE;IACtE,yEAAyE;IACzE,4EAA4E;IAC5E,wEAAwE;IACxE,0EAA0E;IAC1E,2EAA2E;IAC3E,gEAAgE;IAChE,MAAM,aAAa,GAAG,IAAI,EAAE,aAAa,CAAC;IAC1C,MAAM,WAAW,GAAG,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;IAC7D,MAAM,eAAe,GAAG,CAAC,IAAI,IAAI,aAAa,KAAK,SAAS,CAAC;IAC7D,MAAM,QAAQ,GAAG,IAAI,EAAE,cAAc,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IACrF,4EAA4E;IAC5E,8EAA8E;IAC9E,8EAA8E;IAC9E,wDAAwD;IACxD,MAAM,KAAK,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAC;IACvC,OAAO;QACL,KAAK;QACL,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;QAC9D,SAAS,EAAE,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;QACvD,IAAI,EAAE,IAAI,EAAE,IAAI,IAAI,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;KAChE,CAAC;AACJ,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { getHeaderString } from './headers.js';\nimport type { HttpRequest } from '../types/http.js';\n\n/**\n * Identity information extracted from request headers.\n */\nexport interface RequestIdentity {\n  /** Organization ID from x-org-id header */\n  readonly orgId?: string;\n  /** User ID from x-user-id header */\n  readonly userId?: string;\n  /** Request ID from x-request-id header */\n  readonly requestId?: string;\n  /** User role from x-user-role header (decoded from JWT) */\n  readonly role?: string;\n}\n\n/**\n * Canonical org-id normalization: trim + lowercase, empty ⇒ undefined.\n *\n * The SINGLE spelling rule for a tenant id across the fleet. Org ids are\n * 24-hex ObjectId strings (plus the `'system'` sentinel), and hex is\n * case-insensitive — so `Acme`-style casing differences resolve to the SAME\n * Mongo document while string comparisons (`activeOrgId === targetOrgId`, an\n * RLS GUC vs a WHERE clause, a cache key) silently disagree. Everything that\n * compares or keys on an org id normalizes through here so the comparison and\n * the lookup can never drift apart.\n */\nexport function normalizeOrgId(orgId: string | undefined | null): string | undefined {\n  return orgId?.trim().toLowerCase() || undefined;\n}\n\n/**\n * The actor id written when nothing in the request attributes the action to a\n * person — an internal service hop, a scheduler tick, a token whose subject\n * never resolved. One spelling, because the audit trail is queried by it.\n */\nexport const SYSTEM_ACTOR_ID = 'system';\n\n/**\n * The actor id written for an UNAUTHENTICATED actor: an anonymous public plugin\n * submission (docs/plugin-publishing.md — the event carries\n * `details.submissionId` for correlation and is recorded against the system\n * org; the submitter's email, hashed or otherwise, never appears in the audit\n * trail) and platform's pre-auth `device.authorize.start` (a device-login code\n * requested before anyone has signed in). Distinct from {@link SYSTEM_ACTOR_ID}, which means \"no person\n * involved\", not \"a person we don't know\".\n */\nexport const ANONYMOUS_ACTOR_ID = 'anonymous';\n\n/**\n * The actor id written for work the EXPANSION-OFFERS agent did on its own\n * (docs/plans/sales-agent.md D14).\n *\n * Distinct from {@link SYSTEM_ACTOR_ID} because \"why did this account get this\n * offer?\" is the only question anybody will ask about that feature, and the\n * generic system actor makes it unanswerable: the trail shows system work, of\n * which this deployment does a great deal, and nothing would separate an offer\n * the agent decided from a seed, a backfill or an operator script.\n *\n * It also makes the agent's work revocable AS A SET — \"withdraw everything the\n * agent did in the last hour\" is a query on this value rather than an\n * archaeology exercise, which is the control an operator wants on the morning a\n * rule turns out to be wrong.\n *\n * An ACTOR, not a network identity: the agent runs inside billing until Phase 5\n * extracts it, so its service principal is still `billing`. This names who\n * decided, which is what the audit trail is queried by.\n */\nexport const OFFERS_AGENT_ACTOR_ID = 'offers-agent';\n\n/**\n * The actor id to stamp on an audit event, from a route context.\n *\n * One resolver so every route agrees on the fallback: per-route\n * `req.user.sub ?? …` fallbacks disagree, and the same unattributable write\n * would land in the trail under different actors depending on the route.\n *\n * `rc.userId` is already the normalized identity `withRoute` resolved (JWT\n * `sub`, else the `x-user-id` hop header — see {@link getIdentity}), so this is\n * the same value the rest of the request is scoped by, and the ONE place the\n * \"unattributable\" sentinel is chosen. Accepts anything carrying a `userId`,\n * which the route context does — pass `rc`, or `{ userId }` when the handler\n * destructures.\n */\nexport function actorId(rc: { userId?: string | null }): string {\n  return rc.userId || SYSTEM_ACTOR_ID;\n}\n\n/**\n * Extract identity information from request headers.\n *\n * Extracts common identity headers used for multi-tenant authentication:\n * - x-org-id: Organization identifier (INTERNAL SERVICE hops only, see below)\n * - x-user-id: User identifier\n * - x-request-id: Request trace identifier\n * - x-user-role: User role\n *\n * @param req - HTTP request object\n * @returns Identity object with orgId, userId, requestId, and role\n *\n * @example\n * ```typescript\n * app.post('/api/resource', requireAuth, async (req, res) => {\n *   const identity = getIdentity(req);\n *\n *   if (!identity.orgId) {\n *     return sendError(res, 400, 'x-org-id header required');\n *   }\n *\n *   // Use identity.orgId, identity.userId, etc.\n * });\n * ```\n */\nexport function getIdentity(req: HttpRequest): RequestIdentity {\n  // Prefer JWT-verified claims (req.user) over raw headers to prevent\n  // spoofing. Headers are only used as fallback or for fields not in the\n  // JWT (e.g. requestId). The JWT payload uses `sub` for the user id per\n  // OIDC convention; that's our authoritative source.\n  const user = req.user;\n  // The `x-org-id` header is CLIENT-SETTABLE, so it is only ever honored for a\n  // principal that has no tenant of its own to speak for:\n  //   - an INTERNAL SERVICE principal (`principalType: 'service'`), whose token\n  //     names the signing service rather than the tenant it is acting for —\n  //     that is the S2S hop convention (the cascade, the quota client, …); and\n  //   - a request with no verified principal at all (`attachRequestContext`\n  //     runs before `requireAuth`, which recomputes this from the JWT).\n  // For a USER or SERVICE-ACCOUNT principal the JWT is the ONLY authority.\n  // Platform can mint a user token with no `organizationId` (a person between\n  // orgs, mid-invite, mid-onboarding); a `user?.organizationId || header`\n  // fallback would let such a token name any tenant it liked — a value that\n  // flows straight into the RLS tenant GUC. Absent ⇒ undefined ⇒ the route's\n  // `requireOrgId` refuses the call, which is the correct answer.\n  const principalType = user?.principalType;\n  const headerOrgId = getHeaderString(req.headers['x-org-id']);\n  const mayUseHeaderOrg = !user || principalType === 'service';\n  const rawOrgId = user?.organizationId || (mayUseHeaderOrg ? headerOrgId : undefined);\n  // Normalized ONCE here (see normalizeOrgId) so the RLS GUC (`identityScope`\n  // reads this `identity.orgId`) and the app-layer WHERE clauses (route-wrapper\n  // / app-factory) always agree on tenant. A mismatch — GUC set to `Acme` while\n  // WHERE queries `acme` — would silently return no rows.\n  const orgId = normalizeOrgId(rawOrgId);\n  return {\n    orgId,\n    userId: user?.sub || getHeaderString(req.headers['x-user-id']),\n    requestId: getHeaderString(req.headers['x-request-id']),\n    role: user?.role || getHeaderString(req.headers['x-user-role']),\n  };\n}\n"]}

package/lib/utils/index.d.ts

@@ -3,6 +3,7 @@ export * from './api-key.js';
 export * from './safe-require.js';
 export * from './secure-compare.js';
 export * from './crash-handlers.js';
+export * from './concurrency-gate.js';
 export { sendSuccess, sendError, sendQuotaExceeded, quotaExceededMessage, type QuotaExceededDetails, sendPaginatedNested, paginationMeta, type PaginationMeta, extractDbError, errorMessage, sendBadRequest, sendInternalError, parsePaginationParams, type PaginationParams, type SortParams, } from './response.js';
 export { getParam, parseQueryInt, parseQueryString, parseOptionalDate, parsePositiveInt, parseQueryIntClamped, parsePage, validateBulkArray, parseReportInterval, parseReportTimezone, parseWeekStart, isValidTimezone, parseDateRange, type Page, type ReportInterval, type WeekStart, REPORT_INTERVALS, WEEK_STARTS, } from './params.js';
 export * from './headers.js';