@pipeline-builder/api-core 5.2.2 → 5.2.4

package/lib/types/quota-tiers.js

@@ -11,10 +11,123 @@ import { envBool, envInt, envStr } from '../utils/env.js';
  *
  * `storageBytes` is the aggregate registry cap per org. Sized
  * around plugin-image realities: a typical plugin image is 200500 MB;
- * Developer's 2 GB holds ~4 versions × ~500 MB, Pro's 50 GB covers a
+ * Developer's 2 GB holds ~4 versions × ~500 MB, Pro's 25 GB covers a
  * mature catalog. Operators can override per-org via the quota CRUD API.
  */
 const GB = 1024 * 1024 * 1024;
+/**
+ * How the `automationCalls` defaults are sized — written down so the next
+ * person to touch them argues with the arithmetic, not with the numbers.
+ *
+ * Every call an org's automation keys make in one pipeline RUN, itemized (the
+ * earlier sizing counted only the plugin lookups and hand-waved the rest as
+ * "×2"):
+ *
+ *   plugin lookups            12   one per plugin step (self-mutating pipeline)
+ *   synth                      1   the synth step fetching the pipeline config
+ *   runtime check              1   the pre-deploy runtime-check call
+ *   security-report upload     1   the scan step posting its report
+ *   registry register          1   pipeline-register stamping the deployed version
+ *   reporting ingest batches  12   the event forwarder posts ~one batch per action
+ *                             --
+ *                             28   calls per run
+ *
+ * Per default period (`QUOTA_RESET_DAYS`, 3 days) one active pipeline running
+ * hourly makes 28 × 24 × 3 = 2,016 calls. An org keeps far more pipelines alive
+ * than it CREATES in a period (`pipelines` is a creation rate), so active
+ * pipelines are taken as 4× the tier's `pipelines`. On top sits a per-ORG
+ * constant that does not scale with pipelines: the ingest-health heartbeat
+ * (≤ 1/minute → 1,440/day → 4,320/period). The sum gets 25% headroom (retries,
+ * registry pushes, ad-hoc CI scripts on keys) and rounds UP to the next 10,000:
+ *
+ *   developer   2×4×2016 + 4320 =  20,448 × 1.25 =  25,560 →  30,000
+ *   pro         5×4×2016 + 4320 =  44,640 × 1.25 =  55,800 →  60,000
+ *   team       10×4×2016 + 4320 =  84,960 × 1.25 = 106,200 → 110,000
+ *   business   20×4×2016 + 4320 = 165,600 × 1.25 = 207,000 → 210,000
+ *   enterprise 30×4×2016 + 4320 = 246,240 × 1.25 = 307,800 → 310,000
+ *
+ * {@link automationCallsFor} computes exactly this, and the tier tests hold the
+ * table to it. Over the cap the 429 is SOFT for a band ({@link quotaGracePct}):
+ * a self-mutating pipeline that hard-stopped at 100% stayed stopped until the
+ * period reset, up to 3 days. The limits are PER PERIOD: an operator who
+ * lengthens `QUOTA_RESET_DAYS` should scale `QUOTA_TIER_<TIER>_AUTOMATION_CALLS`
+ * by the same factor.
+ */
+export const AUTOMATION_CALLS_SIZING = {
+    callsPerRun: {
+        pluginLookups: 12,
+        synth: 1,
+        runtimeCheck: 1,
+        securityReportUpload: 1,
+        registryRegister: 1,
+        ingestBatches: 12,
+    },
+    runsPerDay: 24,
+    activePipelinesPerCreation: 4,
+    /** Ingest-health heartbeats per org per day (≤ one a minute). */
+    heartbeatsPerDay: 1440,
+    /** Multiplier on the itemized total. */
+    headroom: 1.25,
+    /** Defaults round UP to a multiple of this. */
+    roundTo: 10_000,
+};
+/** The {@link AUTOMATION_CALLS_SIZING} formula for a tier creating `pipelines` per period. */
+export function automationCallsFor(pipelines, periodDays = 3) {
+    const s = AUTOMATION_CALLS_SIZING;
+    const perRun = Object.values(s.callsPerRun).reduce((a, b) => a + b, 0);
+    const perPipeline = perRun * s.runsPerDay * periodDays;
+    const total = (pipelines * s.activePipelinesPerCreation * perPipeline + s.heartbeatsPerDay * periodDays) * s.headroom;
+    return Math.ceil(total / s.roundTo) * s.roundTo;
+}
+/**
+ * The SOFT band above a quota's cap, per type, in percent of the limit. A type
+ * absent from this map has NO band and stops hard at 100%.
+ *
+ * At 100% the account gets the "reached" notice and keeps running; the refusal
+ * starts only past `limit × (100 + pct) / 100`. Reads still REPORT the nominal
+ * limit, so usage shows above 100% while inside the band.
+ *
+ * Two types qualify, for the same reason stated two ways — a hard stop exactly
+ * at 100% is worse than a short overrun when the caller cannot simply wait:
+ *
+ * - `automationCalls` (`QUOTA_AUTOMATION_GRACE_PCT`): the caller is a pipeline
+ *   mid-deploy, not a person, and the counter would stay full for the rest of
+ *   the period.
+ * - `storageBytes` (`QUOTA_STORAGE_GRACE_PCT`): storage is a STOCK — it does
+ *   not reset, so without a band a downgrade or a cancelled pack flips an
+ *   account from working to refused with no buffer at all, and the remedy
+ *   (prune, or buy capacity) takes time the band is there to provide. Note the
+ *   band on a stock is a ONE-TIME buffer rather than a per-period one; that is
+ *   its purpose here, not a limitation of it.
+ *
+ * Every other type stays hard. This was a hardcoded `quotaType !==
+ * 'automationCalls'` comparison, which is why storage had nothing: the
+ * mechanism existed and only the predicate excluded it.
+ */
+const QUOTA_GRACE_PCT = {
+    automationCalls: envInt('QUOTA_AUTOMATION_GRACE_PCT', 10, { min: 0, max: 100 }),
+    storageBytes: envInt('QUOTA_STORAGE_GRACE_PCT', 10, { min: 0, max: 100 }),
+};
+/** The soft band for `quotaType` in percent, or 0 for a type that stops hard. */
+export function quotaGracePct(quotaType) {
+    return QUOTA_GRACE_PCT[quotaType] ?? 0;
+}
+/**
+ * The limit enforcement actually binds on for `quotaType`: the nominal limit,
+ * plus the type's {@link quotaGracePct} band where it has one. Unlimited (-1)
+ * and zero ("none") limits are returned unchanged — a 0 cap is a deliberate
+ * refusal, not a budget to overrun.
+ *
+ * {@link QUOTA_GRACE_PCT} decides WHETHER a type has a band; `gracePct` only
+ * sizes it. So an explicit percentage passed for an unbanded type still yields
+ * the nominal limit, rather than quietly granting a band the type is not meant
+ * to have.
+ */
+export function enforcedQuotaLimit(quotaType, limit, gracePct = quotaGracePct(quotaType)) {
+    if (limit <= 0 || gracePct <= 0 || quotaGracePct(quotaType) <= 0)
+        return limit;
+    return Math.floor((limit * (100 + gracePct)) / 100);
+}
 /**
  * Code-default limits per tier — the fallback when no env override is set.
  * -1 means unlimited. (Counts sized to "comfortably enough for one team, not
@@ -30,7 +143,9 @@ const DEFAULT_TIER_LIMITS = {
         plugins: 10,
         pipelines: 2,
         apiCalls: 25_000,
+        automationCalls: 30_000,
         aiCalls: 20,
+        cpuCredits: 4_500,
         storageBytes: 2 * GB,
         dashboards: 20,
         alertRules: 50,
@@ -38,6 +153,8 @@ const DEFAULT_TIER_LIMITS = {
         idpConfigs: 1,
         listings: 3,
         seats: 1,
+        supportContacts: 0,
+        supportPremiumContacts: 0,
         eventRetentionDays: 30,
         doraRetentionDays: 180,
     },
@@ -49,7 +166,9 @@ const DEFAULT_TIER_LIMITS = {
         plugins: 25,
         pipelines: 5,
         apiCalls: 100_000,
+        automationCalls: 60_000,
         aiCalls: 200,
+        cpuCredits: 11_250,
         storageBytes: 25 * GB,
         dashboards: 200,
         alertRules: 500,
@@ -57,6 +176,8 @@ const DEFAULT_TIER_LIMITS = {
         idpConfigs: 5,
         listings: 10,
         seats: 1,
+        supportContacts: 0,
+        supportPremiumContacts: 0,
         eventRetentionDays: 30,
         doraRetentionDays: 180,
     },
@@ -68,7 +189,9 @@ const DEFAULT_TIER_LIMITS = {
         plugins: 50,
         pipelines: 10,
         apiCalls: 300_000,
+        automationCalls: 110_000,
         aiCalls: 600,
+        cpuCredits: 22_500,
         storageBytes: 60 * GB,
         dashboards: -1,
         alertRules: -1,
@@ -76,6 +199,8 @@ const DEFAULT_TIER_LIMITS = {
         idpConfigs: 5,
         listings: 25,
         seats: 3,
+        supportContacts: 0,
+        supportPremiumContacts: 0,
         eventRetentionDays: 30,
         doraRetentionDays: 180,
     },
@@ -89,7 +214,9 @@ const DEFAULT_TIER_LIMITS = {
         plugins: 100,
         pipelines: 20,
         apiCalls: 800_000,
+        automationCalls: 210_000,
         aiCalls: 1_600,
+        cpuCredits: 45_000,
         storageBytes: 120 * GB,
         dashboards: -1,
         alertRules: -1,
@@ -97,6 +224,8 @@ const DEFAULT_TIER_LIMITS = {
         idpConfigs: 10,
         listings: 50,
         seats: 8,
+        supportContacts: 0,
+        supportPremiumContacts: 0,
         eventRetentionDays: 30,
         doraRetentionDays: 180,
     },
@@ -108,7 +237,9 @@ const DEFAULT_TIER_LIMITS = {
         plugins: 150,
         pipelines: 30,
         apiCalls: 1_500_000,
+        automationCalls: 310_000,
         aiCalls: 3_000,
+        cpuCredits: 67_500,
         storageBytes: 250 * GB,
         dashboards: -1,
         alertRules: -1,
@@ -116,6 +247,8 @@ const DEFAULT_TIER_LIMITS = {
         idpConfigs: -1,
         listings: 100,
         seats: 15,
+        supportContacts: 0,
+        supportPremiumContacts: 0,
         eventRetentionDays: 30,
         doraRetentionDays: 180,
     },
@@ -125,7 +258,9 @@ const DEFAULT_TIER_LIMITS = {
         plugins: -1,
         pipelines: -1,
         apiCalls: -1,
+        automationCalls: -1,
         aiCalls: -1,
+        cpuCredits: -1,
         storageBytes: -1,
         dashboards: -1,
         alertRules: -1,
@@ -133,6 +268,8 @@ const DEFAULT_TIER_LIMITS = {
         idpConfigs: -1,
         listings: -1,
         seats: -1,
+        supportContacts: -1,
+        supportPremiumContacts: -1,
         eventRetentionDays: -1,
         doraRetentionDays: -1,
     },
@@ -171,14 +308,18 @@ function tierLimits(tier) {
         plugins: tierLimitEnv(`QUOTA_TIER_${T}_PLUGINS`, d.plugins),
         pipelines: tierLimitEnv(`QUOTA_TIER_${T}_PIPELINES`, d.pipelines),
         apiCalls: tierLimitEnv(`QUOTA_TIER_${T}_API_CALLS`, d.apiCalls),
+        automationCalls: tierLimitEnv(`QUOTA_TIER_${T}_AUTOMATION_CALLS`, d.automationCalls),
         aiCalls: tierLimitEnv(`QUOTA_TIER_${T}_AI_CALLS`, d.aiCalls),
         storageBytes: tierLimitEnv(`QUOTA_TIER_${T}_STORAGE_BYTES`, d.storageBytes),
+        cpuCredits: tierLimitEnv(`QUOTA_TIER_${T}_CPU_CREDITS`, d.cpuCredits),
         dashboards: tierLimitEnv(`QUOTA_TIER_${T}_DASHBOARDS`, d.dashboards),
         alertRules: tierLimitEnv(`QUOTA_TIER_${T}_ALERT_RULES`, d.alertRules),
         alertDestinations: tierLimitEnv(`QUOTA_TIER_${T}_ALERT_DESTINATIONS`, d.alertDestinations),
         idpConfigs: tierLimitEnv(`QUOTA_TIER_${T}_IDP_CONFIGS`, d.idpConfigs),
         listings: tierLimitEnv(`QUOTA_TIER_${T}_LISTINGS`, d.listings),
         seats: tierLimitEnv(`QUOTA_TIER_${T}_SEATS`, d.seats),
+        supportContacts: tierLimitEnv(`QUOTA_TIER_${T}_SUPPORT_CONTACTS`, d.supportContacts),
+        supportPremiumContacts: tierLimitEnv(`QUOTA_TIER_${T}_SUPPORT_PREMIUM_CONTACTS`, d.supportPremiumContacts),
         eventRetentionDays: tierLimitEnv(`QUOTA_TIER_${T}_EVENT_RETENTION_DAYS`, d.eventRetentionDays),
         doraRetentionDays: tierLimitEnv(`QUOTA_TIER_${T}_DORA_RETENTION_DAYS`, d.doraRetentionDays),
     };
@@ -259,10 +400,34 @@ export function getTierLimits(tier) {
  */
 export const QUOTA_RESET_DAYS = envInt('QUOTA_RESET_DAYS', 3, { min: 1 });
 /** The next quota reset: local midnight `days` from `now`. */
+/**
+ * The `cpuCredits` period, in days. A MONTH rather than the global three-day
+ * window, because build demand is bursty in a way API traffic is not: a full
+ * catalogue rebuild is a day's work that arrives on one day, and a three-day
+ * window refuses it while the account holds most of a month's budget unspent.
+ */
+export const CPU_CREDITS_PERIOD_DAYS = envInt('QUOTA_CPU_CREDITS_PERIOD_DAYS', 30, { min: 1 });
+/**
+ * The usage period for ONE quota type, in days.
+ *
+ * Every flow quota but `cpuCredits` rolls on the global {@link QUOTA_RESET_DAYS}.
+ * Credits are monthly, which makes the period a PER-TYPE fact — so anything that
+ * computes a reset date, a "resets in N days" line or a burn-rate forecast has
+ * to ask for the type's own period rather than reading the global constant. A
+ * forecast against the wrong window is wrong by a factor of ten.
+ *
+ * Stocks (`storageBytes` and the resource counts) have no period at all; this
+ * returns the global window for them because callers gate on
+ * `quotaAccrual(type) === 'stock'` before using it, and returning a figure is
+ * less disruptive than making every caller handle a null. Check the accrual.
+ */
+export function quotaPeriodDays(type) {
+    return type === 'cpuCredits' ? CPU_CREDITS_PERIOD_DAYS : QUOTA_RESET_DAYS;
+}
 export function nextQuotaResetDate(days = QUOTA_RESET_DAYS, now = new Date()) {
     const date = new Date(now);
     date.setDate(date.getDate() + days);
     date.setHours(0, 0, 0, 0);
     return date;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quota-tiers.js","sourceRoot":"","sources":["../../src/types/quota-tiers.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AA6D1D;;;;;;;;;;;;GAYG;AACH,MAAM,EAAE,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAE9B;;;;;;GAMG;AACH,MAAM,mBAAmB,GAAuC;IAC9D,0EAA0E;IAC1E,4EAA4E;IAC5E,8EAA8E;IAC9E,SAAS,EAAE;QACT,OAAO,EAAE,EAAE;QACX,SAAS,EAAE,CAAC;QACZ,QAAQ,EAAE,MAAM;QAChB,OAAO,EAAE,EAAE;QACX,YAAY,EAAE,CAAC,GAAG,EAAE;QACpB,UAAU,EAAE,EAAE;QACd,UAAU,EAAE,EAAE;QACd,iBAAiB,EAAE,EAAE;QACrB,UAAU,EAAE,CAAC;QACb,QAAQ,EAAE,CAAC;QACX,KAAK,EAAE,CAAC;QACR,kBAAkB,EAAE,EAAE;QACtB,iBAAiB,EAAE,GAAG;KACvB;IACD,+EAA+E;IAC/E,gFAAgF;IAChF,gFAAgF;IAChF,8EAA8E;IAC9E,GAAG,EAAE;QACH,OAAO,EAAE,EAAE;QACX,SAAS,EAAE,CAAC;QACZ,QAAQ,EAAE,OAAO;QACjB,OAAO,EAAE,GAAG;QACZ,YAAY,EAAE,EAAE,GAAG,EAAE;QACrB,UAAU,EAAE,GAAG;QACf,UAAU,EAAE,GAAG;QACf,iBAAiB,EAAE,EAAE;QACrB,UAAU,EAAE,CAAC;QACb,QAAQ,EAAE,EAAE;QACZ,KAAK,EAAE,CAAC;QACR,kBAAkB,EAAE,EAAE;QACtB,iBAAiB,EAAE,GAAG;KACvB;IACD,gFAAgF;IAChF,gFAAgF;IAChF,2EAA2E;IAC3E,8BAA8B;IAC9B,IAAI,EAAE;QACJ,OAAO,EAAE,EAAE;QACX,SAAS,EAAE,EAAE;QACb,QAAQ,EAAE,OAAO;QACjB,OAAO,EAAE,GAAG;QACZ,YAAY,EAAE,EAAE,GAAG,EAAE;QACrB,UAAU,EAAE,CAAC,CAAC;QACd,UAAU,EAAE,CAAC,CAAC;QACd,iBAAiB,EAAE,CAAC,CAAC;QACrB,UAAU,EAAE,CAAC;QACb,QAAQ,EAAE,EAAE;QACZ,KAAK,EAAE,CAAC;QACR,kBAAkB,EAAE,EAAE;QACtB,iBAAiB,EAAE,GAAG;KACvB;IACD,2EAA2E;IAC3E,2EAA2E;IAC3E,2EAA2E;IAC3E,8EAA8E;IAC9E,6EAA6E;IAC7E,qEAAqE;IACrE,QAAQ,EAAE;QACR,OAAO,EAAE,GAAG;QACZ,SAAS,EAAE,EAAE;QACb,QAAQ,EAAE,OAAO;QACjB,OAAO,EAAE,KAAK;QACd,YAAY,EAAE,GAAG,GAAG,EAAE;QACtB,UAAU,EAAE,CAAC,CAAC;QACd,UAAU,EAAE,CAAC,CAAC;QACd,iBAAiB,EAAE,CAAC,CAAC;QACrB,UAAU,EAAE,EAAE;QACd,QAAQ,EAAE,EAAE;QACZ,KAAK,EAAE,CAAC;QACR,kBAAkB,EAAE,EAAE;QACtB,iBAAiB,EAAE,GAAG;KACvB;IACD,gFAAgF;IAChF,oFAAoF;IACpF,sEAAsE;IACtE,6EAA6E;IAC7E,UAAU,EAAE;QACV,OAAO,EAAE,GAAG;QACZ,SAAS,EAAE,EAAE;QACb,QAAQ,EAAE,SAAS;QACnB,OAAO,EAAE,KAAK;QACd,YAAY,EAAE,GAAG,GAAG,EAAE;QACtB,UAAU,EAAE,CAAC,CAAC;QACd,UAAU,EAAE,CAAC,CAAC;QACd,iBAAiB,EAAE,CAAC,CAAC;QACrB,UAAU,EAAE,CAAC,CAAC;QACd,QAAQ,EAAE,GAAG;QACb,KAAK,EAAE,EAAE;QACT,kBAAkB,EAAE,EAAE;QACtB,iBAAiB,EAAE,GAAG;KACvB;IACD,6EAA6E;IAC7E,6EAA6E;IAC7E,SAAS,EAAE;QACT,OAAO,EAAE,CAAC,CAAC;QACX,SAAS,EAAE,CAAC,CAAC;QACb,QAAQ,EAAE,CAAC,CAAC;QACZ,OAAO,EAAE,CAAC,CAAC;QACX,YAAY,EAAE,CAAC,CAAC;QAChB,UAAU,EAAE,CAAC,CAAC;QACd,UAAU,EAAE,CAAC,CAAC;QACd,iBAAiB,EAAE,CAAC,CAAC;QACrB,UAAU,EAAE,CAAC,CAAC;QACd,QAAQ,EAAE,CAAC,CAAC;QACZ,KAAK,EAAE,CAAC,CAAC;QACT,kBAAkB,EAAE,CAAC,CAAC;QACtB,iBAAiB,EAAE,CAAC,CAAC;KACtB;CACF,CAAC;AAEF;;;;;GAKG;AACH,SAAS,YAAY,CAAC,IAAY,EAAE,QAAgB;IAClD,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;IACjC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;AAC/B,CAAC;AAED;;;;;GAKG;AACH,SAAS,UAAU,CAAC,IAAe;IACjC,yEAAyE;IACzE,6EAA6E;IAC7E,+EAA+E;IAC/E,8EAA8E;IAC9E,+EAA+E;IAC/E,IAAI,IAAI,KAAK,WAAW,EAAE,CAAC;QACzB,MAAM,QAAQ,GAAG,EAAE,GAAG,mBAAmB,CAAC,SAAS,EAAE,CAAC;QACtD,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAA8B;YAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QACrF,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,MAAM,CAAC,GAAG,mBAAmB,CAAC,IAAI,CAAC,CAAC;IACpC,MAAM,CAAC,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;IAC7B,OAAO;QACL,OAAO,EAAE,YAAY,CAAC,cAAc,CAAC,UAAU,EAAE,CAAC,CAAC,OAAO,CAAC;QAC3D,SAAS,EAAE,YAAY,CAAC,cAAc,CAAC,YAAY,EAAE,CAAC,CAAC,SAAS,CAAC;QACjE,QAAQ,EAAE,YAAY,CAAC,cAAc,CAAC,YAAY,EAAE,CAAC,CAAC,QAAQ,CAAC;QAC/D,OAAO,EAAE,YAAY,CAAC,cAAc,CAAC,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC;QAC5D,YAAY,EAAE,YAAY,CAAC,cAAc,CAAC,gBAAgB,EAAE,CAAC,CAAC,YAAY,CAAC;QAC3E,UAAU,EAAE,YAAY,CAAC,cAAc,CAAC,aAAa,EAAE,CAAC,CAAC,UAAU,CAAC;QACpE,UAAU,EAAE,YAAY,CAAC,cAAc,CAAC,cAAc,EAAE,CAAC,CAAC,UAAU,CAAC;QACrE,iBAAiB,EAAE,YAAY,CAAC,cAAc,CAAC,qBAAqB,EAAE,CAAC,CAAC,iBAAiB,CAAC;QAC1F,UAAU,EAAE,YAAY,CAAC,cAAc,CAAC,cAAc,EAAE,CAAC,CAAC,UAAU,CAAC;QACrE,QAAQ,EAAE,YAAY,CAAC,cAAc,CAAC,WAAW,EAAE,CAAC,CAAC,QAAQ,CAAC;QAC9D,KAAK,EAAE,YAAY,CAAC,cAAc,CAAC,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC;QACrD,kBAAkB,EAAE,YAAY,CAAC,cAAc,CAAC,uBAAuB,EAAE,CAAC,CAAC,kBAAkB,CAAC;QAC9F,iBAAiB,EAAE,YAAY,CAAC,cAAc,CAAC,sBAAsB,EAAE,CAAC,CAAC,iBAAiB,CAAC;KAC5F,CAAC;AACJ,CAAC;AAED,4EAA4E;AAC5E,MAAM,CAAC,MAAM,WAAW,GAAuC;IAC7D,SAAS,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,4BAA4B,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC,EAAE;IACxG,GAAG,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,sBAAsB,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,KAAK,CAAC,EAAE;IAChF,IAAI,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,uBAAuB,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC,EAAE;IACpF,QAAQ,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,2BAA2B,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,UAAU,CAAC,EAAE;IACpG,UAAU,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,6BAA6B,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,YAAY,CAAC,EAAE;IAC5G,SAAS,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,4BAA4B,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC,EAAE;CACzG,CAAC;AAEF;mFACmF;AACnF,MAAM,CAAC,MAAM,WAAW,GAAyB,MAAM,CAAC,IAAI,CAAC,WAAW,CAAgB,CAAC;AAEzF;;;qFAGqF;AACrF,MAAM,CAAC,MAAM,cAAc,GAAyB,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,WAAW,CAAC,CAAC;AAEjG;;;kEAGkE;AAClE,MAAM,CAAC,MAAM,kBAAkB,GAAyB,CAAC,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,CAAC,CAAC;AACxG,MAAM,UAAU,eAAe,CAAC,IAA+B;IAC7D,OAAO,CAAC,CAAC,IAAI,IAAK,kBAAwC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AAC5E,CAAC;AAED;;;8EAG8E;AAC9E,MAAM,CAAC,MAAM,eAAe,GAAyB,CAAC,MAAM,EAAE,UAAU,EAAE,YAAY,CAAC,CAAC;AAKxF;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAC,IAA+B;IACxD,IAAI,CAAC,IAAI,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,IAAI,KAAK,WAAW;QAAE,OAAO,IAAI,CAAC;IACrE,OAAQ,eAAqC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC;AACzF,CAAC;AAED;;mFAEmF;AACnF,MAAM,UAAU,gBAAgB;IAC9B,OAAO,OAAO,CAAC,iBAAiB,EAAE,IAAI,CAAC,CAAC;AAC1C,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAAc,CAAC,gBAAgB,EAAE;IACxD,CAAC,CAAC,WAAW;IACb,CAAC,CAAC,CAAC,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,IAAI,EAAE,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,kBAAkB,KAAK,WAAW;QACpG,CAAC,CAAE,OAAO,CAAC,GAAG,CAAC,kBAAgC;QAC/C,CAAC,CAAC,WAAW,CAAC,CAAC;AAEnB,mDAAmD;AACnD,MAAM,UAAU,WAAW,CAAC,KAAa;IACvC,+EAA+E;IAC/E,8EAA8E;IAC9E,6EAA6E;IAC7E,kFAAkF;IAClF,OAAQ,WAAiC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAC5D,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,OAAO,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,MAAM,CAAA,CAAC,CAAC,WAAW,CAAC,SAAS,CAAC,MAAM,CAAC;AACpF,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC,kBAAkB,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;AAE1E,8DAA8D;AAC9D,MAAM,UAAU,kBAAkB,CAAC,IAAI,GAAW,gBAAgB,EAAE,GAAG,GAAS,IAAI,IAAI,EAAE;IACxF,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC;IAC3B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;IACpC,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1B,OAAO,IAAI,CAAC;AACd,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { envBool, envInt, envStr } from '../utils/env.js';\n\n/** Available quota tier identifiers.\n *\n * `unlimited` is a special tier: every quota is `-1` (uncapped) and it includes\n * every feature/add-on bundle. It is the DEFAULT when billing is disabled (no\n * metering/enforcement surface exists, so nothing is capped), and it is NEVER\n * shown or selectable when billing is enabled — see `STANDARD_TIERS`. */\nexport type QuotaTier = 'developer' | 'pro' | 'team' | 'business' | 'enterprise' | 'unlimited';\n\n/** Limit values for each quota type within a tier. */\nexport interface QuotaTierLimits {\n  plugins: number;\n  pipelines: number;\n  apiCalls: number;\n  aiCalls: number;\n  /**\n   * Aggregate registry storage cap in BYTES. Counted across every repo\n   * under the org's `org-{orgId}/` namespace. -1 means unlimited.\n   * push-gate reads this; the image-registry rejects token issuance for\n   * `push` scope when the org's measured usage exceeds the limit.\n   */\n  storageBytes: number;\n  /** Count-quotas on the user-editable feature tables added to close per-org\n   *  DoS via spam. -1 means unlimited. */\n  dashboards: number;\n  alertRules: number;\n  alertDestinations: number;\n  idpConfigs: number;\n  /**\n   * Active, non-suspended plugin-ecosystem listings the org publishes\n   * (docs/plugin-installing.md). A COUNT quota — installs never\n   * count. -1 = unlimited. Extendable via the `listing_pack` add-on bundle.\n   */\n  listings: number;\n  /**\n   * Max org members (active users / seats). -1 = unlimited. This is the \"Team\"\n   * tier differentiator — enforced at member-invite time (an invite is blocked\n   * when active members + pending invites would exceed this).\n   */\n  seats: number;\n  /**\n   * Reporting retention in DAYS — NOT a flow quota (never decremented, absent\n   * from `VALID_QUOTA_TYPES`): these ride the tier-baseline + bundle-grant math\n   * purely as an entitlement the billing service syncs to reporting's\n   * `dora_settings`. -1 = unlimited (the sweep skips the org entirely).\n   *   `eventRetentionDays` — non-deploy `pipeline_events` (STAGE/ACTION/build).\n   *   `doraRetentionDays`  — deploy events + `deployment_outcomes` + `incidents`,\n   *                          and the per-org report-query window for DORA routes.\n   * Extendable via the `retention_pack` / `dora_history_pack` add-on bundles.\n   */\n  eventRetentionDays: number;\n  doraRetentionDays: number;\n}\n\n/** Full preset for a single tier (label + limits). */\nexport interface QuotaTierPreset {\n  label: string;\n  limits: QuotaTierLimits;\n}\n\n/**\n * Preset limits for each tier. -1 means unlimited.\n *\n * AI calls are sized much smaller than `apiCalls` because each call has\n * external provider cost (~$0.01$0.10/call). Developer tier allows light\n * exploration (50/period); Pro lifts to 2,500; Enterprise is capped high\n * (25,000) — fair-use, not literally unlimited.\n *\n * `storageBytes` is the aggregate registry cap per org. Sized\n * around plugin-image realities: a typical plugin image is 200500 MB;\n * Developer's 2 GB holds ~4 versions × ~500 MB, Pro's 50 GB covers a\n * mature catalog. Operators can override per-org via the quota CRUD API.\n */\nconst GB = 1024 * 1024 * 1024;\n\n/**\n * Code-default limits per tier — the fallback when no env override is set.\n * -1 means unlimited. (Counts sized to \"comfortably enough for one team, not\n * script spam\": 20 dashboards, 50 alert rules, 10 destinations, 1 IdP config\n * for Developer; scaled up for Pro; -1 (uncapped) for the cheap count-quotas\n * on Team/Enterprise while cost-driving quotas — incl. apiCalls — stay finite.)\n */\nconst DEFAULT_TIER_LIMITS: Record<QuotaTier, QuotaTierLimits> = {\n  // Free tier: single seat, 2 pipelines, apiCalls CAPPED (was unlimited — a\n  // DoS/abuse hole on a shared resource); aiCalls small (each has ~$0.01-0.10\n  // external cost). Lean base — growth happens by upgrading, not stacking here.\n  developer: {\n    plugins: 10,\n    pipelines: 2,\n    apiCalls: 25_000,\n    aiCalls: 20,\n    storageBytes: 2 * GB,\n    dashboards: 20,\n    alertRules: 50,\n    alertDestinations: 10,\n    idpConfigs: 1,\n    listings: 3,\n    seats: 1,\n    eventRetentionDays: 30,\n    doraRetentionDays: 180,\n  },\n  // Pro = individual power user, single seat, individual pricing. A 2nd seat (or\n  // team collaboration) requires the Team tier — the `seat` add-on is Team+ only,\n  // keeping Team the collaboration tier. Pro's value over Developer is its richer\n  // call/storage/plugin ceilings + feature add-ons (SSO/audit/DORA), not seats.\n  pro: {\n    plugins: 25,\n    pipelines: 5,\n    apiCalls: 100_000,\n    aiCalls: 200,\n    storageBytes: 25 * GB,\n    dashboards: 200,\n    alertRules: 500,\n    alertDestinations: 50,\n    idpConfigs: 5,\n    listings: 10,\n    seats: 1,\n    eventRetentionDays: 30,\n    doraRetentionDays: 180,\n  },\n  // Team = collaboration tier; the seat limit (3) is the real differentiator over\n  // Pro (single-seat) — it's the multi-seat collaboration floor. Lean base ($79):\n  // growth rides the seat/pipeline/etc add-ons (land-and-expand). Limits sit\n  // between Pro and Enterprise.\n  team: {\n    plugins: 50,\n    pipelines: 10,\n    apiCalls: 300_000,\n    aiCalls: 600,\n    storageBytes: 60 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: 5,\n    listings: 25,\n    seats: 3,\n    eventRetentionDays: 30,\n    doraRetentionDays: 180,\n  },\n  // Business ($249): the step the $79 -> $599 cliff was missing. 8 seats, 20\n  // pipelines, and DORA (advanced_reporting) included rather than an add-on.\n  // Every cost driver is 100,000 apiCalls and 200 aiCalls PER SEAT, the same\n  // per-seat rate as Pro/Team/Enterprise, so the ladder reads consistently to a\n  // buyer who divides by headcount. Count-quotas that Team already uncaps stay\n  // -1; `idpConfigs` sits between Team's 5 and Enterprise's unlimited.\n  business: {\n    plugins: 100,\n    pipelines: 20,\n    apiCalls: 800_000,\n    aiCalls: 1_600,\n    storageBytes: 120 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: 10,\n    listings: 50,\n    seats: 8,\n    eventRetentionDays: 30,\n    doraRetentionDays: 180,\n  },\n  // Enterprise ($599, held): the all-inclusive tier — 15 seats, 30 pipelines, ALL\n  // premium features included (see TIER_FEATURES). FAIR-USE — cost drivers (apiCalls,\n  // aiCalls, storageBytes) capped so one account can't run up unbounded\n  // compute/provider/storage cost on a flat price; cheap count-quotas stay -1.\n  enterprise: {\n    plugins: 150,\n    pipelines: 30,\n    apiCalls: 1_500_000,\n    aiCalls: 3_000,\n    storageBytes: 250 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: -1,\n    listings: 100,\n    seats: 15,\n    eventRetentionDays: 30,\n    doraRetentionDays: 180,\n  },\n  // Unlimited: EVERY quota uncapped (-1). The default when billing is disabled\n  // (no enforcement surface) — never shown/selectable when billing is enabled.\n  unlimited: {\n    plugins: -1,\n    pipelines: -1,\n    apiCalls: -1,\n    aiCalls: -1,\n    storageBytes: -1,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: -1,\n    listings: -1,\n    seats: -1,\n    eventRetentionDays: -1,\n    doraRetentionDays: -1,\n  },\n};\n\n/**\n * Read a tier LIMIT env var. `-1` = unlimited; anything below that is nonsense\n * (a `-5` limit would ship a broken finite cap), so it falls back to the code\n * default rather than clamping up to `-1`. The parsing itself is api-core's\n * shared `envInt` — strict about decimals/garbage — not a local re-derivation.\n */\nfunction tierLimitEnv(name: string, fallback: number): number {\n  const n = envInt(name, fallback);\n  return n < -1 ? fallback : n;\n}\n\n/**\n * Per-tier limits, each overridable via `QUOTA_TIER_<TIER>_<LIMIT>` env vars\n * (e.g. `QUOTA_TIER_PRO_PIPELINES=250`, `QUOTA_TIER_DEVELOPER_STORAGE_BYTES=...`).\n * Unset/empty → the code default. `-1` = unlimited. Read once at module load —\n * on k8s these flow in via the `app-env` ConfigMap (built from `.env`).\n */\nfunction tierLimits(tier: QuotaTier): QuotaTierLimits {\n  // `unlimited` is uncapped BY DEFINITION: EVERY quota is -1 and it is NOT\n  // env-overridable. Reading QUOTA_TIER_UNLIMITED_* here would let a stray env\n  // var silently cap the billing-DISABLED default tier — surfacing as a spurious\n  // \"quota exceeded\" on a deploy that meters nothing. Derive -1 for every field\n  // from the limits shape so a newly-added quota is uncapped here automatically.\n  if (tier === 'unlimited') {\n    const uncapped = { ...DEFAULT_TIER_LIMITS.unlimited };\n    for (const k of Object.keys(uncapped) as (keyof QuotaTierLimits)[]) uncapped[k] = -1;\n    return uncapped;\n  }\n  const d = DEFAULT_TIER_LIMITS[tier];\n  const T = tier.toUpperCase();\n  return {\n    plugins: tierLimitEnv(`QUOTA_TIER_${T}_PLUGINS`, d.plugins),\n    pipelines: tierLimitEnv(`QUOTA_TIER_${T}_PIPELINES`, d.pipelines),\n    apiCalls: tierLimitEnv(`QUOTA_TIER_${T}_API_CALLS`, d.apiCalls),\n    aiCalls: tierLimitEnv(`QUOTA_TIER_${T}_AI_CALLS`, d.aiCalls),\n    storageBytes: tierLimitEnv(`QUOTA_TIER_${T}_STORAGE_BYTES`, d.storageBytes),\n    dashboards: tierLimitEnv(`QUOTA_TIER_${T}_DASHBOARDS`, d.dashboards),\n    alertRules: tierLimitEnv(`QUOTA_TIER_${T}_ALERT_RULES`, d.alertRules),\n    alertDestinations: tierLimitEnv(`QUOTA_TIER_${T}_ALERT_DESTINATIONS`, d.alertDestinations),\n    idpConfigs: tierLimitEnv(`QUOTA_TIER_${T}_IDP_CONFIGS`, d.idpConfigs),\n    listings: tierLimitEnv(`QUOTA_TIER_${T}_LISTINGS`, d.listings),\n    seats: tierLimitEnv(`QUOTA_TIER_${T}_SEATS`, d.seats),\n    eventRetentionDays: tierLimitEnv(`QUOTA_TIER_${T}_EVENT_RETENTION_DAYS`, d.eventRetentionDays),\n    doraRetentionDays: tierLimitEnv(`QUOTA_TIER_${T}_DORA_RETENTION_DAYS`, d.doraRetentionDays),\n  };\n}\n\n// Labels are overridable via `QUOTA_TIER_<TIER>_LABEL` (display name only).\nexport const QUOTA_TIERS: Record<QuotaTier, QuotaTierPreset> = {\n  developer: { label: envStr('QUOTA_TIER_DEVELOPER_LABEL', 'Developer'), limits: tierLimits('developer') },\n  pro: { label: envStr('QUOTA_TIER_PRO_LABEL', 'Pro'), limits: tierLimits('pro') },\n  team: { label: envStr('QUOTA_TIER_TEAM_LABEL', 'Team'), limits: tierLimits('team') },\n  business: { label: envStr('QUOTA_TIER_BUSINESS_LABEL', 'Business'), limits: tierLimits('business') },\n  enterprise: { label: envStr('QUOTA_TIER_ENTERPRISE_LABEL', 'Enterprise'), limits: tierLimits('enterprise') },\n  unlimited: { label: envStr('QUOTA_TIER_UNLIMITED_LABEL', 'Unlimited'), limits: tierLimits('unlimited') },\n};\n\n/** All valid tier names (incl. `unlimited`). Used for validation of a *stored*\n *  tier — `unlimited` is a valid value even though it's never offered for sale. */\nexport const VALID_TIERS: readonly QuotaTier[] = Object.keys(QUOTA_TIERS) as QuotaTier[];\n\n/** The standard, billing-selectable tiers — the ones offered as purchasable plans\n *  and shown in tier pickers. Derived as \"every valid tier except `unlimited`\",\n *  which is the billing-DISABLED default and is never displayed/selectable when\n *  billing is enabled. Kept DRY off `VALID_TIERS` so adding a tier flows through. */\nexport const STANDARD_TIERS: readonly QuotaTier[] = VALID_TIERS.filter((t) => t !== 'unlimited');\n\n/** Tiers that permit the org → team hierarchy (nesting teams under a root). The\n *  billing-off `unlimited` tier is team-capable (it's the most permissive); the\n *  entry-level `developer`/`pro` tiers are not. Single source for the parent-\n *  eligibility + downgrade-overcap checks so they can't drift. */\nexport const TEAM_CAPABLE_TIERS: readonly QuotaTier[] = ['team', 'business', 'enterprise', 'unlimited'];\nexport function tierAllowsTeams(tier: string | undefined | null): boolean {\n  return !!tier && (TEAM_CAPABLE_TIERS as readonly string[]).includes(tier);\n}\n\n/** Tiers that may buy extra seats — billing's per-seat `seat` add-on. Seats are\n *  the Team differentiator, so the single-seat `developer`/`pro` tiers cannot\n *  stack them and must upgrade instead; `unlimited` has no seat cap at all.\n *  Single source for the billing catalog and every \"out of seats\" message. */\nexport const SEAT_PACK_TIERS: readonly QuotaTier[] = ['team', 'business', 'enterprise'];\n\n/** How an account that has used every seat can get another. */\nexport type SeatRemedy = 'upgrade' | 'seat_pack';\n\n/**\n * The remedy to offer an account at its seat cap, from the ACCOUNT's (root) tier:\n * `seat_pack` where seats can be bought, `upgrade` on the single-seat tiers.\n * `null` when the tier is unknown or has no cap — say nothing rather than guess.\n */\nexport function seatRemedy(tier: string | undefined | null): SeatRemedy | null {\n  if (!tier || !isValidTier(tier) || tier === 'unlimited') return null;\n  return (SEAT_PACK_TIERS as readonly string[]).includes(tier) ? 'seat_pack' : 'upgrade';\n}\n\n/** Whether the billing service is enabled in this deployment (`BILLING_ENABLED`,\n *  opt-out default-on — mirrors the billing/platform configs). With billing OFF\n *  there's no metering/enforcement surface, so the default tier is `unlimited`. */\nexport function isBillingEnabled(): boolean {\n  return envBool('BILLING_ENABLED', true);\n}\n\n/**\n * Default tier assigned to new organizations.\n * - Billing DISABLED → `unlimited` (nothing is metered, so everything is uncapped).\n * - Billing ENABLED  → `DEFAULT_QUOTA_TIER` if it's a valid standard tier, else `developer`.\n */\nexport const DEFAULT_TIER: QuotaTier = !isBillingEnabled()\n  ? 'unlimited'\n  : (isValidTier(process.env.DEFAULT_QUOTA_TIER ?? '') && process.env.DEFAULT_QUOTA_TIER !== 'unlimited'\n    ? (process.env.DEFAULT_QUOTA_TIER as QuotaTier)\n    : 'developer');\n\n/** Check whether a string is a valid QuotaTier. */\nexport function isValidTier(value: string): value is QuotaTier {\n  // Use the explicit tuple, not `value in QUOTA_TIERS`: `in` walks the prototype\n  // chain, so inherited Object keys ('toString', 'constructor', …) would return\n  // true and then `getTierLimits` would read `.limits` off a function → crash.\n  // `tier` is attacker-influenceable (JWT / request body / DEFAULT_QUOTA_TIER env).\n  return (VALID_TIERS as readonly string[]).includes(value);\n}\n\n/** Get the default limits for a given tier (falls back to developer). */\nexport function getTierLimits(tier: string): QuotaTierLimits {\n  return isValidTier(tier) ? QUOTA_TIERS[tier].limits: QUOTA_TIERS.developer.limits;\n}\n\n/**\n * The period (days) every usage counter rolls over on. All quotas are per-period\n * FLOW counters on one shared period: the quota service resets a counter this\n * many days after it expires, and platform seeds a new org's counters with the\n * same window (`QUOTA_RESET_DAYS`, default 3).\n */\nexport const QUOTA_RESET_DAYS = envInt('QUOTA_RESET_DAYS', 3, { min: 1 });\n\n/** The next quota reset: local midnight `days` from `now`. */\nexport function nextQuotaResetDate(days: number = QUOTA_RESET_DAYS, now: Date = new Date()): Date {\n  const date = new Date(now);\n  date.setDate(date.getDate() + days);\n  date.setHours(0, 0, 0, 0);\n  return date;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quota-tiers.js","sourceRoot":"","sources":["../../src/types/quota-tiers.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { envBool, envInt, envStr } from '../utils/env.js';\nimport type { QuotaType } from './common.js';\n\n/** Available quota tier identifiers.\n *\n * `unlimited` is a special tier: every quota is `-1` (uncapped) and it includes\n * every feature/add-on bundle. It is the DEFAULT when billing is disabled (no\n * metering/enforcement surface exists, so nothing is capped), and it is NEVER\n * shown or selectable when billing is enabled — see `STANDARD_TIERS`. */\nexport type QuotaTier = 'developer' | 'pro' | 'team' | 'business' | 'enterprise' | 'unlimited';\n\n/** Limit values for each quota type within a tier. */\nexport interface QuotaTierLimits {\n  plugins: number;\n  pipelines: number;\n  apiCalls: number;\n  /**\n   * Metered API calls made by ORG SERVICE ACCOUNTS (automation), counted\n   * instead of `apiCalls` so pipelines can't starve the org's people. See\n   * {@link AUTOMATION_CALLS_SIZING} for how the defaults are derived.\n   */\n  automationCalls: number;\n  aiCalls: number;\n  /**\n   * Aggregate registry storage cap in BYTES. Counted across every repo\n   * under the org's `org-{orgId}/` namespace. -1 means unlimited.\n   * push-gate reads this; the image-registry rejects token issuance for\n   * `push` scope when the org's measured usage exceeds the limit.\n   */\n  storageBytes: number;\n  /**\n   * vCPU-MINUTES of plugin-build compute per MONTH — the one quota on a period\n   * of its own (every other flow quota rolls on `QUOTA_RESET_DAYS`, 3 days).\n   *\n   * Derived from the `plugins` cap rather than guessed: `plugins x 10` builds a\n   * month, at a flat 30 wall-minutes a build and 1.5 vCPU of buildkitd, so\n   * `credits = builds x 45`. The flat per-build figure is deliberate — scaling\n   * BOTH the build count and the per-build cost by tier made credits\n   * superlinear in tier on the strength of an unmeasured claim, and it made a\n   * pack's credit grant tier-dependent, which the catalogue's grant shape cannot\n   * express.\n   *\n   * This is the first dimension with genuine per-unit marginal cost: every other\n   * quota is a rate limit protecting shared infrastructure, this one is compute\n   * the platform pays for. See `docs/plans/cpu-credits.md`.\n   */\n  cpuCredits: number;\n  /** Count-quotas on the user-editable feature tables added to close per-org\n   *  DoS via spam. -1 means unlimited. */\n  dashboards: number;\n  alertRules: number;\n  alertDestinations: number;\n  idpConfigs: number;\n  /**\n   * Active, non-suspended plugin-ecosystem listings the org publishes\n   * (docs/plugin-installing.md). A COUNT quota — installs never\n   * count. -1 = unlimited. Extendable via the `listing_pack` add-on bundle.\n   */\n  listings: number;\n  /**\n   * Max org members (active users / seats). -1 = unlimited. This is the \"Team\"\n   * tier differentiator — enforced at member-invite time (an invite is blocked\n   * when active members + pending invites would exceed this).\n   */\n  seats: number;\n  /**\n   * Max designated SUPPORT CONTACTS — the members authorised to open support\n   * cases. -1 = unlimited. Base is **0 on every tier**: support is an add-on at\n   * every tier and included in none, so an org with no support bundle has no\n   * contacts and cannot open a case. That makes the support paywall a quota\n   * check rather than a feature flag.\n   *\n   * Like `seats` this is a tier LIMIT, not a tracked counter — enforced live at\n   * designation time against current designations across the org subtree.\n   * Extended per unit by the `support_standard` / `support_priority` BASELINE\n   * bundles, which are priced per contact.\n   */\n  supportContacts: number;\n  /**\n   * How many of those contacts may be UPGRADED to premium (24×7, 8-hour\n   * response, and the only ones who may declare `urgent`).\n   *\n   * A second dimension rather than a third baseline level, because premium is an\n   * UPGRADE and not an alternative. The shape it encodes: an org buys N baseline\n   * contacts and upgrades M of them, M ≤ N. That is what lets a 100-seat\n   * customer give business-hours support to its three named contacts and 24×7\n   * to the one who carries the pager — the case the mutually-exclusive ladder\n   * could not express at all, where buying \"99 standard + 1 premium\" charged for\n   * 100 units and granted one contact.\n   *\n   * ADDITIVE, deliberately. A premium contact costs the baseline unit PLUS the\n   * upgrade ($19.99 + $99.99), because it is served during business hours\n   * through the baseline and overnight through the upgrade; pricing the upgrade\n   * as a delta would pretend the baseline were free. Base 0 on every tier, like\n   * `supportContacts`, so the paywall stays a quota check.\n   */\n  supportPremiumContacts: number;\n  /**\n   * Reporting retention in DAYS — NOT a flow quota (never decremented, absent\n   * from `VALID_QUOTA_TYPES`): these ride the tier-baseline + bundle-grant math\n   * purely as an entitlement the billing service syncs to reporting's\n   * `dora_settings`. -1 = unlimited (the sweep skips the org entirely).\n   *   `eventRetentionDays` — non-deploy `pipeline_events` (STAGE/ACTION/build).\n   *   `doraRetentionDays`  — deploy events + `deployment_outcomes` + `incidents`,\n   *                          and the per-org report-query window for DORA routes.\n   * Extendable via the `retention_pack` / `dora_history_pack` add-on bundles.\n   */\n  eventRetentionDays: number;\n  doraRetentionDays: number;\n}\n\n/** Full preset for a single tier (label + limits). */\nexport interface QuotaTierPreset {\n  label: string;\n  limits: QuotaTierLimits;\n}\n\n/**\n * Preset limits for each tier. -1 means unlimited.\n *\n * AI calls are sized much smaller than `apiCalls` because each call has\n * external provider cost (~$0.01$0.10/call). Developer tier allows light\n * exploration (50/period); Pro lifts to 2,500; Enterprise is capped high\n * (25,000) — fair-use, not literally unlimited.\n *\n * `storageBytes` is the aggregate registry cap per org. Sized\n * around plugin-image realities: a typical plugin image is 200500 MB;\n * Developer's 2 GB holds ~4 versions × ~500 MB, Pro's 25 GB covers a\n * mature catalog. Operators can override per-org via the quota CRUD API.\n */\nconst GB = 1024 * 1024 * 1024;\n\n/**\n * How the `automationCalls` defaults are sized — written down so the next\n * person to touch them argues with the arithmetic, not with the numbers.\n *\n * Every call an org's automation keys make in one pipeline RUN, itemized (the\n * earlier sizing counted only the plugin lookups and hand-waved the rest as\n * \"×2\"):\n *\n *   plugin lookups            12   one per plugin step (self-mutating pipeline)\n *   synth                      1   the synth step fetching the pipeline config\n *   runtime check              1   the pre-deploy runtime-check call\n *   security-report upload     1   the scan step posting its report\n *   registry register          1   pipeline-register stamping the deployed version\n *   reporting ingest batches  12   the event forwarder posts ~one batch per action\n *                             --\n *                             28   calls per run\n *\n * Per default period (`QUOTA_RESET_DAYS`, 3 days) one active pipeline running\n * hourly makes 28 × 24 × 3 = 2,016 calls. An org keeps far more pipelines alive\n * than it CREATES in a period (`pipelines` is a creation rate), so active\n * pipelines are taken as 4× the tier's `pipelines`. On top sits a per-ORG\n * constant that does not scale with pipelines: the ingest-health heartbeat\n * (≤ 1/minute → 1,440/day → 4,320/period). The sum gets 25% headroom (retries,\n * registry pushes, ad-hoc CI scripts on keys) and rounds UP to the next 10,000:\n *\n *   developer   2×4×2016 + 4320 =  20,448 × 1.25 =  25,560 →  30,000\n *   pro         5×4×2016 + 4320 =  44,640 × 1.25 =  55,800 →  60,000\n *   team       10×4×2016 + 4320 =  84,960 × 1.25 = 106,200 → 110,000\n *   business   20×4×2016 + 4320 = 165,600 × 1.25 = 207,000 → 210,000\n *   enterprise 30×4×2016 + 4320 = 246,240 × 1.25 = 307,800 → 310,000\n *\n * {@link automationCallsFor} computes exactly this, and the tier tests hold the\n * table to it. Over the cap the 429 is SOFT for a band ({@link quotaGracePct}):\n * a self-mutating pipeline that hard-stopped at 100% stayed stopped until the\n * period reset, up to 3 days. The limits are PER PERIOD: an operator who\n * lengthens `QUOTA_RESET_DAYS` should scale `QUOTA_TIER_<TIER>_AUTOMATION_CALLS`\n * by the same factor.\n */\nexport const AUTOMATION_CALLS_SIZING = {\n  callsPerRun: {\n    pluginLookups: 12,\n    synth: 1,\n    runtimeCheck: 1,\n    securityReportUpload: 1,\n    registryRegister: 1,\n    ingestBatches: 12,\n  },\n  runsPerDay: 24,\n  activePipelinesPerCreation: 4,\n  /** Ingest-health heartbeats per org per day (≤ one a minute). */\n  heartbeatsPerDay: 1440,\n  /** Multiplier on the itemized total. */\n  headroom: 1.25,\n  /** Defaults round UP to a multiple of this. */\n  roundTo: 10_000,\n} as const;\n\n/** The {@link AUTOMATION_CALLS_SIZING} formula for a tier creating `pipelines` per period. */\nexport function automationCallsFor(pipelines: number, periodDays: number = 3): number {\n  const s = AUTOMATION_CALLS_SIZING;\n  const perRun = Object.values(s.callsPerRun).reduce((a, b) => a + b, 0);\n  const perPipeline = perRun * s.runsPerDay * periodDays;\n  const total = (pipelines * s.activePipelinesPerCreation * perPipeline + s.heartbeatsPerDay * periodDays) * s.headroom;\n  return Math.ceil(total / s.roundTo) * s.roundTo;\n}\n\n/**\n * The SOFT band above a quota's cap, per type, in percent of the limit. A type\n * absent from this map has NO band and stops hard at 100%.\n *\n * At 100% the account gets the \"reached\" notice and keeps running; the refusal\n * starts only past `limit × (100 + pct) / 100`. Reads still REPORT the nominal\n * limit, so usage shows above 100% while inside the band.\n *\n * Two types qualify, for the same reason stated two ways — a hard stop exactly\n * at 100% is worse than a short overrun when the caller cannot simply wait:\n *\n * - `automationCalls` (`QUOTA_AUTOMATION_GRACE_PCT`): the caller is a pipeline\n *   mid-deploy, not a person, and the counter would stay full for the rest of\n *   the period.\n * - `storageBytes` (`QUOTA_STORAGE_GRACE_PCT`): storage is a STOCK — it does\n *   not reset, so without a band a downgrade or a cancelled pack flips an\n *   account from working to refused with no buffer at all, and the remedy\n *   (prune, or buy capacity) takes time the band is there to provide. Note the\n *   band on a stock is a ONE-TIME buffer rather than a per-period one; that is\n *   its purpose here, not a limitation of it.\n *\n * Every other type stays hard. This was a hardcoded `quotaType !==\n * 'automationCalls'` comparison, which is why storage had nothing: the\n * mechanism existed and only the predicate excluded it.\n */\nconst QUOTA_GRACE_PCT: Readonly<Record<string, number>> = {\n  automationCalls: envInt('QUOTA_AUTOMATION_GRACE_PCT', 10, { min: 0, max: 100 }),\n  storageBytes: envInt('QUOTA_STORAGE_GRACE_PCT', 10, { min: 0, max: 100 }),\n};\n\n/** The soft band for `quotaType` in percent, or 0 for a type that stops hard. */\nexport function quotaGracePct(quotaType: string): number {\n  return QUOTA_GRACE_PCT[quotaType] ?? 0;\n}\n\n/**\n * The limit enforcement actually binds on for `quotaType`: the nominal limit,\n * plus the type's {@link quotaGracePct} band where it has one. Unlimited (-1)\n * and zero (\"none\") limits are returned unchanged — a 0 cap is a deliberate\n * refusal, not a budget to overrun.\n *\n * {@link QUOTA_GRACE_PCT} decides WHETHER a type has a band; `gracePct` only\n * sizes it. So an explicit percentage passed for an unbanded type still yields\n * the nominal limit, rather than quietly granting a band the type is not meant\n * to have.\n */\nexport function enforcedQuotaLimit(quotaType: string, limit: number, gracePct: number = quotaGracePct(quotaType)): number {\n  if (limit <= 0 || gracePct <= 0 || quotaGracePct(quotaType) <= 0) return limit;\n  return Math.floor((limit * (100 + gracePct)) / 100);\n}\n\n/**\n * Code-default limits per tier — the fallback when no env override is set.\n * -1 means unlimited. (Counts sized to \"comfortably enough for one team, not\n * script spam\": 20 dashboards, 50 alert rules, 10 destinations, 1 IdP config\n * for Developer; scaled up for Pro; -1 (uncapped) for the cheap count-quotas\n * on Team/Enterprise while cost-driving quotas — incl. apiCalls — stay finite.)\n */\nconst DEFAULT_TIER_LIMITS: Record<QuotaTier, QuotaTierLimits> = {\n  // Free tier: single seat, 2 pipelines, apiCalls CAPPED (was unlimited — a\n  // DoS/abuse hole on a shared resource); aiCalls small (each has ~$0.01-0.10\n  // external cost). Lean base — growth happens by upgrading, not stacking here.\n  developer: {\n    plugins: 10,\n    pipelines: 2,\n    apiCalls: 25_000,\n    automationCalls: 30_000,\n    aiCalls: 20,\n    cpuCredits: 4_500,\n    storageBytes: 2 * GB,\n    dashboards: 20,\n    alertRules: 50,\n    alertDestinations: 10,\n    idpConfigs: 1,\n    listings: 3,\n    seats: 1,\n    supportContacts: 0,\n    supportPremiumContacts: 0,\n    eventRetentionDays: 30,\n    doraRetentionDays: 180,\n  },\n  // Pro = individual power user, single seat, individual pricing. A 2nd seat (or\n  // team collaboration) requires the Team tier — the `seat` add-on is Team+ only,\n  // keeping Team the collaboration tier. Pro's value over Developer is its richer\n  // call/storage/plugin ceilings + feature add-ons (SSO/audit/DORA), not seats.\n  pro: {\n    plugins: 25,\n    pipelines: 5,\n    apiCalls: 100_000,\n    automationCalls: 60_000,\n    aiCalls: 200,\n    cpuCredits: 11_250,\n    storageBytes: 25 * GB,\n    dashboards: 200,\n    alertRules: 500,\n    alertDestinations: 50,\n    idpConfigs: 5,\n    listings: 10,\n    seats: 1,\n    supportContacts: 0,\n    supportPremiumContacts: 0,\n    eventRetentionDays: 30,\n    doraRetentionDays: 180,\n  },\n  // Team = collaboration tier; the seat limit (3) is the real differentiator over\n  // Pro (single-seat) — it's the multi-seat collaboration floor. Lean base ($79):\n  // growth rides the seat/pipeline/etc add-ons (land-and-expand). Limits sit\n  // between Pro and Enterprise.\n  team: {\n    plugins: 50,\n    pipelines: 10,\n    apiCalls: 300_000,\n    automationCalls: 110_000,\n    aiCalls: 600,\n    cpuCredits: 22_500,\n    storageBytes: 60 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: 5,\n    listings: 25,\n    seats: 3,\n    supportContacts: 0,\n    supportPremiumContacts: 0,\n    eventRetentionDays: 30,\n    doraRetentionDays: 180,\n  },\n  // Business ($249): the step the $79 -> $599 cliff was missing. 8 seats, 20\n  // pipelines, and DORA (advanced_reporting) included rather than an add-on.\n  // Every cost driver is 100,000 apiCalls and 200 aiCalls PER SEAT, the same\n  // per-seat rate as Pro/Team/Enterprise, so the ladder reads consistently to a\n  // buyer who divides by headcount. Count-quotas that Team already uncaps stay\n  // -1; `idpConfigs` sits between Team's 5 and Enterprise's unlimited.\n  business: {\n    plugins: 100,\n    pipelines: 20,\n    apiCalls: 800_000,\n    automationCalls: 210_000,\n    aiCalls: 1_600,\n    cpuCredits: 45_000,\n    storageBytes: 120 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: 10,\n    listings: 50,\n    seats: 8,\n    supportContacts: 0,\n    supportPremiumContacts: 0,\n    eventRetentionDays: 30,\n    doraRetentionDays: 180,\n  },\n  // Enterprise ($599, held): the all-inclusive tier — 15 seats, 30 pipelines, ALL\n  // premium features included (see TIER_FEATURES). FAIR-USE — cost drivers (apiCalls,\n  // aiCalls, storageBytes) capped so one account can't run up unbounded\n  // compute/provider/storage cost on a flat price; cheap count-quotas stay -1.\n  enterprise: {\n    plugins: 150,\n    pipelines: 30,\n    apiCalls: 1_500_000,\n    automationCalls: 310_000,\n    aiCalls: 3_000,\n    cpuCredits: 67_500,\n    storageBytes: 250 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: -1,\n    listings: 100,\n    seats: 15,\n    supportContacts: 0,\n    supportPremiumContacts: 0,\n    eventRetentionDays: 30,\n    doraRetentionDays: 180,\n  },\n  // Unlimited: EVERY quota uncapped (-1). The default when billing is disabled\n  // (no enforcement surface) — never shown/selectable when billing is enabled.\n  unlimited: {\n    plugins: -1,\n    pipelines: -1,\n    apiCalls: -1,\n    automationCalls: -1,\n    aiCalls: -1,\n    cpuCredits: -1,\n    storageBytes: -1,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: -1,\n    listings: -1,\n    seats: -1,\n    supportContacts: -1,\n    supportPremiumContacts: -1,\n    eventRetentionDays: -1,\n    doraRetentionDays: -1,\n  },\n};\n\n/**\n * Read a tier LIMIT env var. `-1` = unlimited; anything below that is nonsense\n * (a `-5` limit would ship a broken finite cap), so it falls back to the code\n * default rather than clamping up to `-1`. The parsing itself is api-core's\n * shared `envInt` — strict about decimals/garbage — not a local re-derivation.\n */\nfunction tierLimitEnv(name: string, fallback: number): number {\n  const n = envInt(name, fallback);\n  return n < -1 ? fallback : n;\n}\n\n/**\n * Per-tier limits, each overridable via `QUOTA_TIER_<TIER>_<LIMIT>` env vars\n * (e.g. `QUOTA_TIER_PRO_PIPELINES=250`, `QUOTA_TIER_DEVELOPER_STORAGE_BYTES=...`).\n * Unset/empty → the code default. `-1` = unlimited. Read once at module load —\n * on k8s these flow in via the `app-env` ConfigMap (built from `.env`).\n */\nfunction tierLimits(tier: QuotaTier): QuotaTierLimits {\n  // `unlimited` is uncapped BY DEFINITION: EVERY quota is -1 and it is NOT\n  // env-overridable. Reading QUOTA_TIER_UNLIMITED_* here would let a stray env\n  // var silently cap the billing-DISABLED default tier — surfacing as a spurious\n  // \"quota exceeded\" on a deploy that meters nothing. Derive -1 for every field\n  // from the limits shape so a newly-added quota is uncapped here automatically.\n  if (tier === 'unlimited') {\n    const uncapped = { ...DEFAULT_TIER_LIMITS.unlimited };\n    for (const k of Object.keys(uncapped) as (keyof QuotaTierLimits)[]) uncapped[k] = -1;\n    return uncapped;\n  }\n  const d = DEFAULT_TIER_LIMITS[tier];\n  const T = tier.toUpperCase();\n  return {\n    plugins: tierLimitEnv(`QUOTA_TIER_${T}_PLUGINS`, d.plugins),\n    pipelines: tierLimitEnv(`QUOTA_TIER_${T}_PIPELINES`, d.pipelines),\n    apiCalls: tierLimitEnv(`QUOTA_TIER_${T}_API_CALLS`, d.apiCalls),\n    automationCalls: tierLimitEnv(`QUOTA_TIER_${T}_AUTOMATION_CALLS`, d.automationCalls),\n    aiCalls: tierLimitEnv(`QUOTA_TIER_${T}_AI_CALLS`, d.aiCalls),\n    storageBytes: tierLimitEnv(`QUOTA_TIER_${T}_STORAGE_BYTES`, d.storageBytes),\n    cpuCredits: tierLimitEnv(`QUOTA_TIER_${T}_CPU_CREDITS`, d.cpuCredits),\n    dashboards: tierLimitEnv(`QUOTA_TIER_${T}_DASHBOARDS`, d.dashboards),\n    alertRules: tierLimitEnv(`QUOTA_TIER_${T}_ALERT_RULES`, d.alertRules),\n    alertDestinations: tierLimitEnv(`QUOTA_TIER_${T}_ALERT_DESTINATIONS`, d.alertDestinations),\n    idpConfigs: tierLimitEnv(`QUOTA_TIER_${T}_IDP_CONFIGS`, d.idpConfigs),\n    listings: tierLimitEnv(`QUOTA_TIER_${T}_LISTINGS`, d.listings),\n    seats: tierLimitEnv(`QUOTA_TIER_${T}_SEATS`, d.seats),\n    supportContacts: tierLimitEnv(`QUOTA_TIER_${T}_SUPPORT_CONTACTS`, d.supportContacts),\n    supportPremiumContacts: tierLimitEnv(`QUOTA_TIER_${T}_SUPPORT_PREMIUM_CONTACTS`, d.supportPremiumContacts),\n    eventRetentionDays: tierLimitEnv(`QUOTA_TIER_${T}_EVENT_RETENTION_DAYS`, d.eventRetentionDays),\n    doraRetentionDays: tierLimitEnv(`QUOTA_TIER_${T}_DORA_RETENTION_DAYS`, d.doraRetentionDays),\n  };\n}\n\n// Labels are overridable via `QUOTA_TIER_<TIER>_LABEL` (display name only).\nexport const QUOTA_TIERS: Record<QuotaTier, QuotaTierPreset> = {\n  developer: { label: envStr('QUOTA_TIER_DEVELOPER_LABEL', 'Developer'), limits: tierLimits('developer') },\n  pro: { label: envStr('QUOTA_TIER_PRO_LABEL', 'Pro'), limits: tierLimits('pro') },\n  team: { label: envStr('QUOTA_TIER_TEAM_LABEL', 'Team'), limits: tierLimits('team') },\n  business: { label: envStr('QUOTA_TIER_BUSINESS_LABEL', 'Business'), limits: tierLimits('business') },\n  enterprise: { label: envStr('QUOTA_TIER_ENTERPRISE_LABEL', 'Enterprise'), limits: tierLimits('enterprise') },\n  unlimited: { label: envStr('QUOTA_TIER_UNLIMITED_LABEL', 'Unlimited'), limits: tierLimits('unlimited') },\n};\n\n/** All valid tier names (incl. `unlimited`). Used for validation of a *stored*\n *  tier — `unlimited` is a valid value even though it's never offered for sale. */\nexport const VALID_TIERS: readonly QuotaTier[] = Object.keys(QUOTA_TIERS) as QuotaTier[];\n\n/** The standard, billing-selectable tiers — the ones offered as purchasable plans\n *  and shown in tier pickers. Derived as \"every valid tier except `unlimited`\",\n *  which is the billing-DISABLED default and is never displayed/selectable when\n *  billing is enabled. Kept DRY off `VALID_TIERS` so adding a tier flows through. */\nexport const STANDARD_TIERS: readonly QuotaTier[] = VALID_TIERS.filter((t) => t !== 'unlimited');\n\n/** Tiers that permit the org → team hierarchy (nesting teams under a root). The\n *  billing-off `unlimited` tier is team-capable (it's the most permissive); the\n *  entry-level `developer`/`pro` tiers are not. Single source for the parent-\n *  eligibility + downgrade-overcap checks so they can't drift. */\nexport const TEAM_CAPABLE_TIERS: readonly QuotaTier[] = ['team', 'business', 'enterprise', 'unlimited'];\nexport function tierAllowsTeams(tier: string | undefined | null): boolean {\n  return !!tier && (TEAM_CAPABLE_TIERS as readonly string[]).includes(tier);\n}\n\n/** Tiers that may buy extra seats — billing's per-seat `seat` add-on. Seats are\n *  the Team differentiator, so the single-seat `developer`/`pro` tiers cannot\n *  stack them and must upgrade instead; `unlimited` has no seat cap at all.\n *  Single source for the billing catalog and every \"out of seats\" message. */\nexport const SEAT_PACK_TIERS: readonly QuotaTier[] = ['team', 'business', 'enterprise'];\n\n/** How an account that has used every seat can get another. */\nexport type SeatRemedy = 'upgrade' | 'seat_pack';\n\n/**\n * The remedy to offer an account at its seat cap, from the ACCOUNT's (root) tier:\n * `seat_pack` where seats can be bought, `upgrade` on the single-seat tiers.\n * `null` when the tier is unknown or has no cap — say nothing rather than guess.\n */\nexport function seatRemedy(tier: string | undefined | null): SeatRemedy | null {\n  if (!tier || !isValidTier(tier) || tier === 'unlimited') return null;\n  return (SEAT_PACK_TIERS as readonly string[]).includes(tier) ? 'seat_pack' : 'upgrade';\n}\n\n/** Whether the billing service is enabled in this deployment (`BILLING_ENABLED`,\n *  opt-out default-on — mirrors the billing/platform configs). With billing OFF\n *  there's no metering/enforcement surface, so the default tier is `unlimited`. */\nexport function isBillingEnabled(): boolean {\n  return envBool('BILLING_ENABLED', true);\n}\n\n/**\n * Default tier assigned to new organizations.\n * - Billing DISABLED → `unlimited` (nothing is metered, so everything is uncapped).\n * - Billing ENABLED  → `DEFAULT_QUOTA_TIER` if it's a valid standard tier, else `developer`.\n */\nexport const DEFAULT_TIER: QuotaTier = !isBillingEnabled()\n  ? 'unlimited'\n  : (isValidTier(process.env.DEFAULT_QUOTA_TIER ?? '') && process.env.DEFAULT_QUOTA_TIER !== 'unlimited'\n    ? (process.env.DEFAULT_QUOTA_TIER as QuotaTier)\n    : 'developer');\n\n/** Check whether a string is a valid QuotaTier. */\nexport function isValidTier(value: string): value is QuotaTier {\n  // Use the explicit tuple, not `value in QUOTA_TIERS`: `in` walks the prototype\n  // chain, so inherited Object keys ('toString', 'constructor', …) would return\n  // true and then `getTierLimits` would read `.limits` off a function → crash.\n  // `tier` is attacker-influenceable (JWT / request body / DEFAULT_QUOTA_TIER env).\n  return (VALID_TIERS as readonly string[]).includes(value);\n}\n\n/** Get the default limits for a given tier (falls back to developer). */\nexport function getTierLimits(tier: string): QuotaTierLimits {\n  return isValidTier(tier) ? QUOTA_TIERS[tier].limits: QUOTA_TIERS.developer.limits;\n}\n\n/**\n * The period (days) every usage counter rolls over on. All quotas are per-period\n * FLOW counters on one shared period: the quota service resets a counter this\n * many days after it expires, and platform seeds a new org's counters with the\n * same window (`QUOTA_RESET_DAYS`, default 3).\n */\nexport const QUOTA_RESET_DAYS = envInt('QUOTA_RESET_DAYS', 3, { min: 1 });\n\n/** The next quota reset: local midnight `days` from `now`. */\n/**\n * The `cpuCredits` period, in days. A MONTH rather than the global three-day\n * window, because build demand is bursty in a way API traffic is not: a full\n * catalogue rebuild is a day's work that arrives on one day, and a three-day\n * window refuses it while the account holds most of a month's budget unspent.\n */\nexport const CPU_CREDITS_PERIOD_DAYS = envInt('QUOTA_CPU_CREDITS_PERIOD_DAYS', 30, { min: 1 });\n\n/**\n * The usage period for ONE quota type, in days.\n *\n * Every flow quota but `cpuCredits` rolls on the global {@link QUOTA_RESET_DAYS}.\n * Credits are monthly, which makes the period a PER-TYPE fact — so anything that\n * computes a reset date, a \"resets in N days\" line or a burn-rate forecast has\n * to ask for the type's own period rather than reading the global constant. A\n * forecast against the wrong window is wrong by a factor of ten.\n *\n * Stocks (`storageBytes` and the resource counts) have no period at all; this\n * returns the global window for them because callers gate on\n * `quotaAccrual(type) === 'stock'` before using it, and returning a figure is\n * less disruptive than making every caller handle a null. Check the accrual.\n */\nexport function quotaPeriodDays(type: QuotaType): number {\n  return type === 'cpuCredits' ? CPU_CREDITS_PERIOD_DAYS : QUOTA_RESET_DAYS;\n}\n\nexport function nextQuotaResetDate(days: number = QUOTA_RESET_DAYS, now: Date = new Date()): Date {\n  const date = new Date(now);\n  date.setDate(date.getDate() + days);\n  date.setHours(0, 0, 0, 0);\n  return date;\n}\n"]}

package/lib/types/remote-audit-actions.d.ts

@@ -17,7 +17,7 @@
  * (`admin.superadmin.grant`, `org.ownership.transfer`, `user.login`, …). Keep
  * this list free of any platform-only action.
  */
-export declare const REMOTE_AUDIT_ACTIONS: readonly ['plugin.build.completed', 'plugin.build.failed', 'plugin.build.timeout', 'plugin.scan.skipped', 'plugin.vuln.waived', 'plugin.delete', 'plugin.restore', 'plugin.purge', 'plugin.update', 'plugin.upload', 'plugin.deploy', 'plugin.bulk.update', 'plugin.bulk.delete', 'plugin.dlq.purge', 'plugin.build.retry', 'plugin.dlq.replay', 'pipeline.create', 'pipeline.update', 'pipeline.delete', 'pipeline.restore', 'pipeline.purge', 'pipeline_template.create', 'pipeline_template.update', 'pipeline_template.delete', 'pipeline_template.restore', 'pipeline_template.purge', 'pipeline.execution.start', 'pipeline.execution.cancel', 'pipeline.registry.register', 'pipeline.registry.deregister', 'quota.reset', 'quota.limit.update', 'quota.delete', 'compliance.exemption.approve', 'compliance.exemption.revoke', 'compliance.rule.toggle', 'compliance.rule.create', 'compliance.rule.update', 'compliance.rule.delete', 'compliance.rule.restore', 'compliance.rule.purge', 'compliance.policy.create', 'compliance.policy.update', 'compliance.policy.delete', 'compliance.policy.restore', 'compliance.policy.purge', 'compliance.scan-schedule.create', 'compliance.scan-schedule.update', 'compliance.scan-schedule.delete', 'compliance.template.apply', 'compliance.scan.create', 'compliance.scan.cancel', 'compliance.notification-preference.update', 'registry.gc', 'registry.image.delete', 'registry.image.copy', 'registry.image.sign', 'message.announcement.create', 'message.delete', 'message.restore', 'message.purge', 'billing.subscription.create', 'billing.subscription.update', 'billing.subscription.reactivate', 'billing.subscription.cancel', 'billing.subscription.delete', 'billing.tier.override', 'billing.addon.add', 'billing.addon.remove', 'billing.addon.prune', 'billing.discount.generate', 'billing.discount.issue', 'billing.discount.apply', 'billing.discount.remove', 'billing.discount.revoke', 'billing.promotion.create', 'billing.promotion.update', 'billing.promotion.revoke', 'billing.promotion.grant', 'billing.promotion.activate', 'billing.credit.consumed', 'billing.credit.exhausted', 'billing.combo.expired', 'reporting.settings.update', 'reporting.deployment.outcome', 'reporting.retention.sync', 'reporting.report.definition.create', 'reporting.report.definition.update', 'reporting.report.definition.delete', 'reporting.report.ownership.transfer', 'reporting.report.published', 'reporting.report.republished', 'reporting.report.link.created', 'reporting.report.link.revoked', 'reporting.report.recipient.added', 'reporting.report.recipient.removed', 'reporting.report.policy.update', 'reporting.report.paused', 'reporting.report.resumed', 'authz.denied', 'ask.query', 'ask.agent.turn', 'ask.feedback', 'publisher.create', 'publisher.update', 'publisher.terms.accept', 'publisher.verify.request', 'publisher.verify.approve', 'publisher.verify.reject', 'publisher.tier.change', 'publisher.suspend', 'publisher.unsuspend', 'publisher.transfer.request', 'publisher.transfer.accept', 'publisher.transfer.decline', 'publisher.transfer.approve', 'publisher.transfer.reject', 'publisher.profile-change.approve', 'publisher.profile-change.reject', 'plugin.request.submit', 'plugin.request.withdraw', 'plugin.request.approve', 'plugin.request.second-approve', 'plugin.request.reject', 'plugin.request.auto-approve', 'plugin.listing.publish', 'plugin.listing.unlist', 'plugin.listing.update', 'plugin.listing.state.change', 'plugin.listing.pause', 'plugin.listing.unpause', 'plugin.version.pause', 'plugin.version.yank', 'plugin.version.unyank', 'plugin.version.deprecate', 'plugin.collection.update', 'ecosystem.auto-approval-rule.create', 'ecosystem.auto-approval-rule.update', 'ecosystem.auto-approval-rule.delete', 'ecosystem.reserved-name.update', 'ecosystem.sla.update', 'registry.image.publish', 'registry.image.resign', 'registry.image.yank', 'registry.image.gc', 'plugin.install.request', 'plugin.install.approve', 'plugin.install.deny', 'plugin.install.create', 'plugin.install.upgrade', 'plugin.install.change-request', 'plugin.install.change-approve', 'plugin.install.change-reject', 'plugin.install.remove', 'org.plugin-install-policy.update', 'plugin.shadowing.denied', 'plugin.review.create', 'plugin.review.update', 'plugin.review.delete', 'plugin.review.report', 'plugin.review.hold', 'plugin.review.release', 'plugin.review.remove', 'plugin.review.anonymize', 'plugin.review.reply.create', 'plugin.review.reply.update', 'plugin.review.reply.delete', 'plugin.submission.create', 'plugin.submission.verify', 'plugin.submission.gate-fail', 'plugin.submission.approve', 'plugin.submission.reject', 'plugin.submission.claim', 'plugin.submission.expire', 'plugin.advisory.create', 'plugin.advisory.update', 'plugin.advisory.publish', 'plugin.advisory.withdraw', 'plugin.security_notifications.update', 'plugin.security_notifications.external_email.verify', 'plugin.security_notifications.test'];
+export declare const REMOTE_AUDIT_ACTIONS: readonly ['plugin.build.completed', 'plugin.build.failed', 'plugin.build.timeout', 'plugin.scan.skipped', 'plugin.vuln.waived', 'plugin.vuln.flagged', 'plugin.vuln.cleared', 'plugin.delete', 'plugin.restore', 'plugin.purge', 'plugin.update', 'plugin.upload', 'plugin.deploy', 'plugin.bulk.update', 'plugin.bulk.delete', 'plugin.dlq.purge', 'plugin.build.retry', 'plugin.dlq.replay', 'pipeline.create', 'pipeline.update', 'pipeline.delete', 'pipeline.restore', 'pipeline.purge', 'pipeline_template.create', 'pipeline_template.update', 'pipeline_template.delete', 'pipeline_template.restore', 'pipeline_template.purge', 'pipeline.execution.start', 'pipeline.execution.cancel', 'pipeline.registry.register', 'pipeline.registry.deregister', 'quota.reset', 'quota.limit.update', 'quota.delete', 'quota.notice_settings.update', 'compliance.exemption.approve', 'compliance.exemption.revoke', 'compliance.exemption.request', 'compliance.exemption.reject', 'compliance.rule.toggle', 'compliance.rule.create', 'compliance.rule.update', 'compliance.rule.delete', 'compliance.rule.restore', 'compliance.rule.purge', 'compliance.policy.create', 'compliance.policy.update', 'compliance.policy.delete', 'compliance.policy.restore', 'compliance.policy.purge', 'compliance.scan-schedule.create', 'compliance.scan-schedule.update', 'compliance.scan-schedule.delete', 'compliance.template.apply', 'compliance.scan.create', 'compliance.scan.cancel', 'compliance.scan.complete', 'compliance.subscription.auto-subscribe', 'compliance.notification-preference.update', 'registry.gc', 'registry.image.delete', 'registry.image.copy', 'registry.image.sign', 'registry.token.issue', 'registry.quarantine.credential.mint', 'message.announcement.create', 'message.delete', 'message.restore', 'message.purge', 'message.update', 'message.attachment.upload', 'message.notify.internal', 'message.org.purge', 'support.case.open', 'support.case.reply', 'support.case.status', 'support.case.severity', 'support.case.assign', 'support.case.transfer', 'support.oncall.acknowledged', 'support.oncall.escalated', 'support.oncall.test', 'support.oncall.paged', 'support.contact.designate', 'support.contact.revoke', 'support.contact.upgrade', 'support.contact.downgrade', 'support.case.note', 'support.canned.write', 'billing.subscription.create', 'billing.subscription.update', 'billing.subscription.reactivate', 'billing.subscription.cancel', 'billing.subscription.delete', 'billing.tier.override', 'billing.support-floor.override', 'billing.support-incident.grant', 'billing.addon.add', 'billing.addon.remove', 'billing.addon.prune', 'billing.discount.generate', 'billing.discount.issue', 'billing.discount.apply', 'billing.discount.remove', 'billing.discount.revoke', 'billing.campaign.create', 'billing.campaign.update', 'billing.campaign.end', 'billing.promotion.create', 'billing.promotion.update', 'billing.promotion.revoke', 'billing.promotion.grant', 'billing.promotion.activate', 'billing.credit.consumed', 'billing.credit.exhausted', 'billing.combo.expired', 'reporting.settings.update', 'reporting.deployment.outcome', 'reporting.retention.sync', 'reporting.report.definition.create', 'reporting.report.definition.update', 'reporting.report.definition.delete', 'reporting.report.ownership.transfer', 'reporting.report.published', 'reporting.report.republished', 'reporting.report.link.created', 'reporting.report.link.revoked', 'reporting.report.recipient.added', 'reporting.report.recipient.removed', 'reporting.report.policy.update', 'reporting.report.paused', 'reporting.report.resumed', 'reporting.report.run.compose', 'reporting.report.run.notes', 'reporting.report.run.summary', 'reporting.report.recipient.resend', 'reporting.report.recipient.verified', 'reporting.report.recipient.unsubscribed', 'reporting.ingest.batch', 'reporting.ingest.rejected', 'reporting.incident.record', 'authz.denied', 'ask.query', 'ask.agent.turn', 'ask.feedback', 'pipeline.ai.generate', 'plugin.ai.generate', 'publisher.create', 'publisher.update', 'publisher.terms.accept', 'publisher.verify.request', 'publisher.verify.approve', 'publisher.verify.reject', 'publisher.tier.change', 'publisher.suspend', 'publisher.unsuspend', 'publisher.transfer.request', 'publisher.transfer.accept', 'publisher.transfer.decline', 'publisher.transfer.approve', 'publisher.transfer.reject', 'publisher.profile-change.approve', 'publisher.profile-change.reject', 'plugin.request.submit', 'plugin.request.withdraw', 'plugin.request.approve', 'plugin.request.second-approve', 'plugin.request.reject', 'plugin.request.auto-approve', 'plugin.listing.publish', 'plugin.listing.update', 'plugin.listing.state.change', 'plugin.listing.pause', 'plugin.listing.unpause', 'plugin.version.pause', 'plugin.version.yank', 'plugin.version.unyank', 'plugin.version.deprecate', 'plugin.version.prune', 'ecosystem.auto-approval-rule.create', 'ecosystem.auto-approval-rule.update', 'ecosystem.auto-approval-rule.delete', 'ecosystem.reserved-name.update', 'ecosystem.bootstrap.open', 'ecosystem.bootstrap.close', 'registry.image.publish', 'registry.image.resign', 'registry.image.yank', 'registry.image.gc', 'plugin.install.request', 'plugin.install.approve', 'plugin.install.deny', 'plugin.install.create', 'plugin.install.upgrade', 'plugin.install.change-request', 'plugin.install.change-approve', 'plugin.install.change-reject', 'plugin.install.remove', 'org.plugin-install-policy.update', 'plugin.shadowing.denied', 'plugin.review.create', 'plugin.review.update', 'plugin.review.delete', 'plugin.review.report', 'plugin.review.hold', 'plugin.review.release', 'plugin.review.remove', 'plugin.review.anonymize', 'plugin.review.reply.create', 'plugin.review.reply.update', 'plugin.review.reply.delete', 'plugin.submission.create', 'plugin.submission.verify', 'plugin.submission.gate-fail', 'plugin.submission.approve', 'plugin.submission.reject', 'plugin.submission.claim', 'plugin.submission.expire', 'plugin.advisory.create', 'plugin.advisory.update', 'plugin.advisory.publish', 'plugin.advisory.withdraw', 'plugin.security_notifications.update', 'plugin.security_notifications.external_email.verify', 'plugin.security_notifications.test', 'plugin.setup_image.promoted', 'plugin.setup_image.promote_refused', 'plugin.setup_image.kept', 'plugin.setup_image.discarded', 'pipeline.vuln.accepted', 'pipeline.vuln.false_positive', 'pipeline.vuln.reopened', 'pipeline.runtime_check.flagged', 'pipeline.plugin.upgraded', 'pipeline.security_report.upload'];
 export type RemoteAuditAction = typeof REMOTE_AUDIT_ACTIONS[number];
 /** Whether `value` is an action a remote service may emit (the ingest allow-list). */
 export declare function isRemoteAuditAction(value: string): value is RemoteAuditAction;