@pipeline-builder/api-core 4.1.13 → 4.1.15

package/lib/types/plugin-health.js

@@ -0,0 +1,184 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The plugin HEALTH SCORE (docs/plugin-publishing.md): one 0–100
+ * number per listing, from seven components. Pure and dependency-free so the
+ * plugin service (the stats sweep), the frontend (the breakdown panel's
+ * labels) and the tests share one definition.
+ *
+ * Each component scores 0..1 and carries a fixed weight. A component whose
+ * inputs are missing is DROPPED and the remaining weights are renormalized; with
+ * fewer than {@link HEALTH_MIN_COMPONENTS} components the score is null ("not
+ * enough data"), never a guess.
+ *
+ * | component  | weight | score                                                                 |
+ * |------------|--------|-----------------------------------------------------------------------|
+ * | runtime    | 25     | 30-day success rate; only with ≥ 20 runs                              |
+ * | vulns      | 20     | 1 − 0.5·critical − 0.1·high (floor 0), latest listed version; scanned only |
+ * | freshness  | 15     | release age (≤90d 1 → 0 at 540d) averaged with base-image age (≤60d 1 → 0 at 365d) when recorded |
+ * | signed     | 10     | image digest present and signed ⇒ 1                                   |
+ * | smokeTest  | 10     | smoke test declared ⇒ 1                                               |
+ * | docs       | 10     | README 0.5 + license 0.5                                              |
+ * | rating     | 10     | Bayesian rating / 5; only with ≥ 3 ratings                            |
+ */
+export const HEALTH_COMPONENTS = ['runtime', 'vulns', 'freshness', 'signed', 'smokeTest', 'docs', 'rating'];
+/** Nominal weight of each component (they sum to 100). */
+export const HEALTH_WEIGHTS = {
+    runtime: 25,
+    vulns: 20,
+    freshness: 15,
+    signed: 10,
+    smokeTest: 10,
+    docs: 10,
+    rating: 10,
+};
+/** Human labels for the breakdown panel. */
+export const HEALTH_COMPONENT_LABELS = {
+    runtime: 'Runtime success (30 days)',
+    vulns: 'Known vulnerabilities',
+    freshness: 'Freshness',
+    signed: 'Signed image',
+    smokeTest: 'Smoke test declared',
+    docs: 'README and license',
+    rating: 'Rating',
+};
+/** Fewer available components than this ⇒ no score. */
+export const HEALTH_MIN_COMPONENTS = 3;
+/** Runs needed in the window before the success rate counts. */
+export const HEALTH_MIN_RUNS = 20;
+/** Ratings needed before the rating counts. */
+export const HEALTH_MIN_RATINGS = 3;
+/** Release age: full marks up to this many days, zero at {@link HEALTH_RELEASE_ZERO_DAYS}. */
+export const HEALTH_RELEASE_FULL_DAYS = 90;
+export const HEALTH_RELEASE_ZERO_DAYS = 540;
+/** Base-image age: full marks up to this many days, zero at {@link HEALTH_BASE_IMAGE_ZERO_DAYS}. */
+export const HEALTH_BASE_IMAGE_FULL_DAYS = 60;
+export const HEALTH_BASE_IMAGE_ZERO_DAYS = 365;
+const DAY_MS = 86_400_000;
+const round3 = (n) => Math.round(n * 1000) / 1000;
+const clamp01 = (n) => Math.min(1, Math.max(0, n));
+function toTime(d) {
+    if (d === null || d === undefined)
+        return null;
+    const t = new Date(d).getTime();
+    return Number.isFinite(t) ? t : null;
+}
+/** 1 up to `fullDays`, falling linearly to 0 at `zeroDays` (a future date counts as fresh). */
+export function ageScore(ageDays, fullDays, zeroDays) {
+    if (ageDays <= fullDays)
+        return 1;
+    if (ageDays >= zeroDays)
+        return 0;
+    return clamp01(1 - (ageDays - fullDays) / (zeroDays - fullDays));
+}
+/** The vulnerability component: 1 − 0.5·critical − 0.1·high, floored at 0. */
+export function vulnScore(critical, high) {
+    return clamp01(1 - 0.5 * Math.max(0, critical) - 0.1 * Math.max(0, high));
+}
+function runtimeComponent(i) {
+    if (i.runs30d === null || i.runs30d === undefined || i.runs30d < HEALTH_MIN_RUNS)
+        return null;
+    if (i.successRate30d === null || i.successRate30d === undefined || !Number.isFinite(i.successRate30d))
+        return null;
+    return clamp01(i.successRate30d);
+}
+function vulnsComponent(i) {
+    if (toTime(i.scannedAt) === null)
+        return null;
+    return vulnScore(i.vulnCritical ?? 0, i.vulnHigh ?? 0);
+}
+function freshnessComponent(i, now) {
+    const parts = [];
+    const release = toTime(i.lastReleaseAt);
+    if (release !== null)
+        parts.push(ageScore((now - release) / DAY_MS, HEALTH_RELEASE_FULL_DAYS, HEALTH_RELEASE_ZERO_DAYS));
+    const base = toTime(i.baseImageCreatedAt);
+    if (base !== null)
+        parts.push(ageScore((now - base) / DAY_MS, HEALTH_BASE_IMAGE_FULL_DAYS, HEALTH_BASE_IMAGE_ZERO_DAYS));
+    if (parts.length === 0)
+        return null;
+    return parts.reduce((a, b) => a + b, 0) / parts.length;
+}
+const flag = (b) => (b === null || b === undefined ? null : b ? 1 : 0);
+function docsComponent(i) {
+    if ((i.hasReadme === null || i.hasReadme === undefined) && (i.hasLicense === null || i.hasLicense === undefined))
+        return null;
+    return (i.hasReadme ? 0.5 : 0) + (i.hasLicense ? 0.5 : 0);
+}
+function ratingComponent(i) {
+    if (i.ratingCount === null || i.ratingCount === undefined || i.ratingCount < HEALTH_MIN_RATINGS)
+        return null;
+    if (i.ratingBayes === null || i.ratingBayes === undefined || !Number.isFinite(i.ratingBayes))
+        return null;
+    return clamp01(i.ratingBayes / 5);
+}
+/** The health score and its per-component breakdown. Pure; `now` is injectable for tests. */
+export function computeHealthScore(inputs, now = new Date()) {
+    const t = now.getTime();
+    const raw = {
+        runtime: runtimeComponent(inputs),
+        vulns: vulnsComponent(inputs),
+        freshness: freshnessComponent(inputs, t),
+        signed: flag(inputs.signed),
+        smokeTest: flag(inputs.smokeTestDeclared),
+        docs: docsComponent(inputs),
+        rating: ratingComponent(inputs),
+    };
+    const breakdown = {};
+    let weighted = 0;
+    let totalWeight = 0;
+    let available = 0;
+    for (const c of HEALTH_COMPONENTS) {
+        const score = raw[c];
+        breakdown[c] = { score: score === null ? null : round3(score), weight: HEALTH_WEIGHTS[c] };
+        if (score === null)
+            continue;
+        available++;
+        weighted += score * HEALTH_WEIGHTS[c];
+        totalWeight += HEALTH_WEIGHTS[c];
+    }
+    const score = available < HEALTH_MIN_COMPONENTS || totalWeight === 0 ? null : Math.round((100 * weighted) / totalWeight);
+    return { score, breakdown };
+}
+/**
+ * A publisher's health: the install-weighted mean of its listings' scores
+ * (listings with no score are skipped; when no listing has installs, the plain
+ * mean). Null when no listing has a score.
+ */
+export function publisherHealthScore(listings) {
+    const scored = listings.filter((l) => l.healthScore !== null && Number.isFinite(l.healthScore));
+    if (scored.length === 0)
+        return null;
+    const weightOf = (n) => Math.max(0, n);
+    const totalInstalls = scored.reduce((a, l) => a + weightOf(l.installCount), 0);
+    if (totalInstalls === 0)
+        return Math.round(scored.reduce((a, l) => a + l.healthScore, 0) / scored.length);
+    return Math.round(scored.reduce((a, l) => a + l.healthScore * weightOf(l.installCount), 0) / totalInstalls);
+}
+/**
+ * A publisher's 30-day success rate across its listings, weighted by runs.
+ * Null when none of its listings ran in the window.
+ */
+export function publisherSuccessRate(listings) {
+    let runs = 0;
+    let succeeded = 0;
+    for (const l of listings) {
+        if (l.successRate30d === null || !Number.isFinite(l.successRate30d) || l.runs30d <= 0)
+            continue;
+        runs += l.runs30d;
+        succeeded += l.successRate30d * l.runs30d;
+    }
+    return runs === 0 ? null : round3(succeeded / runs);
+}
+export const HEALTH_BAND_GOOD = 80;
+export const HEALTH_BAND_FAIR = 50;
+export function healthBand(score) {
+    if (score === null || score === undefined || !Number.isFinite(score))
+        return 'unknown';
+    if (score >= HEALTH_BAND_GOOD)
+        return 'good';
+    if (score >= HEALTH_BAND_FAIR)
+        return 'fair';
+    return 'poor';
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-health.js","sourceRoot":"","sources":["../../src/types/plugin-health.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The plugin HEALTH SCORE (docs/plugin-publishing.md): one 0–100\n * number per listing, from seven components. Pure and dependency-free so the\n * plugin service (the stats sweep), the frontend (the breakdown panel's\n * labels) and the tests share one definition.\n *\n * Each component scores 0..1 and carries a fixed weight. A component whose\n * inputs are missing is DROPPED and the remaining weights are renormalized; with\n * fewer than {@link HEALTH_MIN_COMPONENTS} components the score is null (\"not\n * enough data\"), never a guess.\n *\n * | component  | weight | score                                                                 |\n * |------------|--------|-----------------------------------------------------------------------|\n * | runtime    | 25     | 30-day success rate; only with ≥ 20 runs                              |\n * | vulns      | 20     | 1 − 0.5·critical − 0.1·high (floor 0), latest listed version; scanned only |\n * | freshness  | 15     | release age (≤90d 1 → 0 at 540d) averaged with base-image age (≤60d 1 → 0 at 365d) when recorded |\n * | signed     | 10     | image digest present and signed ⇒ 1                                   |\n * | smokeTest  | 10     | smoke test declared ⇒ 1                                               |\n * | docs       | 10     | README 0.5 + license 0.5                                              |\n * | rating     | 10     | Bayesian rating / 5; only with ≥ 3 ratings                            |\n */\n\nexport const HEALTH_COMPONENTS = ['runtime', 'vulns', 'freshness', 'signed', 'smokeTest', 'docs', 'rating'] as const;\nexport type HealthComponent = (typeof HEALTH_COMPONENTS)[number];\n\n/** Nominal weight of each component (they sum to 100). */\nexport const HEALTH_WEIGHTS: Readonly<Record<HealthComponent, number>> = {\n  runtime: 25,\n  vulns: 20,\n  freshness: 15,\n  signed: 10,\n  smokeTest: 10,\n  docs: 10,\n  rating: 10,\n};\n\n/** Human labels for the breakdown panel. */\nexport const HEALTH_COMPONENT_LABELS: Readonly<Record<HealthComponent, string>> = {\n  runtime: 'Runtime success (30 days)',\n  vulns: 'Known vulnerabilities',\n  freshness: 'Freshness',\n  signed: 'Signed image',\n  smokeTest: 'Smoke test declared',\n  docs: 'README and license',\n  rating: 'Rating',\n};\n\n/** Fewer available components than this ⇒ no score. */\nexport const HEALTH_MIN_COMPONENTS = 3;\n/** Runs needed in the window before the success rate counts. */\nexport const HEALTH_MIN_RUNS = 20;\n/** Ratings needed before the rating counts. */\nexport const HEALTH_MIN_RATINGS = 3;\n/** Release age: full marks up to this many days, zero at {@link HEALTH_RELEASE_ZERO_DAYS}. */\nexport const HEALTH_RELEASE_FULL_DAYS = 90;\nexport const HEALTH_RELEASE_ZERO_DAYS = 540;\n/** Base-image age: full marks up to this many days, zero at {@link HEALTH_BASE_IMAGE_ZERO_DAYS}. */\nexport const HEALTH_BASE_IMAGE_FULL_DAYS = 60;\nexport const HEALTH_BASE_IMAGE_ZERO_DAYS = 365;\n\n/** One component's contribution: its 0..1 score (null = missing, dropped) and its nominal weight. */\nexport interface HealthComponentScore {\n  score: number | null;\n  weight: number;\n}\nexport type HealthBreakdown = Record<HealthComponent, HealthComponentScore>;\n\nexport interface HealthResult {\n  /** 0–100 integer, or null with fewer than {@link HEALTH_MIN_COMPONENTS} components. */\n  score: number | null;\n  breakdown: HealthBreakdown;\n}\n\n/**\n * What the score is computed from. Every field is optional: `undefined` / null\n * means \"not known\", which drops the component (or, for freshness, that half).\n */\nexport interface HealthInputs {\n  /** Terminal runs in the 30-day window, and the share that succeeded (0..1). */\n  runs30d?: number | null;\n  successRate30d?: number | null;\n  /** The latest listed version's scan; `scannedAt` null ⇒ never scanned. */\n  vulnCritical?: number | null;\n  vulnHigh?: number | null;\n  scannedAt?: Date | string | null;\n  /** When the latest listed version was published. */\n  lastReleaseAt?: Date | string | null;\n  /** The latest listed version's base image `created` time, when recorded. */\n  baseImageCreatedAt?: Date | string | null;\n  /** Latest listed version has an image digest AND a signature (its `public/*` copy). */\n  signed?: boolean | null;\n  smokeTestDeclared?: boolean | null;\n  hasReadme?: boolean | null;\n  hasLicense?: boolean | null;\n  ratingBayes?: number | null;\n  ratingCount?: number | null;\n}\n\nconst DAY_MS = 86_400_000;\n\nconst round3 = (n: number): number => Math.round(n * 1000) / 1000;\nconst clamp01 = (n: number): number => Math.min(1, Math.max(0, n));\n\nfunction toTime(d: Date | string | null | undefined): number | null {\n  if (d === null || d === undefined) return null;\n  const t = new Date(d).getTime();\n  return Number.isFinite(t) ? t : null;\n}\n\n/** 1 up to `fullDays`, falling linearly to 0 at `zeroDays` (a future date counts as fresh). */\nexport function ageScore(ageDays: number, fullDays: number, zeroDays: number): number {\n  if (ageDays <= fullDays) return 1;\n  if (ageDays >= zeroDays) return 0;\n  return clamp01(1 - (ageDays - fullDays) / (zeroDays - fullDays));\n}\n\n/** The vulnerability component: 1 − 0.5·critical − 0.1·high, floored at 0. */\nexport function vulnScore(critical: number, high: number): number {\n  return clamp01(1 - 0.5 * Math.max(0, critical) - 0.1 * Math.max(0, high));\n}\n\nfunction runtimeComponent(i: HealthInputs): number | null {\n  if (i.runs30d === null || i.runs30d === undefined || i.runs30d < HEALTH_MIN_RUNS) return null;\n  if (i.successRate30d === null || i.successRate30d === undefined || !Number.isFinite(i.successRate30d)) return null;\n  return clamp01(i.successRate30d);\n}\n\nfunction vulnsComponent(i: HealthInputs): number | null {\n  if (toTime(i.scannedAt) === null) return null;\n  return vulnScore(i.vulnCritical ?? 0, i.vulnHigh ?? 0);\n}\n\nfunction freshnessComponent(i: HealthInputs, now: number): number | null {\n  const parts: number[] = [];\n  const release = toTime(i.lastReleaseAt);\n  if (release !== null) parts.push(ageScore((now - release) / DAY_MS, HEALTH_RELEASE_FULL_DAYS, HEALTH_RELEASE_ZERO_DAYS));\n  const base = toTime(i.baseImageCreatedAt);\n  if (base !== null) parts.push(ageScore((now - base) / DAY_MS, HEALTH_BASE_IMAGE_FULL_DAYS, HEALTH_BASE_IMAGE_ZERO_DAYS));\n  if (parts.length === 0) return null;\n  return parts.reduce((a, b) => a + b, 0) / parts.length;\n}\n\nconst flag = (b: boolean | null | undefined): number | null => (b === null || b === undefined ? null : b ? 1 : 0);\n\nfunction docsComponent(i: HealthInputs): number | null {\n  if ((i.hasReadme === null || i.hasReadme === undefined) && (i.hasLicense === null || i.hasLicense === undefined)) return null;\n  return (i.hasReadme ? 0.5 : 0) + (i.hasLicense ? 0.5 : 0);\n}\n\nfunction ratingComponent(i: HealthInputs): number | null {\n  if (i.ratingCount === null || i.ratingCount === undefined || i.ratingCount < HEALTH_MIN_RATINGS) return null;\n  if (i.ratingBayes === null || i.ratingBayes === undefined || !Number.isFinite(i.ratingBayes)) return null;\n  return clamp01(i.ratingBayes / 5);\n}\n\n/** The health score and its per-component breakdown. Pure; `now` is injectable for tests. */\nexport function computeHealthScore(inputs: HealthInputs, now: Date = new Date()): HealthResult {\n  const t = now.getTime();\n  const raw: Record<HealthComponent, number | null> = {\n    runtime: runtimeComponent(inputs),\n    vulns: vulnsComponent(inputs),\n    freshness: freshnessComponent(inputs, t),\n    signed: flag(inputs.signed),\n    smokeTest: flag(inputs.smokeTestDeclared),\n    docs: docsComponent(inputs),\n    rating: ratingComponent(inputs),\n  };\n  const breakdown = {} as HealthBreakdown;\n  let weighted = 0;\n  let totalWeight = 0;\n  let available = 0;\n  for (const c of HEALTH_COMPONENTS) {\n    const score = raw[c];\n    breakdown[c] = { score: score === null ? null : round3(score), weight: HEALTH_WEIGHTS[c] };\n    if (score === null) continue;\n    available++;\n    weighted += score * HEALTH_WEIGHTS[c];\n    totalWeight += HEALTH_WEIGHTS[c];\n  }\n  const score = available < HEALTH_MIN_COMPONENTS || totalWeight === 0 ? null : Math.round((100 * weighted) / totalWeight);\n  return { score, breakdown };\n}\n\n/**\n * A publisher's health: the install-weighted mean of its listings' scores\n * (listings with no score are skipped; when no listing has installs, the plain\n * mean). Null when no listing has a score.\n */\nexport function publisherHealthScore(listings: ReadonlyArray<{ healthScore: number | null; installCount: number }>): number | null {\n  const scored = listings.filter((l): l is { healthScore: number; installCount: number } =>\n    l.healthScore !== null && Number.isFinite(l.healthScore));\n  if (scored.length === 0) return null;\n  const weightOf = (n: number) => Math.max(0, n);\n  const totalInstalls = scored.reduce((a, l) => a + weightOf(l.installCount), 0);\n  if (totalInstalls === 0) return Math.round(scored.reduce((a, l) => a + l.healthScore, 0) / scored.length);\n  return Math.round(scored.reduce((a, l) => a + l.healthScore * weightOf(l.installCount), 0) / totalInstalls);\n}\n\n/**\n * A publisher's 30-day success rate across its listings, weighted by runs.\n * Null when none of its listings ran in the window.\n */\nexport function publisherSuccessRate(listings: ReadonlyArray<{ successRate30d: number | null; runs30d: number }>): number | null {\n  let runs = 0;\n  let succeeded = 0;\n  for (const l of listings) {\n    if (l.successRate30d === null || !Number.isFinite(l.successRate30d) || l.runs30d <= 0) continue;\n    runs += l.runs30d;\n    succeeded += l.successRate30d * l.runs30d;\n  }\n  return runs === 0 ? null : round3(succeeded / runs);\n}\n\n/** Display band for a score: good ≥ 80, fair ≥ 50, poor below, unknown when null. */\nexport type HealthBand = 'good' | 'fair' | 'poor' | 'unknown';\nexport const HEALTH_BAND_GOOD = 80;\nexport const HEALTH_BAND_FAIR = 50;\n\nexport function healthBand(score: number | null | undefined): HealthBand {\n  if (score === null || score === undefined || !Number.isFinite(score)) return 'unknown';\n  if (score >= HEALTH_BAND_GOOD) return 'good';\n  if (score >= HEALTH_BAND_FAIR) return 'fair';\n  return 'poor';\n}\n"]}

package/lib/types/quota-tiers.d.ts

@@ -24,6 +24,12 @@ export interface QuotaTierLimits {
     alertRules: number;
     alertDestinations: number;
     idpConfigs: number;
+    /**
+     * Active, non-suspended plugin-ecosystem listings the org publishes
+     * (docs/plugin-installing.md). A COUNT quota — installs never
+     * count. -1 = unlimited. Extendable via the `listing_pack` add-on bundle.
+     */
+    listings: number;
     /**
      * Max org members (active users / seats). -1 = unlimited. This is the "Team"
      * tier differentiator — enforced at member-invite time (an invite is blocked
@@ -77,3 +83,12 @@ export declare const DEFAULT_TIER: QuotaTier;
 export declare function isValidTier(value: string): value is QuotaTier;
 /** Get the default limits for a given tier (falls back to developer). */
 export declare function getTierLimits(tier: string): QuotaTierLimits;
+/**
+ * The period (days) every usage counter rolls over on. All quotas are per-period
+ * FLOW counters on one shared period: the quota service resets a counter this
+ * many days after it expires, and platform seeds a new org's counters with the
+ * same window (`QUOTA_RESET_DAYS`, default 3).
+ */
+export declare const QUOTA_RESET_DAYS: number;
+/** The next quota reset: local midnight `days` from `now`. */
+export declare function nextQuotaResetDate(days?: number, now?: Date): Date;

package/lib/types/quota-tiers.js

@@ -1,6 +1,6 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
-import { envInt, envStr } from '../utils/env.js';
+import { envBool, envInt, envStr } from '../utils/env.js';
 /**
  * Preset limits for each tier. -1 means unlimited.
  *
@@ -36,6 +36,7 @@ const DEFAULT_TIER_LIMITS = {
         alertRules: 50,
         alertDestinations: 10,
         idpConfigs: 1,
+        listings: 3,
         seats: 1,
         eventRetentionDays: 30,
         doraRetentionDays: 180,
@@ -54,6 +55,7 @@ const DEFAULT_TIER_LIMITS = {
         alertRules: 500,
         alertDestinations: 50,
         idpConfigs: 5,
+        listings: 10,
         seats: 1,
         eventRetentionDays: 30,
         doraRetentionDays: 180,
@@ -72,6 +74,7 @@ const DEFAULT_TIER_LIMITS = {
         alertRules: -1,
         alertDestinations: -1,
         idpConfigs: 5,
+        listings: 25,
         seats: 3,
         eventRetentionDays: 30,
         doraRetentionDays: 180,
@@ -90,6 +93,7 @@ const DEFAULT_TIER_LIMITS = {
         alertRules: -1,
         alertDestinations: -1,
         idpConfigs: -1,
+        listings: 100,
         seats: 15,
         eventRetentionDays: 30,
         doraRetentionDays: 180,
@@ -106,6 +110,7 @@ const DEFAULT_TIER_LIMITS = {
         alertRules: -1,
         alertDestinations: -1,
         idpConfigs: -1,
+        listings: -1,
         seats: -1,
         eventRetentionDays: -1,
         doraRetentionDays: -1,
@@ -151,6 +156,7 @@ function tierLimits(tier) {
         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),
         eventRetentionDays: tierLimitEnv(`QUOTA_TIER_${T}_EVENT_RETENTION_DAYS`, d.eventRetentionDays),
         doraRetentionDays: tierLimitEnv(`QUOTA_TIER_${T}_DORA_RETENTION_DAYS`, d.doraRetentionDays),
@@ -184,7 +190,7 @@ export function tierAllowsTeams(tier) {
  *  opt-out default-on — mirrors the billing/platform configs). With billing OFF
  *  there's no metering/enforcement surface, so the default tier is `unlimited`. */
 export function isBillingEnabled() {
-    return (process.env.BILLING_ENABLED || 'true').toLowerCase() !== 'false';
+    return envBool('BILLING_ENABLED', true);
 }
 /**
  * Default tier assigned to new organizations.
@@ -208,4 +214,18 @@ export function isValidTier(value) {
 export function getTierLimits(tier) {
     return isValidTier(tier) ? QUOTA_TIERS[tier].limits : QUOTA_TIERS.developer.limits;
 }
-//# 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 { 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' | '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   * 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: 25,\n    pipelines: 2,\n    apiCalls: 25_000,\n    aiCalls: 25,\n    storageBytes: 2 * GB,\n    dashboards: 20,\n    alertRules: 50,\n    alertDestinations: 10,\n    idpConfigs: 1,\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: 50,\n    pipelines: 5,\n    apiCalls: 250_000,\n    aiCalls: 1_000,\n    storageBytes: 25 * GB,\n    dashboards: 200,\n    alertRules: 500,\n    alertDestinations: 50,\n    idpConfigs: 5,\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: 75,\n    pipelines: 6,\n    apiCalls: 500_000,\n    aiCalls: 2_500,\n    storageBytes: 60 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: 5,\n    seats: 3,\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: 900_000,\n    aiCalls: 9_000,\n    storageBytes: 250 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: -1,\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    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    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  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', 'enterprise', 'unlimited'];\nexport function tierAllowsTeams(tier: string | undefined | null): boolean {\n  return !!tier && (TEAM_CAPABLE_TIERS as readonly string[]).includes(tier);\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 (process.env.BILLING_ENABLED || 'true').toLowerCase() !== 'false';\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"]}
+/**
+ * The period (days) every usage counter rolls over on. All quotas are per-period
+ * FLOW counters on one shared period: the quota service resets a counter this
+ * many days after it expires, and platform seeds a new org's counters with the
+ * same window (`QUOTA_RESET_DAYS`, default 3).
+ */
+export const QUOTA_RESET_DAYS = envInt('QUOTA_RESET_DAYS', 3, { min: 1 });
+/** The next quota reset: local midnight `days` from `now`. */
+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":"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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';\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' | '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: 25,\n    pipelines: 2,\n    apiCalls: 25_000,\n    aiCalls: 25,\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: 50,\n    pipelines: 5,\n    apiCalls: 250_000,\n    aiCalls: 1_000,\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: 75,\n    pipelines: 6,\n    apiCalls: 500_000,\n    aiCalls: 2_500,\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  // 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: 900_000,\n    aiCalls: 9_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  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', 'enterprise', 'unlimited'];\nexport function tierAllowsTeams(tier: string | undefined | null): boolean {\n  return !!tier && (TEAM_CAPABLE_TIERS as readonly string[]).includes(tier);\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"]}

package/lib/types/wire-vocabulary.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Closed string vocabularies that cross the wire between the services and the
+ * browser. Each is an `as const` array (the runtime list a Zod enum, a Mongoose
+ * enum or a drizzle `$type` builds from) plus the union type derived from it.
+ *
+ * Dependency-free on purpose: the frontend imports these types, so a value added
+ * here reaches the UI's exhaustive label maps as a compile error instead of a
+ * silently unhandled string. The Postgres CHECK constraints in
+ * deploy/shared/postgres-init.sql mirror the ones stored in SQL.
+ */
+export declare const RULE_SEVERITIES: readonly ['warning', 'error', 'critical'];
+export type RuleSeverity = (typeof RULE_SEVERITIES)[number];
+export declare const RULE_TARGETS: readonly ['plugin', 'pipeline'];
+export type RuleTarget = (typeof RULE_TARGETS)[number];
+/** Field-evaluation operators; the engine's implementations live in api/compliance. */
+export declare const RULE_OPERATORS: readonly ['eq', 'neq', 'contains', 'notContains', 'regex', 'gt', 'gte', 'lt', 'lte', 'in', 'notIn', 'exists', 'notExists', 'notEmpty', 'countGt', 'countLt', 'lengthGt', 'lengthLt'];
+export type RuleOperator = (typeof RULE_OPERATORS)[number];
+/** Operators that test presence only and take no comparison value. */
+export declare const VALUELESS_RULE_OPERATORS: readonly ["exists", "notExists", "notEmpty"];
+/** How a multi-condition rule combines its conditions. */
+export declare const RULE_CONDITION_MODES: readonly ['all', 'any'];
+export type RuleConditionMode = (typeof RULE_CONDITION_MODES)[number];
+/** `published` rules belong to the system org and apply by subscription. */
+export declare const RULE_SCOPES: readonly ['org', 'published'];
+export type RuleScope = (typeof RULE_SCOPES)[number];
+export declare const MESSAGE_TYPES: readonly ['announcement', 'conversation'];
+export type MessageType = (typeof MESSAGE_TYPES)[number];
+export declare const MESSAGE_PRIORITIES: readonly ['normal', 'high', 'urgent'];
+export type MessagePriority = (typeof MESSAGE_PRIORITIES)[number];
+export declare const SUBSCRIPTION_STATUSES: readonly ['active', 'canceled', 'past_due', 'trialing', 'incomplete'];
+export type SubscriptionStatus = (typeof SUBSCRIPTION_STATUSES)[number];
+export declare const BILLING_INTERVALS: readonly ['monthly', 'annual'];
+export type BillingInterval = (typeof BILLING_INTERVALS)[number];
+/** OIDC providers an org IdP config can name (GitHub is OAuth-only and refused by the OIDC engine). */
+export declare const IDP_PROVIDERS: readonly ['generic-oidc', 'cognito', 'google', 'github'];
+export type IdpProvider = (typeof IDP_PROVIDERS)[number];
+/** The federation protocol an org signs in over — one per org. */
+export declare const IDP_PROTOCOLS: readonly ['oidc', 'saml'];
+export type IdpProtocol = (typeof IDP_PROTOCOLS)[number];
+/**
+ * Which SAML assertion attribute carries which identity field. An empty name
+ * means "use the common spellings" (short names plus the Entra/Shibboleth URIs).
+ */
+export interface SamlAttributeMapping {
+    /** Attribute holding the user's email address. */
+    email?: string;
+    /** Attribute holding the display name. */
+    name?: string;
+    /** Attribute holding group memberships (drives JIT role mapping). */
+    groups?: string;
+}
+/** The coarse grant a permission role gives its members. */
+export declare const ROLE_GRANTS: readonly ['superadmin', 'admin', 'member'];
+export type RoleGrant = (typeof ROLE_GRANTS)[number];
+/** Publisher trust tier. */
+export declare const PUBLISHER_TIERS: readonly ['official', 'verified', 'community', 'unverified'];
+export type PublisherTier = (typeof PUBLISHER_TIERS)[number];
+/** A directory listing's lifecycle state. */
+export declare const LISTING_STATES: readonly ['listed', 'unmaintained', 'suspended', 'transferred'];
+export type ListingState = (typeof LISTING_STATES)[number];
+/** What a publish request asks the system org to do. */
+export declare const PUBLISH_REQUEST_KINDS: readonly ['new_listing', 'new_version', 'listing_update', 'yank', 'unpause', 'transfer', 'claim', 'profile_change', 'advisory', 'verify', 'moderation', 'submission'];
+export type PublishRequestKind = (typeof PUBLISH_REQUEST_KINDS)[number];
+export declare const PUBLISH_REQUEST_STATUSES: readonly ['pending', 'pending_second_approval', 'approved', 'rejected', 'withdrawn'];
+export type PublishRequestStatus = (typeof PUBLISH_REQUEST_STATUSES)[number];
+/** The statuses a request is still "open" in (drives the one-open-request index). */
+export declare const OPEN_PUBLISH_REQUEST_STATUSES: readonly ["pending", "pending_second_approval"];
+/** `security` requests jump the moderation queue. */
+export declare const PUBLISH_REQUEST_LANES: readonly ['standard', 'security'];
+export type PublishRequestLane = (typeof PUBLISH_REQUEST_LANES)[number];
+/** Install version policy: exact, `~`, `^`, or anything non-breaking. */
+export declare const INSTALL_VERSION_POLICIES: readonly ['pinned', 'patch', 'minor', 'latest'];
+export type InstallVersionPolicy = (typeof INSTALL_VERSION_POLICIES)[number];
+export declare const INSTALL_STATUSES: readonly ['active', 'pending_approval', 'denied'];
+export type InstallStatus = (typeof INSTALL_STATUSES)[number];
+/** The advisory severity at which a consumption policy blocks installs. */
+export declare const BLOCK_ON_ADVISORY_LEVELS: readonly ['critical', 'high', 'never'];
+export type BlockOnAdvisory = (typeof BLOCK_ON_ADVISORY_LEVELS)[number];
+/** Whether official plugins need an explicit install before a pipeline can use them. */
+export declare const OFFICIAL_INSTALLS_MODES: readonly ['implicit', 'explicit'];
+export type OfficialInstalls = (typeof OFFICIAL_INSTALLS_MODES)[number];
+export declare const REVIEW_STATUSES: readonly ['published', 'held', 'removed'];
+export type ReviewStatus = (typeof REVIEW_STATUSES)[number];
+/** Why a held review is held. */
+export declare const REVIEW_HOLD_REASONS: readonly ['reports', 'burst', 'filter', 'security', 'moderator'];
+export type ReviewHoldReason = (typeof REVIEW_HOLD_REASONS)[number];
+/** A review report's category; `security` routes privately to the advisory path. */
+export declare const REVIEW_REPORT_CATEGORIES: readonly ['spam', 'abuse', 'off_topic', 'security'];
+export type ReviewReportCategory = (typeof REVIEW_REPORT_CATEGORIES)[number];
+export declare const ADVISORY_SEVERITIES: readonly ['critical', 'high', 'medium', 'low'];
+export type AdvisorySeverity = (typeof ADVISORY_SEVERITIES)[number];
+export declare const ADVISORY_STATES: readonly ['draft', 'published', 'withdrawn'];
+export type AdvisoryState = (typeof ADVISORY_STATES)[number];
+export declare const ADVISORY_SOURCES: readonly ['publisher', 'moderator', 'cve_rescan', 'review'];
+export type AdvisorySource = (typeof ADVISORY_SOURCES)[number];
+/**
+ * An anonymous submission's lifecycle. `publishing` is the short claim an
+ * approval takes before it copies the quarantined image out, so an expiry can
+ * never delete the artifacts of a submission that is being published.
+ */
+export declare const SUBMISSION_STATUSES: readonly ['pending_verification', 'pending_review', 'publishing', 'gate_failed', 'approved', 'rejected', 'expired', 'claimed'];
+export type SubmissionStatus = (typeof SUBMISSION_STATUSES)[number];