@pipeline-builder/pipeline-core 3.4.143 → 3.4.145

package/lib/config/billing-config.d.ts

@@ -1,8 +1,16 @@
-import type { BillingConfig, BundleConfig } from './config-types.js';
+import type { BillingConfig, BundleConfig, ComboDiscountConfig } from './config-types.js';
 /**
  * Load billing plan configuration from environment variables.
  */
 export declare function loadBillingConfig(): BillingConfig;
+/**
+ * Config-load guardrail for combos: every `bundleId` must resolve to an ACTIVE
+ * bundle and every `minQuantities` key must be one of the combo's `bundleIds`.
+ * A typo'd member or stray minQuantity key otherwise ships a permanently-inert
+ * combo (missing bundle treated as unit price 0, or a min never satisfiable),
+ * silently never applying. Throws so misconfig fails fast at boot.
+ */
+export declare function assertCombosValid(combos: ComboDiscountConfig[], bundles: BundleConfig[]): void;
 /**
  * Config-load guardrail for the `requires` prerequisite graph. A `requires` entry
  * that doesn't resolve to an ACTIVE bundle — or that participates in a cycle —

package/lib/config/billing-config.js

@@ -121,8 +121,8 @@ export function loadBillingConfig() {
                 || 'For individual power users and production workloads',
             tier: 'pro',
             prices: {
-                monthly: envCents(process.env.BILLING_PLAN_PRO_MONTHLY, 4900),
-                annual: envCents(process.env.BILLING_PLAN_PRO_ANNUAL, 49000),
+                monthly: envCents(process.env.BILLING_PLAN_PRO_MONTHLY, 3900),
+                annual: envCents(process.env.BILLING_PLAN_PRO_ANNUAL, 39000),
             },
             features: parseFeatures(process.env.BILLING_PLAN_PRO_FEATURES, DEFAULT_PRO_FEATURES),
             isActive: true,
@@ -136,8 +136,8 @@ export function loadBillingConfig() {
                 || 'For teams collaborating on shared pipelines',
             tier: 'team',
             prices: {
-                monthly: envCents(process.env.BILLING_PLAN_TEAM_MONTHLY, 14900),
-                annual: envCents(process.env.BILLING_PLAN_TEAM_ANNUAL, 149000),
+                monthly: envCents(process.env.BILLING_PLAN_TEAM_MONTHLY, 7900),
+                annual: envCents(process.env.BILLING_PLAN_TEAM_ANNUAL, 79000),
             },
             features: parseFeatures(process.env.BILLING_PLAN_TEAM_FEATURES, DEFAULT_TEAM_FEATURES),
             isActive: true,
@@ -148,7 +148,7 @@ export function loadBillingConfig() {
             id: 'enterprise',
             name: process.env.BILLING_PLAN_ENTERPRISE_NAME || 'Enterprise',
             description: process.env.BILLING_PLAN_ENTERPRISE_DESCRIPTION
-                || 'Org-wide scale with unlimited seats and priority support',
+                || 'Org-wide scale with a high seat baseline (expandable via Member Seat add-ons) and priority support',
             tier: 'enterprise',
             prices: {
                 monthly: envCents(process.env.BILLING_PLAN_ENTERPRISE_MONTHLY, 59900),
@@ -196,8 +196,10 @@ export function loadBillingConfig() {
  * Defaults:
  *  - "Analytics Suite" — Advanced Reporting (DORA) + Team Usage Analytics, each
  *    $30/mo, together $42/mo ($420/yr) → a $18/mo credit (~30% off).
- *  - "Team Growth Bundle" — ≥1 Seat Pack ($25) + Team Usage Analytics ($30),
- *    together $38.50/mo ($385/yr) → a $16.50/mo credit (~30% off).
+ *  - "Team Growth Bundle" — ≥5 Seats ($19.99 ea) + Team Usage Analytics ($30),
+ *    basket $129.95/mo → together $90.99/mo ($909.90/yr) → a ~$38.96/mo credit (~30% off).
+ *  - "Scale Bundle" — API Pack ($19.99) + Storage Pack ($19.99), basket $39.98/mo
+ *    → together $27.99/mo ($279.90/yr) → a ~$11.99/mo credit (~30% off).
  * Prices env-overridable via `BILLING_COMBO_<ID>_MONTHLY` / `_ANNUAL`.
  */
 function loadComboDiscounts(bundles) {
@@ -215,13 +217,52 @@ function loadComboDiscounts(bundles) {
     });
     const combos = [
         c('analytics_suite', 'Analytics Suite', ['advanced_reporting', 'team_usage_analytics'], 4200, 42000, 0),
-        c('team_growth', 'Team Growth Bundle', ['seat_pack', 'team_usage_analytics'], 3850, 38500, 1, { seat_pack: 1 }),
+        // Team Growth — ≥5 Seats ($19.99 ea) + Team Usage Analytics ($30). Basket
+        // 5×$19.99 + $30 = $129.95/mo → bundled $90.99/mo (~30% off, ~$38.96 credit).
+        c('team_growth', 'Team Growth Bundle', ['seat', 'team_usage_analytics'], 9099, 90990, 1, { seat: 5 }),
         // Compliance Suite — Standard + Advanced at 30% off ($908.60/yr vs $1,298 list).
         c('compliance_suite', 'Compliance Suite', ['compliance_standard', 'compliance_advanced'], 9086, 90860, 2),
+        // Scale Bundle — API Pack ($19.99) + Storage Pack ($19.99). Basket $39.98/mo →
+        // bundled $27.99/mo (~30% off, ~$11.99 credit). Both members all-tier.
+        c('scale_bundle', 'Scale Bundle', ['api_pack', 'storage_pack'], 2799, 27990, 3),
     ];
+    assertCombosValid(combos, bundles);
     warnOnNonDiscountCombos(combos, bundles);
     return combos;
 }
+/**
+ * Config-load guardrail for combos: every `bundleId` must resolve to an ACTIVE
+ * bundle and every `minQuantities` key must be one of the combo's `bundleIds`.
+ * A typo'd member or stray minQuantity key otherwise ships a permanently-inert
+ * combo (missing bundle treated as unit price 0, or a min never satisfiable),
+ * silently never applying. Throws so misconfig fails fast at boot.
+ */
+export function assertCombosValid(combos, bundles) {
+    const activeIds = new Set(bundles.filter((b) => b.isActive).map((b) => b.id));
+    for (const combo of combos) {
+        for (const id of combo.bundleIds) {
+            if (!activeIds.has(id)) {
+                throw new Error(`Combo "${combo.id}" references bundle "${id}", which is not an active bundle.`);
+            }
+        }
+        for (const key of Object.keys(combo.minQuantities ?? {})) {
+            if (!combo.bundleIds.includes(key)) {
+                throw new Error(`Combo "${combo.id}" minQuantities key "${key}" is not one of its bundleIds.`);
+            }
+        }
+    }
+}
+/** The volume-discount percent applying to `quantity` units of a bundle — the
+ *  highest `volumeTiers` entry whose `minQuantity ≤ quantity`, else 0. Mirrors
+ *  `volumeDiscountPct` in api/billing's combo-pricing (which can't be imported the
+ *  other way); the combo credit math and this guardrail MUST use the same basis. */
+function volumeDiscountPctAt(bundle, quantity) {
+    let pct = 0;
+    for (const t of bundle?.volumeTiers ?? [])
+        if (quantity >= t.minQuantity)
+            pct = t.discountPercent;
+    return pct;
+}
 /**
  * Guardrail: a combo whose combined price is ≥ its minimum-composition basket grants
  * no credit (the credit clamps to $0) and is silently inert. Warn loudly instead so a
@@ -232,7 +273,16 @@ function warnOnNonDiscountCombos(combos, bundles) {
     const byId = new Map(bundles.map((b) => [b.id, b]));
     for (const combo of combos) {
         for (const interval of ['monthly', 'annual']) {
-            const basket = combo.bundleIds.reduce((s, id) => s + (byId.get(id)?.prices[interval] ?? 0) * (combo.minQuantities?.[id] ?? 1), 0);
+            // Post-volume basis (mirrors `comboBasisCents`): a member with volume tiers is
+            // basised on its DISCOUNTED unit at the combo's minQty, so this guardrail can't
+            // silently miss a combo that grants no real credit once volume is applied.
+            const basket = combo.bundleIds.reduce((s, id) => {
+                const b = byId.get(id);
+                const qty = combo.minQuantities?.[id] ?? 1;
+                const rawUnit = b?.prices[interval] ?? 0;
+                const unit = Math.round((rawUnit * (100 - volumeDiscountPctAt(b, qty))) / 100);
+                return s + unit * qty;
+            }, 0);
             if (combo.prices[interval] >= basket) {
                 // eslint-disable-next-line no-console
                 console.warn(`[billing-config] Combo "${combo.id}" ${interval} price ${combo.prices[interval]} ≥ member basket ${basket}; it grants no discount.`);
@@ -244,7 +294,7 @@ const BUNDLE_GB = 1024 * 1024 * 1024;
 /**
  * Apply a per-bundle grant override. Each stackable pack grants exactly one
  * quota dimension, so `BILLING_BUNDLE_<ID>_GRANT` retunes that amount (e.g. make
- * the Seat Pack grant +10 instead of +5) — parallel to the price overrides.
+ * the Plugin Pack grant +50 instead of +25) — parallel to the price overrides.
  * Ignored for multi-dimension or feature-only (empty-grant) bundles, and for a
  * malformed/negative value.
  */
@@ -280,6 +330,45 @@ function applyTiersOverride(id, defaultTiers) {
         return defaultTiers;
     }
 }
+/**
+ * Apply a per-bundle volume-tier override. `BILLING_BUNDLE_<ID>_VOLUME_TIERS` is a
+ * JSON array of `{ minQuantity, discountPercent }` (e.g.
+ * `[{"minQuantity":5,"discountPercent":10}]`) — parallel to the price/grant/tier
+ * overrides. Falls back to `defaultTiers` when unset, malformed, or containing an
+ * invalid entry (minQuantity ≥ 1, 0 < discountPercent ≤ 100). Sorted ascending by
+ * minQuantity so the "highest matching tier wins" lookup is deterministic.
+ */
+function applyVolumeTiersOverride(id, defaultTiers) {
+    const raw = process.env[`BILLING_BUNDLE_${id.toUpperCase()}_VOLUME_TIERS`];
+    const sortAsc = (t) => [...t].sort((a, b) => a.minQuantity - b.minQuantity);
+    const fallback = () => (defaultTiers ? sortAsc(defaultTiers) : undefined);
+    if (!raw)
+        return fallback();
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed) || parsed.length === 0)
+            return fallback();
+        // Each entry: integer minQuantity ≥ 1, 0 < discountPercent ≤ 100.
+        const valid = parsed.filter((t) => t && typeof t.minQuantity === 'number' && Number.isInteger(t.minQuantity) && t.minQuantity >= 1
+            && typeof t.discountPercent === 'number' && t.discountPercent > 0 && t.discountPercent <= 100);
+        if (valid.length !== parsed.length)
+            return fallback();
+        const sorted = sortAsc(valid);
+        // Reject a non-monotonic curve: buying MORE must never earn a SMALLER discount,
+        // and duplicate thresholds are ambiguous. (`volumeDiscountPct` picks the last
+        // qualifying tier, so a descending percent would penalize higher quantities.)
+        for (let i = 1; i < sorted.length; i++) {
+            if (sorted[i].minQuantity === sorted[i - 1].minQuantity)
+                return fallback();
+            if (sorted[i].discountPercent <= sorted[i - 1].discountPercent)
+                return fallback();
+        }
+        return sorted;
+    }
+    catch {
+        return fallback();
+    }
+}
 /**
  * Purchasable add-on bundles (docs/billing-bundles.md §3). Grants are per-unit
  * deltas on QuotaTierLimits; prices (cents, `BILLING_BUNDLE_<ID>_MONTHLY` /
@@ -292,6 +381,7 @@ function loadBundles() {
         // Resolve monthly first so the annual fallback tracks a `_MONTHLY` override
         // (annual ≈ 10× the *effective* monthly, not the hardcoded default).
         const resolvedMonthly = envCents(process.env[`BILLING_BUNDLE_${id.toUpperCase()}_MONTHLY`], monthly);
+        const volumeTiers = applyVolumeTiersOverride(id, extra.volumeTiers);
         return {
             id,
             name,
@@ -300,6 +390,7 @@ function loadBundles() {
             ...(extra.features ? { features: extra.features } : {}),
             ...(extra.maxQuantity !== undefined ? { maxQuantity: extra.maxQuantity } : {}),
             ...(extra.requires ? { requires: extra.requires } : {}),
+            ...(volumeTiers ? { volumeTiers } : {}),
             prices: {
                 monthly: resolvedMonthly,
                 annual: envCents(process.env[`BILLING_BUNDLE_${id.toUpperCase()}_ANNUAL`], resolvedMonthly * 10),
@@ -314,18 +405,17 @@ function loadBundles() {
     // is the billing-off tier and buys nothing) — so this is exactly STANDARD_TIERS.
     const ALL = [...STANDARD_TIERS];
     const bundles = [
-        // Capacity packs (pipelines/plugins) are available on EVERY tier so any
-        // account — including free (developer) — can expand in place. Feature bundles
-        // (audit_log/sso) and rate packs stay tier-scoped by default.
-        // Seat Pack is the EXCEPTION — Team+ only. A single-seat Developer/Pro could
-        // otherwise add cheap seats ($5/seat) and undercut Team (whose 10 seats are the
-        // tier differentiator); restricting it forces "need >1 seat → upgrade to Team".
-        b('seat_pack', 'Seat Pack (+5)', '5 additional member seats', { seats: 5 }, 2500, ['team', 'enterprise'], 0),
-        b('pipeline_pack', 'Pipeline Pack (+10)', '10 additional pipelines', { pipelines: 10 }, 1500, ALL, 1),
-        b('plugin_pack', 'Plugin Pack (+100)', '100 additional plugins', { plugins: 100 }, 1500, ALL, 2),
-        b('api_pack', 'API Pack (+1M)', '1,000,000 additional API calls / period', { apiCalls: 1_000_000 }, 2000, ALL, 3),
-        b('ai_pack', 'AI Pack (+5k)', '5,000 additional AI calls / period', { aiCalls: 5000 }, 7500, ALL, 4),
-        b('storage_pack', 'Storage Pack (+50 GB)', '50 GB additional registry storage', { storageBytes: 50 * BUNDLE_GB }, 2500, ALL, 5),
+        // `seat` and `pipeline_pack` are the tier differentiators, so both are Team+
+        // ONLY — a single-seat Developer/Pro can't cheaply stack seats/pipelines to
+        // undercut Team (3 seats / 6 pipelines); they must upgrade. `seat` is granular
+        // (per-seat) with volume tiers (5/15/40 → 10/20/30%). The other capacity packs
+        // (plugin/api/ai/storage) are NOT differentiators, so they stay all-tier.
+        b('seat', 'Member Seat', '1 additional member seat', { seats: 1 }, 1999, ['team', 'enterprise'], 0, { volumeTiers: [{ minQuantity: 5, discountPercent: 10 }, { minQuantity: 15, discountPercent: 20 }, { minQuantity: 40, discountPercent: 30 }] }),
+        b('pipeline_pack', 'Pipeline Pack (+5)', '5 additional pipelines', { pipelines: 5 }, 1500, ['team', 'enterprise'], 1),
+        b('plugin_pack', 'Plugin Pack (+25)', '25 additional plugins', { plugins: 25 }, 1000, ALL, 2),
+        b('api_pack', 'API Pack (+100k)', '100,000 additional API calls / period', { apiCalls: 100_000 }, 1999, ALL, 3),
+        b('ai_pack', 'AI Pack (+2.5k)', '2,500 additional AI calls / period', { aiCalls: 2500 }, 1999, ALL, 4),
+        b('storage_pack', 'Storage Pack (+10 GB)', '10 GB additional registry storage', { storageBytes: 10 * BUNDLE_GB }, 1999, ALL, 5),
         b('audit_log', 'Audit Log', 'Audit log capability', {}, 2000, ['pro'], 6, { features: ['audit_log'], stackable: false }),
         // SSO is INCLUDED in Team (see TIER_FEATURES.team), so the add-on is Pro-only.
         b('sso', 'SSO / IdP', 'SSO + up to 5 IdP configs', { idpConfigs: 5 }, 4000, ['pro'], 7, { features: ['sso'], stackable: false }),
@@ -404,4 +494,4 @@ export function assertBundleRequiresValid(bundles) {
         visit(bundle, []);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"billing-config.js","sourceRoot":"","sources":["../../src/config/billing-config.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Load billing plan configuration from environment variables.\n *\n * Per-plan prices are the most likely to vary between environments:\n *   BILLING_PLAN_{TIER}_MONTHLY / BILLING_PLAN_{TIER}_ANNUAL  (in cents)\n *\n * Optional overrides for descriptions and features:\n *   BILLING_PLAN_{TIER}_NAME          (plain string, display name)\n *   BILLING_PLAN_{TIER}_DESCRIPTION   (plain string)\n *   BILLING_PLAN_{TIER}_FEATURES      (JSON string array)\n *\n * All defaults match the original hardcoded seed data.\n */\nimport { QUOTA_TIERS, TIER_FEATURES, FEATURE_METADATA, VALID_TIERS, STANDARD_TIERS, isValidTier, type QuotaTier, type QuotaTierLimits } from '@pipeline-builder/api-core';\nimport type { BillingConfig, BillingPlanConfig, BundleConfig, ComboDiscountConfig } from './config-types.js';\n\n/** Per-unit quota deltas for a bundle — keys constrained to real quota fields\n *  (matches `BundleConfig.grants`), so a typo'd dimension fails to compile. */\ntype GrantMap = Partial<Record<keyof QuotaTierLimits, number>>;\n\n// -- Default features ---------------------------------------------------------\n// The marketed feature list is built from two derived sources so it can never\n// drift from what the platform actually enforces:\n//   1. LIMIT lines derived from each tier's EFFECTIVE quota limits (QUOTA_TIERS),\n//      so they track QUOTA_TIER_* env overrides.\n//   2. INCLUDED-FEATURE lines derived from the enforced entitlement set\n//      (TIER_FEATURES) via FEATURE_METADATA labels — so an advertised base\n//      feature is always one `requireFeature` actually grants for that tier.\n// Only genuinely non-gated marketing copy (support level, dashboards, RBAC) is\n// hand-authored, passed as `perks`. Purchasable add-ons (sso, audit_log) are NOT\n// listed as base perks here — they are sold as bundles (see loadBundles()).\n\n/** \"Up to N plugins\" / \"Unlimited plugins\" from an effective limit (-1 = unlimited). */\nfunction limitLine(limit: number, singular: string, plural: string): string {\n  if (limit === -1) return `Unlimited ${plural}`;\n  return `Up to ${limit.toLocaleString('en-US')} ${limit === 1 ? singular : plural}`;\n}\n\nfunction defaultFeatures(tier: QuotaTier, perks: string[]): string[] {\n  const l = QUOTA_TIERS[tier].limits;\n  return [\n    limitLine(l.seats, 'seat', 'seats'),\n    limitLine(l.plugins, 'plugin', 'plugins'),\n    limitLine(l.pipelines, 'pipeline', 'pipelines'),\n    limitLine(l.apiCalls, 'API call', 'API calls'),\n    limitLine(l.aiCalls, 'AI call', 'AI calls'),\n    // Enforced entitlements → customer-facing labels (single source of truth).\n    ...TIER_FEATURES[tier].map((f) => FEATURE_METADATA[f].label),\n    ...perks,\n  ];\n}\n\n// Note: `perks` are non-gated marketing lines only. Enforced features (incl.\n// Priority Support for pro/team/enterprise) come from TIER_FEATURES above.\nconst DEFAULT_DEVELOPER_FEATURES = defaultFeatures('developer', ['Community support']);\nconst DEFAULT_PRO_FEATURES = defaultFeatures('pro', ['Reporting dashboard']);\nconst DEFAULT_TEAM_FEATURES = defaultFeatures('team', ['RBAC & team roles']);\nconst DEFAULT_ENTERPRISE_FEATURES = defaultFeatures('enterprise', [\n  'RBAC & team roles', 'Reporting dashboard',\n]);\n// Unlimited includes every feature (TIER_FEATURES.unlimited = all).\nconst DEFAULT_UNLIMITED_FEATURES = defaultFeatures('unlimited', [\n  'Unlimited everything', 'RBAC & team roles', 'Reporting dashboard',\n]);\n\n/**\n * Parse a price (in cents) from an env var, falling back to the default when\n * unset OR malformed. A NaN (e.g. `BILLING_PLAN_PRO_MONTHLY=abc`) must never\n * flow into the returned config as a price.\n */\nfunction envCents(envVar: string | undefined, fallback: number): number {\n  if (envVar === undefined || envVar === '') return fallback;\n  // `parseInt` is too lenient here: '49.99'→49, '49abc'→49, '-100'→-100 would all\n  // flow through as a \"price\". Require a clean, non-negative integer (cents),\n  // matching `applyGrantOverride`'s rigor — anything else falls back.\n  const n = Number(envVar);\n  return Number.isInteger(n) && n >= 0 ? n : fallback;\n}\n\n/**\n * Parse a JSON array from an env var, falling back to default.\n */\nfunction parseFeatures(envVar: string | undefined, fallback: string[]): string[] {\n  if (!envVar) return fallback;\n  try {\n    const parsed = JSON.parse(envVar);\n    // Array-of-strings only — a JSON array of non-strings (e.g. `[1,2]`) must not\n    // ship numbers as feature labels. Filter to strings (mirrors applyTiersOverride).\n    if (!Array.isArray(parsed)) return fallback;\n    const strings = parsed.filter((x): x is string => typeof x === 'string');\n    return strings.length === parsed.length ? strings : fallback;\n  } catch {\n    return fallback;\n  }\n}\n\n/**\n * Load billing plan configuration from environment variables.\n */\nexport function loadBillingConfig(): BillingConfig {\n  // Keyed by QuotaTier so the compiler forces a plan for EVERY tier — adding a\n  // 5th QuotaTier without a plan here is now a compile error (was a hand-kept\n  // 4-element array that silently shipped no plan/price for a new tier). The\n  // public `config.plans` shape stays an array, derived below in VALID_TIERS\n  // order (developer, pro, team, enterprise, unlimited) to preserve consumer ordering.\n  const planByTier: Record<QuotaTier, BillingPlanConfig> = {\n    developer: {\n      id: 'developer',\n      name: process.env.BILLING_PLAN_DEVELOPER_NAME || 'Developer',\n      description: process.env.BILLING_PLAN_DEVELOPER_DESCRIPTION\n        || 'Free starter tier for individual developers',\n      tier: 'developer',\n      prices: {\n        monthly: envCents(process.env.BILLING_PLAN_DEVELOPER_MONTHLY, 0),\n        annual: envCents(process.env.BILLING_PLAN_DEVELOPER_ANNUAL, 0),\n      },\n      features: parseFeatures(\n        process.env.BILLING_PLAN_DEVELOPER_FEATURES,\n        DEFAULT_DEVELOPER_FEATURES,\n      ),\n      isActive: true,\n      isDefault: true,\n      sortOrder: 0,\n    },\n    pro: {\n      id: 'pro',\n      name: process.env.BILLING_PLAN_PRO_NAME || 'Pro',\n      description: process.env.BILLING_PLAN_PRO_DESCRIPTION\n        || 'For individual power users and production workloads',\n      tier: 'pro',\n      prices: {\n        monthly: envCents(process.env.BILLING_PLAN_PRO_MONTHLY, 4900),\n        annual: envCents(process.env.BILLING_PLAN_PRO_ANNUAL, 49000),\n      },\n      features: parseFeatures(\n        process.env.BILLING_PLAN_PRO_FEATURES,\n        DEFAULT_PRO_FEATURES,\n      ),\n      isActive: true,\n      isDefault: false,\n      sortOrder: 1,\n    },\n    team: {\n      id: 'team',\n      name: process.env.BILLING_PLAN_TEAM_NAME || 'Team',\n      description: process.env.BILLING_PLAN_TEAM_DESCRIPTION\n        || 'For teams collaborating on shared pipelines',\n      tier: 'team',\n      prices: {\n        monthly: envCents(process.env.BILLING_PLAN_TEAM_MONTHLY, 14900),\n        annual: envCents(process.env.BILLING_PLAN_TEAM_ANNUAL, 149000),\n      },\n      features: parseFeatures(\n        process.env.BILLING_PLAN_TEAM_FEATURES,\n        DEFAULT_TEAM_FEATURES,\n      ),\n      isActive: true,\n      isDefault: false,\n      sortOrder: 2,\n    },\n    enterprise: {\n      id: 'enterprise',\n      name: process.env.BILLING_PLAN_ENTERPRISE_NAME || 'Enterprise',\n      description: process.env.BILLING_PLAN_ENTERPRISE_DESCRIPTION\n        || 'Org-wide scale with unlimited seats and priority support',\n      tier: 'enterprise',\n      prices: {\n        monthly: envCents(process.env.BILLING_PLAN_ENTERPRISE_MONTHLY, 59900),\n        annual: envCents(process.env.BILLING_PLAN_ENTERPRISE_ANNUAL, 599000),\n      },\n      features: parseFeatures(\n        process.env.BILLING_PLAN_ENTERPRISE_FEATURES,\n        DEFAULT_ENTERPRISE_FEATURES,\n      ),\n      isActive: true,\n      isDefault: false,\n      sortOrder: 3,\n    },\n    // The billing-DISABLED default plan: everything uncapped, all features, free.\n    // Seeded so the tier→plan mapping resolves, but never offered for sale — the\n    // read-plans route filters it out (see createReadPlanRoutes), so it's hidden\n    // whenever billing is enabled (the only time /plans is served).\n    unlimited: {\n      id: 'unlimited',\n      name: process.env.BILLING_PLAN_UNLIMITED_NAME || 'Unlimited',\n      description: process.env.BILLING_PLAN_UNLIMITED_DESCRIPTION\n        || 'Everything uncapped — the default when billing is disabled',\n      tier: 'unlimited',\n      prices: {\n        monthly: envCents(process.env.BILLING_PLAN_UNLIMITED_MONTHLY, 0),\n        annual: envCents(process.env.BILLING_PLAN_UNLIMITED_ANNUAL, 0),\n      },\n      features: parseFeatures(\n        process.env.BILLING_PLAN_UNLIMITED_FEATURES,\n        DEFAULT_UNLIMITED_FEATURES,\n      ),\n      isActive: true,\n      isDefault: false,\n      sortOrder: 4,\n    },\n  };\n\n  // Derive the array consumers read (`config.plans`) in canonical tier order.\n  const plans: BillingPlanConfig[] = VALID_TIERS.map((tier) => planByTier[tier]);\n\n  // Build bundles ONCE and thread them into the combo loader (which needs their\n  // env-effective prices) — avoids parsing the whole bundle catalog twice per load.\n  const bundles = loadBundles();\n  return { plans, bundles, comboDiscounts: loadComboDiscounts(bundles) };\n}\n\n/**\n * Combo discounts (docs/billing-bundles.md §Combo pricing). When an account owns\n * every member bundle (each at ≥ its minimum quantity), the set is billed at the\n * combined price instead of the sum of the members — realized as a recurring usage\n * credit for the difference. Overlapping combos are resolved by max-weight packing\n * (a shared add-on is never discounted twice); `sortOrder` breaks equal-total ties.\n *\n * Defaults:\n *  - \"Analytics Suite\" — Advanced Reporting (DORA) + Team Usage Analytics, each\n *    $30/mo, together $42/mo ($420/yr) → a $18/mo credit (~30% off).\n *  - \"Team Growth Bundle\" — ≥1 Seat Pack ($25) + Team Usage Analytics ($30),\n *    together $38.50/mo ($385/yr) → a $16.50/mo credit (~30% off).\n * Prices env-overridable via `BILLING_COMBO_<ID>_MONTHLY` / `_ANNUAL`.\n */\nfunction loadComboDiscounts(bundles: BundleConfig[]): ComboDiscountConfig[] {\n  const c = (\n    id: string,\n    name: string,\n    bundleIds: string[],\n    monthly: number,\n    annual: number,\n    sortOrder: number,\n    minQuantities?: Record<string, number>,\n  ): ComboDiscountConfig => ({\n    id,\n    name,\n    bundleIds,\n    ...(minQuantities ? { minQuantities } : {}),\n    prices: {\n      monthly: envCents(process.env[`BILLING_COMBO_${id.toUpperCase()}_MONTHLY`], monthly),\n      annual: envCents(process.env[`BILLING_COMBO_${id.toUpperCase()}_ANNUAL`], annual),\n    },\n    sortOrder,\n    isActive: true,\n  });\n\n  const combos = [\n    c('analytics_suite', 'Analytics Suite', ['advanced_reporting', 'team_usage_analytics'], 4200, 42000, 0),\n    c('team_growth', 'Team Growth Bundle', ['seat_pack', 'team_usage_analytics'], 3850, 38500, 1, { seat_pack: 1 }),\n    // Compliance Suite — Standard + Advanced at 30% off ($908.60/yr vs $1,298 list).\n    c('compliance_suite', 'Compliance Suite', ['compliance_standard', 'compliance_advanced'], 9086, 90860, 2),\n  ];\n  warnOnNonDiscountCombos(combos, bundles);\n  return combos;\n}\n\n/**\n * Guardrail: a combo whose combined price is ≥ its minimum-composition basket grants\n * no credit (the credit clamps to $0) and is silently inert. Warn loudly instead so a\n * misconfigured `BILLING_COMBO_*` override is caught. Non-fatal.\n */\nfunction warnOnNonDiscountCombos(combos: ComboDiscountConfig[], bundles: BundleConfig[]): void {\n  // Combo members are always bundles; resolve their (env-effective) unit prices once.\n  const byId = new Map(bundles.map((b) => [b.id, b]));\n  for (const combo of combos) {\n    for (const interval of ['monthly', 'annual'] as const) {\n      const basket = combo.bundleIds.reduce((s, id) => s + (byId.get(id)?.prices[interval] ?? 0) * (combo.minQuantities?.[id] ?? 1), 0);\n      if (combo.prices[interval] >= basket) {\n        // eslint-disable-next-line no-console\n        console.warn(`[billing-config] Combo \"${combo.id}\" ${interval} price ${combo.prices[interval]} ≥ member basket ${basket}; it grants no discount.`);\n      }\n    }\n  }\n}\n\nconst BUNDLE_GB = 1024 * 1024 * 1024;\n\n/**\n * Apply a per-bundle grant override. Each stackable pack grants exactly one\n * quota dimension, so `BILLING_BUNDLE_<ID>_GRANT` retunes that amount (e.g. make\n * the Seat Pack grant +10 instead of +5) — parallel to the price overrides.\n * Ignored for multi-dimension or feature-only (empty-grant) bundles, and for a\n * malformed/negative value.\n */\nfunction applyGrantOverride(id: string, grants: GrantMap): GrantMap {\n  const raw = process.env[`BILLING_BUNDLE_${id.toUpperCase()}_GRANT`];\n  const keys = Object.keys(grants);\n  if (raw === undefined || raw === '' || keys.length !== 1) return grants;\n  const n = parseInt(raw, 10);\n  if (Number.isNaN(n) || n < 0) return grants;\n  // `keys` came from a GrantMap, so its sole key is a QuotaTierLimits field.\n  return { [keys[0] as keyof QuotaTierLimits]: n };\n}\n\n/**\n * Apply a per-bundle tier-availability override. `BILLING_BUNDLE_<ID>_TIERS` is a\n * JSON array of tier IDs that may purchase the bundle (e.g. `[\"developer\",\"pro\"]`)\n * — parallel to the price/grant overrides. Falls back to `defaultTiers` when\n * unset, malformed, empty, or containing an unknown tier.\n */\nfunction applyTiersOverride(id: string, defaultTiers: QuotaTier[]): QuotaTier[] {\n  const raw = process.env[`BILLING_BUNDLE_${id.toUpperCase()}_TIERS`];\n  if (!raw) return defaultTiers;\n  try {\n    const parsed = JSON.parse(raw);\n    if (!Array.isArray(parsed) || parsed.length === 0) return defaultTiers;\n    const valid = parsed.filter((t): t is QuotaTier => typeof t === 'string' && isValidTier(t));\n    return valid.length === parsed.length ? valid : defaultTiers;\n  } catch {\n    return defaultTiers;\n  }\n}\n\n/**\n * Purchasable add-on bundles (docs/billing-bundles.md §3). Grants are per-unit\n * deltas on QuotaTierLimits; prices (cents, `BILLING_BUNDLE_<ID>_MONTHLY` /\n * `_ANNUAL`), the single-dimension grant amount (`BILLING_BUNDLE_<ID>_GRANT`),\n * and the purchasable-tier list (`BILLING_BUNDLE_<ID>_TIERS`) are all\n * env-overridable. Annual ≈ 10× monthly.\n */\nfunction loadBundles(): BundleConfig[] {\n  const b = (\n    id: string,\n    name: string,\n    description: string,\n    grants: GrantMap,\n    monthly: number,\n    availableForTiers: QuotaTier[],\n    sortOrder: number,\n    extra: { features?: string[]; stackable?: boolean; maxQuantity?: number; requires?: string[] } = {},\n  ): BundleConfig => {\n    // Resolve monthly first so the annual fallback tracks a `_MONTHLY` override\n    // (annual ≈ 10× the *effective* monthly, not the hardcoded default).\n    const resolvedMonthly = envCents(process.env[`BILLING_BUNDLE_${id.toUpperCase()}_MONTHLY`], monthly);\n    return {\n      id,\n      name,\n      description,\n      grants: applyGrantOverride(id, grants),\n      ...(extra.features ? { features: extra.features } : {}),\n      ...(extra.maxQuantity !== undefined ? { maxQuantity: extra.maxQuantity } : {}),\n      ...(extra.requires ? { requires: extra.requires } : {}),\n      prices: {\n        monthly: resolvedMonthly,\n        annual: envCents(process.env[`BILLING_BUNDLE_${id.toUpperCase()}_ANNUAL`], resolvedMonthly * 10),\n      },\n      stackable: extra.stackable ?? true,\n      availableForTiers: applyTiersOverride(id, availableForTiers),\n      isActive: true,\n      sortOrder,\n    };\n  };\n\n  // Bundles are purchasable on every SELECTABLE tier (excludes `unlimited`, which\n  // is the billing-off tier and buys nothing) — so this is exactly STANDARD_TIERS.\n  const ALL: QuotaTier[] = [...STANDARD_TIERS];\n  const bundles: BundleConfig[] = [\n    // Capacity packs (pipelines/plugins) are available on EVERY tier so any\n    // account — including free (developer) — can expand in place. Feature bundles\n    // (audit_log/sso) and rate packs stay tier-scoped by default.\n    // Seat Pack is the EXCEPTION — Team+ only. A single-seat Developer/Pro could\n    // otherwise add cheap seats ($5/seat) and undercut Team (whose 10 seats are the\n    // tier differentiator); restricting it forces \"need >1 seat → upgrade to Team\".\n    b('seat_pack', 'Seat Pack (+5)', '5 additional member seats', { seats: 5 }, 2500, ['team', 'enterprise'], 0),\n    b('pipeline_pack', 'Pipeline Pack (+10)', '10 additional pipelines', { pipelines: 10 }, 1500, ALL, 1),\n    b('plugin_pack', 'Plugin Pack (+100)', '100 additional plugins', { plugins: 100 }, 1500, ALL, 2),\n    b('api_pack', 'API Pack (+1M)', '1,000,000 additional API calls / period', { apiCalls: 1_000_000 }, 2000, ALL, 3),\n    b('ai_pack', 'AI Pack (+5k)', '5,000 additional AI calls / period', { aiCalls: 5000 }, 7500, ALL, 4),\n    b('storage_pack', 'Storage Pack (+50 GB)', '50 GB additional registry storage', { storageBytes: 50 * BUNDLE_GB }, 2500, ALL, 5),\n    b('audit_log', 'Audit Log', 'Audit log capability', {}, 2000, ['pro'], 6, { features: ['audit_log'], stackable: false }),\n    // SSO is INCLUDED in Team (see TIER_FEATURES.team), so the add-on is Pro-only.\n    b('sso', 'SSO / IdP', 'SSO + up to 5 IdP configs', { idpConfigs: 5 }, 4000, ['pro'], 7, { features: ['sso'], stackable: false }),\n    // DORA / advanced delivery analytics. INCLUDED in Enterprise (TIER_FEATURES),\n    // so the add-on is offered to every other tier (developer/pro/team). Priced\n    // between Audit Log ($20) and SSO ($40) — a higher-value, actively-used\n    // analytics surface than the audit log, but below the SSO enterprise gate.\n    b('advanced_reporting', 'Advanced Reporting (DORA)', 'DORA delivery metrics — deployment frequency, change failure rate, MTTR, lead-time proxy, performance bands + trend', {}, 3000, ['developer', 'pro', 'team'], 8, { features: ['advanced_reporting'], stackable: false }),\n    // Per-team usage breakdown across the org → team subtree. INCLUDED in\n    // Enterprise (TIER_FEATURES); the add-on is offered to Pro/Team (developer has\n    // no teams to break down). Priced at $30/mo ($300/yr) — parity with DORA, its\n    // analytics sibling. Overridable via BILLING_BUNDLE_TEAM_USAGE_ANALYTICS_MONTHLY/_ANNUAL.\n    b('team_usage_analytics', 'Team Usage Analytics', 'Per-team usage breakdown across the org → team subtree (all quota dimensions)', {}, 3000, ['pro', 'team'], 9, { features: ['team_usage_analytics'], stackable: false }),\n    // Retention packs (docs/billing-bundles.md). Stackable capacity packs that\n    // raise the reporting retention entitlement billing syncs to reporting's\n    // `dora_settings`. NOT quota-metered flow — `eventRetentionDays`/`doraRetentionDays`\n    // are absent from VALID_QUOTA_TYPES, so they never ride the quota-service leg.\n    // Standard Retention Pack: +90d standard-event retention (base 30 → 120 → 210…).\n    // Capped at 7 (30 + 7×90 = 660 ≤ the 730-day retention ceiling).\n    b('retention_pack', 'Standard Retention Pack (+90d)', '90 additional days of standard pipeline-event retention', { eventRetentionDays: 90 }, 1500, ALL, 10, { maxQuantity: 7 }),\n    // DORA History Pack: +365d DORA retention AND per-org report-query window (the\n    // window cap tracks doraRetentionDays). Only meaningful with Advanced Reporting\n    // — INCLUDED in Enterprise, an add-on on developer/pro/team. Capped at 1\n    // (180 + 365 = 545 ≤ the 730-day retention ceiling).\n    b('dora_history_pack', 'DORA History Pack (+365d)', '365 additional days of DORA history + report-query window (requires Advanced Reporting)', { doraRetentionDays: 365 }, 3000, ALL, 11, { maxQuantity: 1 }),\n    // Compliance content add-ons (docs/plans/compliance-addons.md). Feature bundles\n    // gating access to curated system-org published rule sets. INCLUDED in\n    // Enterprise/Unlimited (via ALL_FEATURE_FLAGS); sold to Developer/Pro/Team.\n    // Standard = ~20 CI/CD best-practice rules. Advanced = SOC2/PCI/CIS framework\n    // libraries; REQUIRES Standard (or buy the Suite combo for both at 30% off).\n    b('compliance_standard', 'Standard Compliance', 'Curated CI/CD best-practice compliance rules', {}, 2990, ['developer', 'pro', 'team'], 12, { features: ['compliance_standard'], stackable: false }),\n    b('compliance_advanced', 'Advanced Compliance', 'Curated framework compliance libraries (SOC2 / PCI-DSS / CIS)', {}, 9990, ['developer', 'pro', 'team'], 13, { features: ['compliance_advanced'], stackable: false, requires: ['compliance_standard'] }),\n  ];\n  assertBundleRequiresValid(bundles);\n  return bundles;\n}\n\n/**\n * Config-load guardrail for the `requires` prerequisite graph. A `requires` entry\n * that doesn't resolve to an ACTIVE bundle — or that participates in a cycle —\n * silently makes the referencing bundle unpurchasable (the addon route rejects\n * with 400 forever because the prerequisite can never be satisfied). Catch it at\n * load with a clear error rather than shipping a dead SKU.\n *\n *  - Every id in a bundle's `requires` MUST name an active bundle in the catalog.\n *  - The `requires` graph MUST be acyclic (a → b → a can never be satisfied).\n */\nexport function assertBundleRequiresValid(bundles: BundleConfig[]): void {\n  const active = new Map(bundles.filter((b) => b.isActive).map((b) => [b.id, b]));\n\n  // 1. Validity: every requires id resolves to an active bundle.\n  for (const bundle of bundles) {\n    for (const reqId of bundle.requires ?? []) {\n      if (!active.has(reqId)) {\n        throw new Error(\n          `[billing-config] Bundle \"${bundle.id}\" requires \"${reqId}\", which is not an active bundle in the catalog — it would be permanently unpurchasable.`,\n        );\n      }\n    }\n  }\n\n  // 2. Acyclicity: DFS over the requires edges, tracking the current path.\n  const VISITING = 1;\n  const DONE = 2;\n  const state = new Map<string, number>();\n\n  const visit = (id: string, path: string[]): void => {\n    const s = state.get(id);\n    if (s === DONE) return;\n    if (s === VISITING) {\n      const cycle = [...path.slice(path.indexOf(id)), id].join(' -> ');\n      throw new Error(`[billing-config] Bundle \"requires\" cycle detected: ${cycle}.`);\n    }\n    state.set(id, VISITING);\n    for (const reqId of active.get(id)?.requires ?? []) {\n      visit(reqId, [...path, id]);\n    }\n    state.set(id, DONE);\n  };\n\n  for (const bundle of active.keys()) {\n    visit(bundle, []);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"billing-config.js","sourceRoot":"","sources":["../../src/config/billing-config.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Load billing plan configuration from environment variables.\n *\n * Per-plan prices are the most likely to vary between environments:\n *   BILLING_PLAN_{TIER}_MONTHLY / BILLING_PLAN_{TIER}_ANNUAL  (in cents)\n *\n * Optional overrides for descriptions and features:\n *   BILLING_PLAN_{TIER}_NAME          (plain string, display name)\n *   BILLING_PLAN_{TIER}_DESCRIPTION   (plain string)\n *   BILLING_PLAN_{TIER}_FEATURES      (JSON string array)\n *\n * All defaults match the original hardcoded seed data.\n */\nimport { QUOTA_TIERS, TIER_FEATURES, FEATURE_METADATA, VALID_TIERS, STANDARD_TIERS, isValidTier, type QuotaTier, type QuotaTierLimits } from '@pipeline-builder/api-core';\nimport type { BillingConfig, BillingPlanConfig, BundleConfig, ComboDiscountConfig } from './config-types.js';\n\n/** Per-unit quota deltas for a bundle — keys constrained to real quota fields\n *  (matches `BundleConfig.grants`), so a typo'd dimension fails to compile. */\ntype GrantMap = Partial<Record<keyof QuotaTierLimits, number>>;\n\n// -- Default features ---------------------------------------------------------\n// The marketed feature list is built from two derived sources so it can never\n// drift from what the platform actually enforces:\n//   1. LIMIT lines derived from each tier's EFFECTIVE quota limits (QUOTA_TIERS),\n//      so they track QUOTA_TIER_* env overrides.\n//   2. INCLUDED-FEATURE lines derived from the enforced entitlement set\n//      (TIER_FEATURES) via FEATURE_METADATA labels — so an advertised base\n//      feature is always one `requireFeature` actually grants for that tier.\n// Only genuinely non-gated marketing copy (support level, dashboards, RBAC) is\n// hand-authored, passed as `perks`. Purchasable add-ons (sso, audit_log) are NOT\n// listed as base perks here — they are sold as bundles (see loadBundles()).\n\n/** \"Up to N plugins\" / \"Unlimited plugins\" from an effective limit (-1 = unlimited). */\nfunction limitLine(limit: number, singular: string, plural: string): string {\n  if (limit === -1) return `Unlimited ${plural}`;\n  return `Up to ${limit.toLocaleString('en-US')} ${limit === 1 ? singular : plural}`;\n}\n\nfunction defaultFeatures(tier: QuotaTier, perks: string[]): string[] {\n  const l = QUOTA_TIERS[tier].limits;\n  return [\n    limitLine(l.seats, 'seat', 'seats'),\n    limitLine(l.plugins, 'plugin', 'plugins'),\n    limitLine(l.pipelines, 'pipeline', 'pipelines'),\n    limitLine(l.apiCalls, 'API call', 'API calls'),\n    limitLine(l.aiCalls, 'AI call', 'AI calls'),\n    // Enforced entitlements → customer-facing labels (single source of truth).\n    ...TIER_FEATURES[tier].map((f) => FEATURE_METADATA[f].label),\n    ...perks,\n  ];\n}\n\n// Note: `perks` are non-gated marketing lines only. Enforced features (incl.\n// Priority Support for pro/team/enterprise) come from TIER_FEATURES above.\nconst DEFAULT_DEVELOPER_FEATURES = defaultFeatures('developer', ['Community support']);\nconst DEFAULT_PRO_FEATURES = defaultFeatures('pro', ['Reporting dashboard']);\nconst DEFAULT_TEAM_FEATURES = defaultFeatures('team', ['RBAC & team roles']);\nconst DEFAULT_ENTERPRISE_FEATURES = defaultFeatures('enterprise', [\n  'RBAC & team roles', 'Reporting dashboard',\n]);\n// Unlimited includes every feature (TIER_FEATURES.unlimited = all).\nconst DEFAULT_UNLIMITED_FEATURES = defaultFeatures('unlimited', [\n  'Unlimited everything', 'RBAC & team roles', 'Reporting dashboard',\n]);\n\n/**\n * Parse a price (in cents) from an env var, falling back to the default when\n * unset OR malformed. A NaN (e.g. `BILLING_PLAN_PRO_MONTHLY=abc`) must never\n * flow into the returned config as a price.\n */\nfunction envCents(envVar: string | undefined, fallback: number): number {\n  if (envVar === undefined || envVar === '') return fallback;\n  // `parseInt` is too lenient here: '49.99'→49, '49abc'→49, '-100'→-100 would all\n  // flow through as a \"price\". Require a clean, non-negative integer (cents),\n  // matching `applyGrantOverride`'s rigor — anything else falls back.\n  const n = Number(envVar);\n  return Number.isInteger(n) && n >= 0 ? n : fallback;\n}\n\n/**\n * Parse a JSON array from an env var, falling back to default.\n */\nfunction parseFeatures(envVar: string | undefined, fallback: string[]): string[] {\n  if (!envVar) return fallback;\n  try {\n    const parsed = JSON.parse(envVar);\n    // Array-of-strings only — a JSON array of non-strings (e.g. `[1,2]`) must not\n    // ship numbers as feature labels. Filter to strings (mirrors applyTiersOverride).\n    if (!Array.isArray(parsed)) return fallback;\n    const strings = parsed.filter((x): x is string => typeof x === 'string');\n    return strings.length === parsed.length ? strings : fallback;\n  } catch {\n    return fallback;\n  }\n}\n\n/**\n * Load billing plan configuration from environment variables.\n */\nexport function loadBillingConfig(): BillingConfig {\n  // Keyed by QuotaTier so the compiler forces a plan for EVERY tier — adding a\n  // 5th QuotaTier without a plan here is now a compile error (was a hand-kept\n  // 4-element array that silently shipped no plan/price for a new tier). The\n  // public `config.plans` shape stays an array, derived below in VALID_TIERS\n  // order (developer, pro, team, enterprise, unlimited) to preserve consumer ordering.\n  const planByTier: Record<QuotaTier, BillingPlanConfig> = {\n    developer: {\n      id: 'developer',\n      name: process.env.BILLING_PLAN_DEVELOPER_NAME || 'Developer',\n      description: process.env.BILLING_PLAN_DEVELOPER_DESCRIPTION\n        || 'Free starter tier for individual developers',\n      tier: 'developer',\n      prices: {\n        monthly: envCents(process.env.BILLING_PLAN_DEVELOPER_MONTHLY, 0),\n        annual: envCents(process.env.BILLING_PLAN_DEVELOPER_ANNUAL, 0),\n      },\n      features: parseFeatures(\n        process.env.BILLING_PLAN_DEVELOPER_FEATURES,\n        DEFAULT_DEVELOPER_FEATURES,\n      ),\n      isActive: true,\n      isDefault: true,\n      sortOrder: 0,\n    },\n    pro: {\n      id: 'pro',\n      name: process.env.BILLING_PLAN_PRO_NAME || 'Pro',\n      description: process.env.BILLING_PLAN_PRO_DESCRIPTION\n        || 'For individual power users and production workloads',\n      tier: 'pro',\n      prices: {\n        monthly: envCents(process.env.BILLING_PLAN_PRO_MONTHLY, 3900),\n        annual: envCents(process.env.BILLING_PLAN_PRO_ANNUAL, 39000),\n      },\n      features: parseFeatures(\n        process.env.BILLING_PLAN_PRO_FEATURES,\n        DEFAULT_PRO_FEATURES,\n      ),\n      isActive: true,\n      isDefault: false,\n      sortOrder: 1,\n    },\n    team: {\n      id: 'team',\n      name: process.env.BILLING_PLAN_TEAM_NAME || 'Team',\n      description: process.env.BILLING_PLAN_TEAM_DESCRIPTION\n        || 'For teams collaborating on shared pipelines',\n      tier: 'team',\n      prices: {\n        monthly: envCents(process.env.BILLING_PLAN_TEAM_MONTHLY, 7900),\n        annual: envCents(process.env.BILLING_PLAN_TEAM_ANNUAL, 79000),\n      },\n      features: parseFeatures(\n        process.env.BILLING_PLAN_TEAM_FEATURES,\n        DEFAULT_TEAM_FEATURES,\n      ),\n      isActive: true,\n      isDefault: false,\n      sortOrder: 2,\n    },\n    enterprise: {\n      id: 'enterprise',\n      name: process.env.BILLING_PLAN_ENTERPRISE_NAME || 'Enterprise',\n      description: process.env.BILLING_PLAN_ENTERPRISE_DESCRIPTION\n        || 'Org-wide scale with a high seat baseline (expandable via Member Seat add-ons) and priority support',\n      tier: 'enterprise',\n      prices: {\n        monthly: envCents(process.env.BILLING_PLAN_ENTERPRISE_MONTHLY, 59900),\n        annual: envCents(process.env.BILLING_PLAN_ENTERPRISE_ANNUAL, 599000),\n      },\n      features: parseFeatures(\n        process.env.BILLING_PLAN_ENTERPRISE_FEATURES,\n        DEFAULT_ENTERPRISE_FEATURES,\n      ),\n      isActive: true,\n      isDefault: false,\n      sortOrder: 3,\n    },\n    // The billing-DISABLED default plan: everything uncapped, all features, free.\n    // Seeded so the tier→plan mapping resolves, but never offered for sale — the\n    // read-plans route filters it out (see createReadPlanRoutes), so it's hidden\n    // whenever billing is enabled (the only time /plans is served).\n    unlimited: {\n      id: 'unlimited',\n      name: process.env.BILLING_PLAN_UNLIMITED_NAME || 'Unlimited',\n      description: process.env.BILLING_PLAN_UNLIMITED_DESCRIPTION\n        || 'Everything uncapped — the default when billing is disabled',\n      tier: 'unlimited',\n      prices: {\n        monthly: envCents(process.env.BILLING_PLAN_UNLIMITED_MONTHLY, 0),\n        annual: envCents(process.env.BILLING_PLAN_UNLIMITED_ANNUAL, 0),\n      },\n      features: parseFeatures(\n        process.env.BILLING_PLAN_UNLIMITED_FEATURES,\n        DEFAULT_UNLIMITED_FEATURES,\n      ),\n      isActive: true,\n      isDefault: false,\n      sortOrder: 4,\n    },\n  };\n\n  // Derive the array consumers read (`config.plans`) in canonical tier order.\n  const plans: BillingPlanConfig[] = VALID_TIERS.map((tier) => planByTier[tier]);\n\n  // Build bundles ONCE and thread them into the combo loader (which needs their\n  // env-effective prices) — avoids parsing the whole bundle catalog twice per load.\n  const bundles = loadBundles();\n  return { plans, bundles, comboDiscounts: loadComboDiscounts(bundles) };\n}\n\n/**\n * Combo discounts (docs/billing-bundles.md §Combo pricing). When an account owns\n * every member bundle (each at ≥ its minimum quantity), the set is billed at the\n * combined price instead of the sum of the members — realized as a recurring usage\n * credit for the difference. Overlapping combos are resolved by max-weight packing\n * (a shared add-on is never discounted twice); `sortOrder` breaks equal-total ties.\n *\n * Defaults:\n *  - \"Analytics Suite\" — Advanced Reporting (DORA) + Team Usage Analytics, each\n *    $30/mo, together $42/mo ($420/yr) → a $18/mo credit (~30% off).\n *  - \"Team Growth Bundle\" — ≥5 Seats ($19.99 ea) + Team Usage Analytics ($30),\n *    basket $129.95/mo → together $90.99/mo ($909.90/yr) → a ~$38.96/mo credit (~30% off).\n *  - \"Scale Bundle\" — API Pack ($19.99) + Storage Pack ($19.99), basket $39.98/mo\n *    → together $27.99/mo ($279.90/yr) → a ~$11.99/mo credit (~30% off).\n * Prices env-overridable via `BILLING_COMBO_<ID>_MONTHLY` / `_ANNUAL`.\n */\nfunction loadComboDiscounts(bundles: BundleConfig[]): ComboDiscountConfig[] {\n  const c = (\n    id: string,\n    name: string,\n    bundleIds: string[],\n    monthly: number,\n    annual: number,\n    sortOrder: number,\n    minQuantities?: Record<string, number>,\n  ): ComboDiscountConfig => ({\n    id,\n    name,\n    bundleIds,\n    ...(minQuantities ? { minQuantities } : {}),\n    prices: {\n      monthly: envCents(process.env[`BILLING_COMBO_${id.toUpperCase()}_MONTHLY`], monthly),\n      annual: envCents(process.env[`BILLING_COMBO_${id.toUpperCase()}_ANNUAL`], annual),\n    },\n    sortOrder,\n    isActive: true,\n  });\n\n  const combos = [\n    c('analytics_suite', 'Analytics Suite', ['advanced_reporting', 'team_usage_analytics'], 4200, 42000, 0),\n    // Team Growth — ≥5 Seats ($19.99 ea) + Team Usage Analytics ($30). Basket\n    // 5×$19.99 + $30 = $129.95/mo → bundled $90.99/mo (~30% off, ~$38.96 credit).\n    c('team_growth', 'Team Growth Bundle', ['seat', 'team_usage_analytics'], 9099, 90990, 1, { seat: 5 }),\n    // Compliance Suite — Standard + Advanced at 30% off ($908.60/yr vs $1,298 list).\n    c('compliance_suite', 'Compliance Suite', ['compliance_standard', 'compliance_advanced'], 9086, 90860, 2),\n    // Scale Bundle — API Pack ($19.99) + Storage Pack ($19.99). Basket $39.98/mo →\n    // bundled $27.99/mo (~30% off, ~$11.99 credit). Both members all-tier.\n    c('scale_bundle', 'Scale Bundle', ['api_pack', 'storage_pack'], 2799, 27990, 3),\n  ];\n  assertCombosValid(combos, bundles);\n  warnOnNonDiscountCombos(combos, bundles);\n  return combos;\n}\n\n/**\n * Config-load guardrail for combos: every `bundleId` must resolve to an ACTIVE\n * bundle and every `minQuantities` key must be one of the combo's `bundleIds`.\n * A typo'd member or stray minQuantity key otherwise ships a permanently-inert\n * combo (missing bundle treated as unit price 0, or a min never satisfiable),\n * silently never applying. Throws so misconfig fails fast at boot.\n */\nexport function assertCombosValid(combos: ComboDiscountConfig[], bundles: BundleConfig[]): void {\n  const activeIds = new Set(bundles.filter((b) => b.isActive).map((b) => b.id));\n  for (const combo of combos) {\n    for (const id of combo.bundleIds) {\n      if (!activeIds.has(id)) {\n        throw new Error(`Combo \"${combo.id}\" references bundle \"${id}\", which is not an active bundle.`);\n      }\n    }\n    for (const key of Object.keys(combo.minQuantities ?? {})) {\n      if (!combo.bundleIds.includes(key)) {\n        throw new Error(`Combo \"${combo.id}\" minQuantities key \"${key}\" is not one of its bundleIds.`);\n      }\n    }\n  }\n}\n\n/** The volume-discount percent applying to `quantity` units of a bundle — the\n *  highest `volumeTiers` entry whose `minQuantity ≤ quantity`, else 0. Mirrors\n *  `volumeDiscountPct` in api/billing's combo-pricing (which can't be imported the\n *  other way); the combo credit math and this guardrail MUST use the same basis. */\nfunction volumeDiscountPctAt(bundle: BundleConfig | undefined, quantity: number): number {\n  let pct = 0;\n  for (const t of bundle?.volumeTiers ?? []) if (quantity >= t.minQuantity) pct = t.discountPercent;\n  return pct;\n}\n\n/**\n * Guardrail: a combo whose combined price is ≥ its minimum-composition basket grants\n * no credit (the credit clamps to $0) and is silently inert. Warn loudly instead so a\n * misconfigured `BILLING_COMBO_*` override is caught. Non-fatal.\n */\nfunction warnOnNonDiscountCombos(combos: ComboDiscountConfig[], bundles: BundleConfig[]): void {\n  // Combo members are always bundles; resolve their (env-effective) unit prices once.\n  const byId = new Map(bundles.map((b) => [b.id, b]));\n  for (const combo of combos) {\n    for (const interval of ['monthly', 'annual'] as const) {\n      // Post-volume basis (mirrors `comboBasisCents`): a member with volume tiers is\n      // basised on its DISCOUNTED unit at the combo's minQty, so this guardrail can't\n      // silently miss a combo that grants no real credit once volume is applied.\n      const basket = combo.bundleIds.reduce((s, id) => {\n        const b = byId.get(id);\n        const qty = combo.minQuantities?.[id] ?? 1;\n        const rawUnit = b?.prices[interval] ?? 0;\n        const unit = Math.round((rawUnit * (100 - volumeDiscountPctAt(b, qty))) / 100);\n        return s + unit * qty;\n      }, 0);\n      if (combo.prices[interval] >= basket) {\n        // eslint-disable-next-line no-console\n        console.warn(`[billing-config] Combo \"${combo.id}\" ${interval} price ${combo.prices[interval]} ≥ member basket ${basket}; it grants no discount.`);\n      }\n    }\n  }\n}\n\nconst BUNDLE_GB = 1024 * 1024 * 1024;\n\n/**\n * Apply a per-bundle grant override. Each stackable pack grants exactly one\n * quota dimension, so `BILLING_BUNDLE_<ID>_GRANT` retunes that amount (e.g. make\n * the Plugin Pack grant +50 instead of +25) — parallel to the price overrides.\n * Ignored for multi-dimension or feature-only (empty-grant) bundles, and for a\n * malformed/negative value.\n */\nfunction applyGrantOverride(id: string, grants: GrantMap): GrantMap {\n  const raw = process.env[`BILLING_BUNDLE_${id.toUpperCase()}_GRANT`];\n  const keys = Object.keys(grants);\n  if (raw === undefined || raw === '' || keys.length !== 1) return grants;\n  const n = parseInt(raw, 10);\n  if (Number.isNaN(n) || n < 0) return grants;\n  // `keys` came from a GrantMap, so its sole key is a QuotaTierLimits field.\n  return { [keys[0] as keyof QuotaTierLimits]: n };\n}\n\n/**\n * Apply a per-bundle tier-availability override. `BILLING_BUNDLE_<ID>_TIERS` is a\n * JSON array of tier IDs that may purchase the bundle (e.g. `[\"developer\",\"pro\"]`)\n * — parallel to the price/grant overrides. Falls back to `defaultTiers` when\n * unset, malformed, empty, or containing an unknown tier.\n */\nfunction applyTiersOverride(id: string, defaultTiers: QuotaTier[]): QuotaTier[] {\n  const raw = process.env[`BILLING_BUNDLE_${id.toUpperCase()}_TIERS`];\n  if (!raw) return defaultTiers;\n  try {\n    const parsed = JSON.parse(raw);\n    if (!Array.isArray(parsed) || parsed.length === 0) return defaultTiers;\n    const valid = parsed.filter((t): t is QuotaTier => typeof t === 'string' && isValidTier(t));\n    return valid.length === parsed.length ? valid : defaultTiers;\n  } catch {\n    return defaultTiers;\n  }\n}\n\ntype VolumeTier = { minQuantity: number; discountPercent: number };\n\n/**\n * Apply a per-bundle volume-tier override. `BILLING_BUNDLE_<ID>_VOLUME_TIERS` is a\n * JSON array of `{ minQuantity, discountPercent }` (e.g.\n * `[{\"minQuantity\":5,\"discountPercent\":10}]`) — parallel to the price/grant/tier\n * overrides. Falls back to `defaultTiers` when unset, malformed, or containing an\n * invalid entry (minQuantity ≥ 1, 0 < discountPercent ≤ 100). Sorted ascending by\n * minQuantity so the \"highest matching tier wins\" lookup is deterministic.\n */\nfunction applyVolumeTiersOverride(id: string, defaultTiers?: VolumeTier[]): VolumeTier[] | undefined {\n  const raw = process.env[`BILLING_BUNDLE_${id.toUpperCase()}_VOLUME_TIERS`];\n  const sortAsc = (t: VolumeTier[]) => [...t].sort((a, b) => a.minQuantity - b.minQuantity);\n  const fallback = () => (defaultTiers ? sortAsc(defaultTiers) : undefined);\n  if (!raw) return fallback();\n  try {\n    const parsed = JSON.parse(raw);\n    if (!Array.isArray(parsed) || parsed.length === 0) return fallback();\n    // Each entry: integer minQuantity ≥ 1, 0 < discountPercent ≤ 100.\n    const valid = parsed.filter((t): t is VolumeTier =>\n      t && typeof t.minQuantity === 'number' && Number.isInteger(t.minQuantity) && t.minQuantity >= 1\n      && typeof t.discountPercent === 'number' && t.discountPercent > 0 && t.discountPercent <= 100);\n    if (valid.length !== parsed.length) return fallback();\n    const sorted = sortAsc(valid);\n    // Reject a non-monotonic curve: buying MORE must never earn a SMALLER discount,\n    // and duplicate thresholds are ambiguous. (`volumeDiscountPct` picks the last\n    // qualifying tier, so a descending percent would penalize higher quantities.)\n    for (let i = 1; i < sorted.length; i++) {\n      if (sorted[i].minQuantity === sorted[i - 1].minQuantity) return fallback();\n      if (sorted[i].discountPercent <= sorted[i - 1].discountPercent) return fallback();\n    }\n    return sorted;\n  } catch {\n    return fallback();\n  }\n}\n\n/**\n * Purchasable add-on bundles (docs/billing-bundles.md §3). Grants are per-unit\n * deltas on QuotaTierLimits; prices (cents, `BILLING_BUNDLE_<ID>_MONTHLY` /\n * `_ANNUAL`), the single-dimension grant amount (`BILLING_BUNDLE_<ID>_GRANT`),\n * and the purchasable-tier list (`BILLING_BUNDLE_<ID>_TIERS`) are all\n * env-overridable. Annual ≈ 10× monthly.\n */\nfunction loadBundles(): BundleConfig[] {\n  const b = (\n    id: string,\n    name: string,\n    description: string,\n    grants: GrantMap,\n    monthly: number,\n    availableForTiers: QuotaTier[],\n    sortOrder: number,\n    extra: { features?: string[]; stackable?: boolean; maxQuantity?: number; requires?: string[]; volumeTiers?: VolumeTier[] } = {},\n  ): BundleConfig => {\n    // Resolve monthly first so the annual fallback tracks a `_MONTHLY` override\n    // (annual ≈ 10× the *effective* monthly, not the hardcoded default).\n    const resolvedMonthly = envCents(process.env[`BILLING_BUNDLE_${id.toUpperCase()}_MONTHLY`], monthly);\n    const volumeTiers = applyVolumeTiersOverride(id, extra.volumeTiers);\n    return {\n      id,\n      name,\n      description,\n      grants: applyGrantOverride(id, grants),\n      ...(extra.features ? { features: extra.features } : {}),\n      ...(extra.maxQuantity !== undefined ? { maxQuantity: extra.maxQuantity } : {}),\n      ...(extra.requires ? { requires: extra.requires } : {}),\n      ...(volumeTiers ? { volumeTiers } : {}),\n      prices: {\n        monthly: resolvedMonthly,\n        annual: envCents(process.env[`BILLING_BUNDLE_${id.toUpperCase()}_ANNUAL`], resolvedMonthly * 10),\n      },\n      stackable: extra.stackable ?? true,\n      availableForTiers: applyTiersOverride(id, availableForTiers),\n      isActive: true,\n      sortOrder,\n    };\n  };\n\n  // Bundles are purchasable on every SELECTABLE tier (excludes `unlimited`, which\n  // is the billing-off tier and buys nothing) — so this is exactly STANDARD_TIERS.\n  const ALL: QuotaTier[] = [...STANDARD_TIERS];\n  const bundles: BundleConfig[] = [\n    // `seat` and `pipeline_pack` are the tier differentiators, so both are Team+\n    // ONLY — a single-seat Developer/Pro can't cheaply stack seats/pipelines to\n    // undercut Team (3 seats / 6 pipelines); they must upgrade. `seat` is granular\n    // (per-seat) with volume tiers (5/15/40 → 10/20/30%). The other capacity packs\n    // (plugin/api/ai/storage) are NOT differentiators, so they stay all-tier.\n    b('seat', 'Member Seat', '1 additional member seat', { seats: 1 }, 1999, ['team', 'enterprise'], 0,\n      { volumeTiers: [{ minQuantity: 5, discountPercent: 10 }, { minQuantity: 15, discountPercent: 20 }, { minQuantity: 40, discountPercent: 30 }] }),\n    b('pipeline_pack', 'Pipeline Pack (+5)', '5 additional pipelines', { pipelines: 5 }, 1500, ['team', 'enterprise'], 1),\n    b('plugin_pack', 'Plugin Pack (+25)', '25 additional plugins', { plugins: 25 }, 1000, ALL, 2),\n    b('api_pack', 'API Pack (+100k)', '100,000 additional API calls / period', { apiCalls: 100_000 }, 1999, ALL, 3),\n    b('ai_pack', 'AI Pack (+2.5k)', '2,500 additional AI calls / period', { aiCalls: 2500 }, 1999, ALL, 4),\n    b('storage_pack', 'Storage Pack (+10 GB)', '10 GB additional registry storage', { storageBytes: 10 * BUNDLE_GB }, 1999, ALL, 5),\n    b('audit_log', 'Audit Log', 'Audit log capability', {}, 2000, ['pro'], 6, { features: ['audit_log'], stackable: false }),\n    // SSO is INCLUDED in Team (see TIER_FEATURES.team), so the add-on is Pro-only.\n    b('sso', 'SSO / IdP', 'SSO + up to 5 IdP configs', { idpConfigs: 5 }, 4000, ['pro'], 7, { features: ['sso'], stackable: false }),\n    // DORA / advanced delivery analytics. INCLUDED in Enterprise (TIER_FEATURES),\n    // so the add-on is offered to every other tier (developer/pro/team). Priced\n    // between Audit Log ($20) and SSO ($40) — a higher-value, actively-used\n    // analytics surface than the audit log, but below the SSO enterprise gate.\n    b('advanced_reporting', 'Advanced Reporting (DORA)', 'DORA delivery metrics — deployment frequency, change failure rate, MTTR, lead-time proxy, performance bands + trend', {}, 3000, ['developer', 'pro', 'team'], 8, { features: ['advanced_reporting'], stackable: false }),\n    // Per-team usage breakdown across the org → team subtree. INCLUDED in\n    // Enterprise (TIER_FEATURES); the add-on is offered to Pro/Team (developer has\n    // no teams to break down). Priced at $30/mo ($300/yr) — parity with DORA, its\n    // analytics sibling. Overridable via BILLING_BUNDLE_TEAM_USAGE_ANALYTICS_MONTHLY/_ANNUAL.\n    b('team_usage_analytics', 'Team Usage Analytics', 'Per-team usage breakdown across the org → team subtree (all quota dimensions)', {}, 3000, ['pro', 'team'], 9, { features: ['team_usage_analytics'], stackable: false }),\n    // Retention packs (docs/billing-bundles.md). Stackable capacity packs that\n    // raise the reporting retention entitlement billing syncs to reporting's\n    // `dora_settings`. NOT quota-metered flow — `eventRetentionDays`/`doraRetentionDays`\n    // are absent from VALID_QUOTA_TYPES, so they never ride the quota-service leg.\n    // Standard Retention Pack: +90d standard-event retention (base 30 → 120 → 210…).\n    // Capped at 7 (30 + 7×90 = 660 ≤ the 730-day retention ceiling).\n    b('retention_pack', 'Standard Retention Pack (+90d)', '90 additional days of standard pipeline-event retention', { eventRetentionDays: 90 }, 1500, ALL, 10, { maxQuantity: 7 }),\n    // DORA History Pack: +365d DORA retention AND per-org report-query window (the\n    // window cap tracks doraRetentionDays). Only meaningful with Advanced Reporting\n    // — INCLUDED in Enterprise, an add-on on developer/pro/team. Capped at 1\n    // (180 + 365 = 545 ≤ the 730-day retention ceiling).\n    b('dora_history_pack', 'DORA History Pack (+365d)', '365 additional days of DORA history + report-query window (requires Advanced Reporting)', { doraRetentionDays: 365 }, 3000, ALL, 11, { maxQuantity: 1 }),\n    // Compliance content add-ons (docs/plans/compliance-addons.md). Feature bundles\n    // gating access to curated system-org published rule sets. INCLUDED in\n    // Enterprise/Unlimited (via ALL_FEATURE_FLAGS); sold to Developer/Pro/Team.\n    // Standard = ~20 CI/CD best-practice rules. Advanced = SOC2/PCI/CIS framework\n    // libraries; REQUIRES Standard (or buy the Suite combo for both at 30% off).\n    b('compliance_standard', 'Standard Compliance', 'Curated CI/CD best-practice compliance rules', {}, 2990, ['developer', 'pro', 'team'], 12, { features: ['compliance_standard'], stackable: false }),\n    b('compliance_advanced', 'Advanced Compliance', 'Curated framework compliance libraries (SOC2 / PCI-DSS / CIS)', {}, 9990, ['developer', 'pro', 'team'], 13, { features: ['compliance_advanced'], stackable: false, requires: ['compliance_standard'] }),\n  ];\n  assertBundleRequiresValid(bundles);\n  return bundles;\n}\n\n/**\n * Config-load guardrail for the `requires` prerequisite graph. A `requires` entry\n * that doesn't resolve to an ACTIVE bundle — or that participates in a cycle —\n * silently makes the referencing bundle unpurchasable (the addon route rejects\n * with 400 forever because the prerequisite can never be satisfied). Catch it at\n * load with a clear error rather than shipping a dead SKU.\n *\n *  - Every id in a bundle's `requires` MUST name an active bundle in the catalog.\n *  - The `requires` graph MUST be acyclic (a → b → a can never be satisfied).\n */\nexport function assertBundleRequiresValid(bundles: BundleConfig[]): void {\n  const active = new Map(bundles.filter((b) => b.isActive).map((b) => [b.id, b]));\n\n  // 1. Validity: every requires id resolves to an active bundle.\n  for (const bundle of bundles) {\n    for (const reqId of bundle.requires ?? []) {\n      if (!active.has(reqId)) {\n        throw new Error(\n          `[billing-config] Bundle \"${bundle.id}\" requires \"${reqId}\", which is not an active bundle in the catalog — it would be permanently unpurchasable.`,\n        );\n      }\n    }\n  }\n\n  // 2. Acyclicity: DFS over the requires edges, tracking the current path.\n  const VISITING = 1;\n  const DONE = 2;\n  const state = new Map<string, number>();\n\n  const visit = (id: string, path: string[]): void => {\n    const s = state.get(id);\n    if (s === DONE) return;\n    if (s === VISITING) {\n      const cycle = [...path.slice(path.indexOf(id)), id].join(' -> ');\n      throw new Error(`[billing-config] Bundle \"requires\" cycle detected: ${cycle}.`);\n    }\n    state.set(id, VISITING);\n    for (const reqId of active.get(id)?.requires ?? []) {\n      visit(reqId, [...path, id]);\n    }\n    state.set(id, DONE);\n  };\n\n  for (const bundle of active.keys()) {\n    visit(bundle, []);\n  }\n}\n"]}

package/lib/config/config-types.d.ts

@@ -289,6 +289,18 @@ export interface BundleConfig {
      * Retention Pack caps at 7 so 30 + 7×90 = 660 ≤ 730). Absent ⇒ unbounded.
      */
     readonly maxQuantity?: number;
+    /**
+     * Optional per-unit volume discount tiers for a stackable pack: at ≥ `minQuantity`
+     * purchased units, `discountPercent` comes off the line subtotal (unit × quantity).
+     * The highest matching tier wins. Realized as a recurring usage credit (like a
+     * combo), so the provider still charges unit×qty and the credit offsets the
+     * balance. Env-overridable via `BILLING_BUNDLE_<ID>_VOLUME_TIERS` (JSON). Used by
+     * the per-seat `seat` bundle. Absent ⇒ no volume discount.
+     */
+    readonly volumeTiers?: readonly {
+        readonly minQuantity: number;
+        readonly discountPercent: number;
+    }[];
     /** Base tiers this bundle is offered to. */
     readonly availableForTiers: readonly QuotaTier[];
     /**
@@ -315,8 +327,8 @@ export interface ComboDiscountConfig {
     /** The member bundle ids that must ALL be present for the combo to apply. */
     readonly bundleIds: readonly string[];
     /** Per-member minimum quantity (bundleId → count; absent ⇒ 1). Lets a stackable
-     *  capacity pack anchor a combo — e.g. `{ seat_pack: 1 }` = "≥ 1 Seat Pack". The
-     *  credit basis uses this minimum, so extra packs never inflate the discount. */
+     *  capacity pack anchor a combo — e.g. `{ seat: 5 }` = "≥ 5 seats". The credit
+     *  basis uses this minimum, so extra units never inflate the discount. */
     readonly minQuantities?: Readonly<Record<string, number>>;
     /** The combined price for the minimum set (cents). The credit is
      *  `Σ member unit price × minQty − prices`, clamped ≥ 0. */

package/lib/config/config-types.js

@@ -1,4 +1,4 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config-types.js","sourceRoot":"","sources":["../../src/config/config-types.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { QuotaTier, QuotaTierLimits } from '@pipeline-builder/api-core';\nimport type { Algorithm } from 'jsonwebtoken';\n\n/**\n * Type-safe configuration interface\n */\nexport interface AppConfig {\n  readonly server: ServerConfig;\n  readonly auth: AuthConfig;\n  readonly database: DatabaseConfig;\n  readonly registry: RegistryConfig;\n  readonly redis: RedisConfig;\n  readonly pluginBuild: PluginBuildConfig;\n  readonly dockerConfig: BuildConfig;\n  readonly observability: ObservabilityConfig;\n  readonly compliance: ComplianceConfig;\n  readonly aws: AWSConfig;\n  readonly rateLimit: RateLimitConfig;\n  readonly billing: BillingConfig;\n}\n\n/** Express server configuration. */\nexport interface ServerConfig {\n  /** HTTP listen port (env: `PORT`). */\n  readonly port: number;\n  readonly cors: {\n    /** Whether to include credentials in CORS responses (env: `CORS_CREDENTIALS`). */\n    readonly credentials: boolean;\n    /** Allowed origin(s) — single string, array, or `'*'` (env: `CORS_ORIGIN`). */\n    readonly origin: string | string[];\n  };\n  /** Number of reverse proxy hops to trust (env: `TRUST_PROXY`). */\n  readonly trustProxy: number;\n  /** Frontend base URL, used as CORS fallback (env: `PLATFORM_BASE_URL`). */\n  readonly platformUrl: string;\n  readonly httpClient: {\n    /** Default HTTP request timeout in ms (env: `HTTP_CLIENT_TIMEOUT`). */\n    readonly timeout: number;\n    /** Maximum retry attempts for failed requests (env: `HTTP_CLIENT_MAX_RETRIES`). */\n    readonly maxRetries: number;\n    /** Base delay between retries in ms (env: `HTTP_CLIENT_RETRY_DELAY_MS`). */\n    readonly retryDelayMs: number;\n  };\n  readonly sse: {\n    /** Max SSE clients per request (env: `SSE_MAX_CLIENTS_PER_REQUEST`). */\n    readonly maxClientsPerRequest: number;\n    /** SSE client timeout in ms (env: `SSE_CLIENT_TIMEOUT_MS`). */\n    readonly clientTimeoutMs: number;\n    /** SSE cleanup interval in ms (env: `SSE_CLEANUP_INTERVAL_MS`). */\n    readonly cleanupIntervalMs: number;\n  };\n  readonly services: {\n    readonly pluginHost: string;\n    readonly pluginPort: number;\n    readonly pipelineHost: string;\n    readonly pipelinePort: number;\n    readonly messageHost: string;\n    readonly messagePort: number;\n    readonly platformHost: string;\n    readonly platformPort: number;\n    readonly complianceHost: string;\n    readonly compliancePort: number;\n    readonly billingHost: string;\n    readonly billingPort: number;\n    readonly billingTimeout: number;\n  };\n}\n\n/** JWT and refresh token authentication configuration. */\nexport interface AuthConfig {\n  readonly jwt: {\n    /** Signing secret for access tokens (env: `JWT_SECRET`). */\n    readonly secret: string;\n    /** Token lifetime in seconds (env: `JWT_EXPIRES_IN`). */\n    readonly expiresIn: number;\n    /** Signing algorithm, e.g. `'HS256'` (env: `JWT_ALGORITHM`). */\n    readonly algorithm: Algorithm;\n    /** bcrypt salt rounds for password hashing (env: `BCRYPT_SALT_ROUNDS`). */\n    readonly saltRounds: number;\n  };\n  readonly refreshToken: {\n    /** Signing secret for refresh tokens (env: `REFRESH_TOKEN_SECRET`). */\n    readonly secret: string;\n    /** Token lifetime in seconds (env: `REFRESH_TOKEN_EXPIRES_IN`). */\n    readonly expiresIn: number;\n  };\n}\n\n/** PostgreSQL and Drizzle ORM database configuration. */\nexport interface DatabaseConfig {\n  readonly postgres: {\n    /** PostgreSQL host (env: `DB_HOST`). */\n    readonly host: string;\n    /** PostgreSQL port (env: `DB_PORT`). */\n    readonly port: number;\n    /** Database name (env: `DATABASE`). */\n    readonly database: string;\n    /** Database user (env: `DB_USER`). */\n    readonly user: string;\n    /** Database password (env: `DB_PASSWORD`). */\n    readonly password: string;\n  };\n  readonly drizzle: {\n    /** Maximum connection pool size (env: `DRIZZLE_MAX_POOL_SIZE`). */\n    readonly maxPoolSize: number;\n    /** Idle connection timeout in ms (env: `DRIZZLE_IDLE_TIMEOUT_MILLIS`). */\n    readonly idleTimeoutMillis: number;\n    /** New connection timeout in ms (env: `DRIZZLE_CONNECTION_TIMEOUT_MILLIS`). */\n    readonly connectionTimeoutMillis: number;\n  };\n}\n\nexport interface RegistryConfig {\n  readonly host: string;\n  readonly port: number;\n  /**\n   * Host/port an OUT-OF-CLUSTER client (notably AWS CodeBuild) uses to pull\n   * plugin images, when it differs from the in-cluster `host`/`port`. The\n   * in-cluster `registry:5000` ClusterIP isn't resolvable from the VPC, so the\n   * synthesized CodeBuild image URI must point at the public gateway instead.\n   * Env: `IMAGE_REGISTRY_PULL_HOST` / `IMAGE_REGISTRY_PULL_PORT`. Optional;\n   * consumers fall back to `host`/`port` when unset (single-host /\n   * in-cluster-only deploys). `loadRegistryConfig` always populates them.\n   */\n  readonly pullHost?: string;\n  readonly pullPort?: number;\n  /** Docker network for build/push (empty string = default). */\n  readonly network: string;\n  /**\n   * BuildKit talks to the registry over plain HTTP when true; HTTPS with the\n   * system CA bundle otherwise. Env: `IMAGE_REGISTRY_HTTP` (defaults true —\n   * the in-cluster registry has no TLS).\n   */\n  readonly http: boolean;\n}\n\nexport interface RedisConfig {\n  readonly host: string;\n  readonly port: number;\n}\n\nexport interface PluginBuildConfig {\n  readonly concurrency: number;\n  readonly maxAttempts: number;\n  readonly backoffDelayMs: number;\n  readonly workerTimeoutMs: number;\n  readonly tempDirMaxAgeMs: number;\n  readonly dlqMaxAttempts: number;\n  readonly dlqBackoffBaseMs: number;\n  readonly dlqMaxSize: number;\n}\n\nexport interface BuildConfig {\n  /** Root directory for build temp files. */\n  readonly tempRoot: string;\n  /** Build timeout in milliseconds. */\n  readonly timeoutMs: number;\n  /** Push timeout in milliseconds. */\n  readonly pushTimeoutMs: number;\n  /**\n   * Path to the buildkitd socket the plugin's `buildctl` connects to. In k8s\n   * and compose this is a shared emptyDir/tmpfs volume mounted from the\n   * buildkitd sidecar.\n   */\n  readonly buildkitAddr: string;\n}\n\nexport interface ObservabilityConfig {\n  readonly logLevel: string;\n  readonly logFormat: string;\n  readonly serviceName: string;\n  readonly tracing: {\n    readonly enabled: boolean;\n    readonly endpoint: string;\n  };\n}\n\nexport interface ComplianceConfig {\n  readonly scanSchedulerIntervalMs: number;\n  /** When false, the scheduler skips scans/schedules for the system org. Default: false. */\n  readonly systemOrgScansEnabled: boolean;\n  /** Cross-pod leader-lock TTL for the scan scheduler (ms). Default: 300000. */\n  readonly scanLockTtlMs: number;\n  /** How often the digest scheduler checks for due digests (ms). Default: 3600000. */\n  readonly digestSchedulerIntervalMs: number;\n  /** Cross-pod leader-lock TTL for the digest scheduler (ms). Default: 300000. */\n  readonly digestLockTtlMs: number;\n}\n\n/**\n * AWS infrastructure configuration.\n *\n * Deliberately expressed in PLAIN DATA (numbers, strings, string unions) rather\n * than CDK value objects (`Duration`, `Runtime`, `RetentionDays`, ...). Config is\n * loaded by every service, but only the CDK entry point (`@pipeline-builder/\n * pipeline-core/cdk`) builds stacks  typing this block with CDK classes put\n * `aws-cdk-lib` on the import graph of `Config`, and therefore of every API\n * service that reads so much as a port number. Conversion to CDK objects happens\n * at the construct boundary in `config/aws-config-cdk.ts`.\n */\nexport interface AWSConfig {\n  readonly lambda: {\n    /** Lambda runtime identifier, e.g. `'nodejs24.x'` (env: `LAMBDA_RUNTIME`). */\n    readonly runtime: string;\n    /** Function timeout in seconds (env: `LAMBDA_TIMEOUT`). */\n    readonly timeoutSeconds: number;\n    readonly memorySize: number;\n    readonly architecture: 'arm64' | 'x86_64';\n    readonly reservedConcurrentExecutions?: number;\n  };\n  readonly logging: {\n    readonly groupName: string;\n    /** CloudWatch retention in days; `0` means never expire (env: `LOG_RETENTION`). */\n    readonly retentionDays: number;\n    readonly removalPolicy: 'retain' | 'destroy';\n  };\n  readonly codeBuild: {\n    /** CodeBuild compute type name, e.g. `'SMALL'` (env: `CODEBUILD_COMPUTE_TYPE`). */\n    readonly computeType: string;\n    /**\n     * Image used for CodeBuild steps that don't have a plugin-baked image\n     * (cold-start synth bootstrap, ShellSteps with no registry, and\n     * `metadata_only` plugins). env: `CODEBUILD_DEFAULT_IMAGE`. Default\n     * `pipeline-bootstrap:1.0` — the local tag built by\n     * `deploy/codebuild/bootstrap/Dockerfile`, with `pipeline-manager`\n     * baked in.\n     *\n     * Contract: the image MUST have `pipeline-manager` on PATH. The\n     * bootstrap synth path no longer self-heals via `npm install -g`;\n     * pointing this at an image without the tool gets exit 127 on the\n     * first cold-start build.\n     *\n     * Resolution:\n     * - Bare tag (no `/`) → auto-prefixed to\n     *   `<registry-host>:<port>/library/<tag>` using the registry config,\n     *   with the per-org platform Secret as Basic auth (same flow as\n     *   plugin images).\n     * - Fully-qualified registry URI (contains `/`) → used as-is, no\n     *   auth wired (operator owns making it pullable).\n     * - When the registry isn't configured or per-org auth isn't\n     *   available at the call site, falls back to\n     *   `aws/codebuild/standard:8.0` with a warning — cold-start synth\n     *   will then fail on `pipeline-manager: not found`, surfacing the\n     *   misconfiguration loudly instead of silently swapping images.\n     */\n    readonly defaultImage: string;\n  };\n}\n\n/** Express rate limiting configuration. */\nexport interface RateLimitConfig {\n  /** Maximum requests per window (env: `LIMITER_MAX`). */\n  readonly max: number;\n  /** Rate limit window in milliseconds (env: `LIMITER_WINDOWMS`). */\n  readonly windowMs: number;\n  /** Include legacy `X-RateLimit-*` headers. */\n  readonly legacyHeaders: boolean;\n  /** Include standard `RateLimit-*` headers (RFC 6585). */\n  readonly standardHeaders: boolean;\n}\n\n/** Price configuration for a single billing plan (in cents). */\nexport interface BillingPlanPrices {\n  readonly monthly: number;\n  readonly annual: number;\n}\n\n/** Full billing plan definition used for seeding and runtime configuration. */\nexport interface BillingPlanConfig {\n  readonly id: string;\n  readonly name: string;\n  readonly description: string;\n  readonly tier: QuotaTier;\n  readonly prices: BillingPlanPrices;\n  readonly features: readonly string[];\n  readonly isActive: boolean;\n  readonly isDefault: boolean;\n  readonly sortOrder: number;\n}\n\n/**\n * A purchasable add-on bundle: a quantity-stackable pack that ADDS to the\n * account's base (tier) limits and adds a recurring line item. See\n * docs/billing-bundles.md.\n */\nexport interface BundleConfig {\n  readonly id: string;\n  readonly name: string;\n  readonly description: string;\n  /** Per-unit deltas on `QuotaTierLimits` fields, e.g. `{ seats: 5 }`. Keys are\n   *  constrained to real quota fields so a typo is a compile error (was\n   *  `Record<string, number>`, where a misspelled key was silently unenforceable). */\n  readonly grants: Readonly<Partial<Record<keyof QuotaTierLimits, number>>>;\n  /** Feature flags granted by a feature bundle (e.g. `audit_log`). */\n  readonly features?: readonly string[];\n  /** Per-unit price (cents). Stripe multiplies by quantity. */\n  readonly prices: BillingPlanPrices;\n  /** True for stackable resource packs; false for a boolean feature bundle. */\n  readonly stackable: boolean;\n  /**\n   * Maximum purchasable quantity for a stackable pack. Enforced by the addon\n   * purchase/preview route (`quantity ≤ maxQuantity`, reject over-cap). Used to\n   * keep retention packs under the 730-day retention ceiling (e.g. the Standard\n   * Retention Pack caps at 7 so 30 + 7×90 = 660 ≤ 730). Absent ⇒ unbounded.\n   */\n  readonly maxQuantity?: number;\n  /** Base tiers this bundle is offered to. */\n  readonly availableForTiers: readonly QuotaTier[];\n  /**\n   * Prerequisite bundle ids that must be held (or purchased in the same action)\n   * before this bundle can be added. Enforced by the addon purchase/preview route\n   * (reject with 400 when unmet); a combo that includes the prerequisite satisfies\n   * it. Used by `compliance_advanced` (`requires: ['compliance_standard']`).\n   * Absent ⇒ no prerequisite.\n   */\n  readonly requires?: readonly string[];\n  readonly isActive: boolean;\n  readonly sortOrder: number;\n}\n\n/**\n * A combo discount: when an account holds EVERY bundle in `bundleIds`, the pair\n * is billed at `prices` (the combined price) instead of the sum of the members'\n * individual prices. Realized as a recurring usage credit for the difference —\n * never a provider coupon — consistent with the usage-credit discount model. See\n * docs/billing-bundles.md §Combo pricing.\n */\nexport interface ComboDiscountConfig {\n  readonly id: string;\n  readonly name: string;\n  /** The member bundle ids that must ALL be present for the combo to apply. */\n  readonly bundleIds: readonly string[];\n  /** Per-member minimum quantity (bundleId → count; absent ⇒ 1). Lets a stackable\n   *  capacity pack anchor a combo — e.g. `{ seat_pack: 1 }` = \"≥ 1 Seat Pack\". The\n   *  credit basis uses this minimum, so extra packs never inflate the discount. */\n  readonly minQuantities?: Readonly<Record<string, number>>;\n  /** The combined price for the minimum set (cents). The credit is\n   *  `Σ member unit price × minQty − prices`, clamped ≥ 0. */\n  readonly prices: BillingPlanPrices;\n  /** Deterministic tie-break among equal-total optimal packings when combos overlap\n   *  (lower wins). */\n  readonly sortOrder: number;\n  readonly isActive: boolean;\n}\n\n/** Billing plans + add-on bundle configuration. */\nexport interface BillingConfig {\n  readonly plans: readonly BillingPlanConfig[];\n  readonly bundles: readonly BundleConfig[];\n  readonly comboDiscounts: readonly ComboDiscountConfig[];\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config-types.js","sourceRoot":"","sources":["../../src/config/config-types.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { QuotaTier, QuotaTierLimits } from '@pipeline-builder/api-core';\nimport type { Algorithm } from 'jsonwebtoken';\n\n/**\n * Type-safe configuration interface\n */\nexport interface AppConfig {\n  readonly server: ServerConfig;\n  readonly auth: AuthConfig;\n  readonly database: DatabaseConfig;\n  readonly registry: RegistryConfig;\n  readonly redis: RedisConfig;\n  readonly pluginBuild: PluginBuildConfig;\n  readonly dockerConfig: BuildConfig;\n  readonly observability: ObservabilityConfig;\n  readonly compliance: ComplianceConfig;\n  readonly aws: AWSConfig;\n  readonly rateLimit: RateLimitConfig;\n  readonly billing: BillingConfig;\n}\n\n/** Express server configuration. */\nexport interface ServerConfig {\n  /** HTTP listen port (env: `PORT`). */\n  readonly port: number;\n  readonly cors: {\n    /** Whether to include credentials in CORS responses (env: `CORS_CREDENTIALS`). */\n    readonly credentials: boolean;\n    /** Allowed origin(s) — single string, array, or `'*'` (env: `CORS_ORIGIN`). */\n    readonly origin: string | string[];\n  };\n  /** Number of reverse proxy hops to trust (env: `TRUST_PROXY`). */\n  readonly trustProxy: number;\n  /** Frontend base URL, used as CORS fallback (env: `PLATFORM_BASE_URL`). */\n  readonly platformUrl: string;\n  readonly httpClient: {\n    /** Default HTTP request timeout in ms (env: `HTTP_CLIENT_TIMEOUT`). */\n    readonly timeout: number;\n    /** Maximum retry attempts for failed requests (env: `HTTP_CLIENT_MAX_RETRIES`). */\n    readonly maxRetries: number;\n    /** Base delay between retries in ms (env: `HTTP_CLIENT_RETRY_DELAY_MS`). */\n    readonly retryDelayMs: number;\n  };\n  readonly sse: {\n    /** Max SSE clients per request (env: `SSE_MAX_CLIENTS_PER_REQUEST`). */\n    readonly maxClientsPerRequest: number;\n    /** SSE client timeout in ms (env: `SSE_CLIENT_TIMEOUT_MS`). */\n    readonly clientTimeoutMs: number;\n    /** SSE cleanup interval in ms (env: `SSE_CLEANUP_INTERVAL_MS`). */\n    readonly cleanupIntervalMs: number;\n  };\n  readonly services: {\n    readonly pluginHost: string;\n    readonly pluginPort: number;\n    readonly pipelineHost: string;\n    readonly pipelinePort: number;\n    readonly messageHost: string;\n    readonly messagePort: number;\n    readonly platformHost: string;\n    readonly platformPort: number;\n    readonly complianceHost: string;\n    readonly compliancePort: number;\n    readonly billingHost: string;\n    readonly billingPort: number;\n    readonly billingTimeout: number;\n  };\n}\n\n/** JWT and refresh token authentication configuration. */\nexport interface AuthConfig {\n  readonly jwt: {\n    /** Signing secret for access tokens (env: `JWT_SECRET`). */\n    readonly secret: string;\n    /** Token lifetime in seconds (env: `JWT_EXPIRES_IN`). */\n    readonly expiresIn: number;\n    /** Signing algorithm, e.g. `'HS256'` (env: `JWT_ALGORITHM`). */\n    readonly algorithm: Algorithm;\n    /** bcrypt salt rounds for password hashing (env: `BCRYPT_SALT_ROUNDS`). */\n    readonly saltRounds: number;\n  };\n  readonly refreshToken: {\n    /** Signing secret for refresh tokens (env: `REFRESH_TOKEN_SECRET`). */\n    readonly secret: string;\n    /** Token lifetime in seconds (env: `REFRESH_TOKEN_EXPIRES_IN`). */\n    readonly expiresIn: number;\n  };\n}\n\n/** PostgreSQL and Drizzle ORM database configuration. */\nexport interface DatabaseConfig {\n  readonly postgres: {\n    /** PostgreSQL host (env: `DB_HOST`). */\n    readonly host: string;\n    /** PostgreSQL port (env: `DB_PORT`). */\n    readonly port: number;\n    /** Database name (env: `DATABASE`). */\n    readonly database: string;\n    /** Database user (env: `DB_USER`). */\n    readonly user: string;\n    /** Database password (env: `DB_PASSWORD`). */\n    readonly password: string;\n  };\n  readonly drizzle: {\n    /** Maximum connection pool size (env: `DRIZZLE_MAX_POOL_SIZE`). */\n    readonly maxPoolSize: number;\n    /** Idle connection timeout in ms (env: `DRIZZLE_IDLE_TIMEOUT_MILLIS`). */\n    readonly idleTimeoutMillis: number;\n    /** New connection timeout in ms (env: `DRIZZLE_CONNECTION_TIMEOUT_MILLIS`). */\n    readonly connectionTimeoutMillis: number;\n  };\n}\n\nexport interface RegistryConfig {\n  readonly host: string;\n  readonly port: number;\n  /**\n   * Host/port an OUT-OF-CLUSTER client (notably AWS CodeBuild) uses to pull\n   * plugin images, when it differs from the in-cluster `host`/`port`. The\n   * in-cluster `registry:5000` ClusterIP isn't resolvable from the VPC, so the\n   * synthesized CodeBuild image URI must point at the public gateway instead.\n   * Env: `IMAGE_REGISTRY_PULL_HOST` / `IMAGE_REGISTRY_PULL_PORT`. Optional;\n   * consumers fall back to `host`/`port` when unset (single-host /\n   * in-cluster-only deploys). `loadRegistryConfig` always populates them.\n   */\n  readonly pullHost?: string;\n  readonly pullPort?: number;\n  /** Docker network for build/push (empty string = default). */\n  readonly network: string;\n  /**\n   * BuildKit talks to the registry over plain HTTP when true; HTTPS with the\n   * system CA bundle otherwise. Env: `IMAGE_REGISTRY_HTTP` (defaults true —\n   * the in-cluster registry has no TLS).\n   */\n  readonly http: boolean;\n}\n\nexport interface RedisConfig {\n  readonly host: string;\n  readonly port: number;\n}\n\nexport interface PluginBuildConfig {\n  readonly concurrency: number;\n  readonly maxAttempts: number;\n  readonly backoffDelayMs: number;\n  readonly workerTimeoutMs: number;\n  readonly tempDirMaxAgeMs: number;\n  readonly dlqMaxAttempts: number;\n  readonly dlqBackoffBaseMs: number;\n  readonly dlqMaxSize: number;\n}\n\nexport interface BuildConfig {\n  /** Root directory for build temp files. */\n  readonly tempRoot: string;\n  /** Build timeout in milliseconds. */\n  readonly timeoutMs: number;\n  /** Push timeout in milliseconds. */\n  readonly pushTimeoutMs: number;\n  /**\n   * Path to the buildkitd socket the plugin's `buildctl` connects to. In k8s\n   * and compose this is a shared emptyDir/tmpfs volume mounted from the\n   * buildkitd sidecar.\n   */\n  readonly buildkitAddr: string;\n}\n\nexport interface ObservabilityConfig {\n  readonly logLevel: string;\n  readonly logFormat: string;\n  readonly serviceName: string;\n  readonly tracing: {\n    readonly enabled: boolean;\n    readonly endpoint: string;\n  };\n}\n\nexport interface ComplianceConfig {\n  readonly scanSchedulerIntervalMs: number;\n  /** When false, the scheduler skips scans/schedules for the system org. Default: false. */\n  readonly systemOrgScansEnabled: boolean;\n  /** Cross-pod leader-lock TTL for the scan scheduler (ms). Default: 300000. */\n  readonly scanLockTtlMs: number;\n  /** How often the digest scheduler checks for due digests (ms). Default: 3600000. */\n  readonly digestSchedulerIntervalMs: number;\n  /** Cross-pod leader-lock TTL for the digest scheduler (ms). Default: 300000. */\n  readonly digestLockTtlMs: number;\n}\n\n/**\n * AWS infrastructure configuration.\n *\n * Deliberately expressed in PLAIN DATA (numbers, strings, string unions) rather\n * than CDK value objects (`Duration`, `Runtime`, `RetentionDays`, ...). Config is\n * loaded by every service, but only the CDK entry point (`@pipeline-builder/\n * pipeline-core/cdk`) builds stacks  typing this block with CDK classes put\n * `aws-cdk-lib` on the import graph of `Config`, and therefore of every API\n * service that reads so much as a port number. Conversion to CDK objects happens\n * at the construct boundary in `config/aws-config-cdk.ts`.\n */\nexport interface AWSConfig {\n  readonly lambda: {\n    /** Lambda runtime identifier, e.g. `'nodejs24.x'` (env: `LAMBDA_RUNTIME`). */\n    readonly runtime: string;\n    /** Function timeout in seconds (env: `LAMBDA_TIMEOUT`). */\n    readonly timeoutSeconds: number;\n    readonly memorySize: number;\n    readonly architecture: 'arm64' | 'x86_64';\n    readonly reservedConcurrentExecutions?: number;\n  };\n  readonly logging: {\n    readonly groupName: string;\n    /** CloudWatch retention in days; `0` means never expire (env: `LOG_RETENTION`). */\n    readonly retentionDays: number;\n    readonly removalPolicy: 'retain' | 'destroy';\n  };\n  readonly codeBuild: {\n    /** CodeBuild compute type name, e.g. `'SMALL'` (env: `CODEBUILD_COMPUTE_TYPE`). */\n    readonly computeType: string;\n    /**\n     * Image used for CodeBuild steps that don't have a plugin-baked image\n     * (cold-start synth bootstrap, ShellSteps with no registry, and\n     * `metadata_only` plugins). env: `CODEBUILD_DEFAULT_IMAGE`. Default\n     * `pipeline-bootstrap:1.0` — the local tag built by\n     * `deploy/codebuild/bootstrap/Dockerfile`, with `pipeline-manager`\n     * baked in.\n     *\n     * Contract: the image MUST have `pipeline-manager` on PATH. The\n     * bootstrap synth path no longer self-heals via `npm install -g`;\n     * pointing this at an image without the tool gets exit 127 on the\n     * first cold-start build.\n     *\n     * Resolution:\n     * - Bare tag (no `/`) → auto-prefixed to\n     *   `<registry-host>:<port>/library/<tag>` using the registry config,\n     *   with the per-org platform Secret as Basic auth (same flow as\n     *   plugin images).\n     * - Fully-qualified registry URI (contains `/`) → used as-is, no\n     *   auth wired (operator owns making it pullable).\n     * - When the registry isn't configured or per-org auth isn't\n     *   available at the call site, falls back to\n     *   `aws/codebuild/standard:8.0` with a warning — cold-start synth\n     *   will then fail on `pipeline-manager: not found`, surfacing the\n     *   misconfiguration loudly instead of silently swapping images.\n     */\n    readonly defaultImage: string;\n  };\n}\n\n/** Express rate limiting configuration. */\nexport interface RateLimitConfig {\n  /** Maximum requests per window (env: `LIMITER_MAX`). */\n  readonly max: number;\n  /** Rate limit window in milliseconds (env: `LIMITER_WINDOWMS`). */\n  readonly windowMs: number;\n  /** Include legacy `X-RateLimit-*` headers. */\n  readonly legacyHeaders: boolean;\n  /** Include standard `RateLimit-*` headers (RFC 6585). */\n  readonly standardHeaders: boolean;\n}\n\n/** Price configuration for a single billing plan (in cents). */\nexport interface BillingPlanPrices {\n  readonly monthly: number;\n  readonly annual: number;\n}\n\n/** Full billing plan definition used for seeding and runtime configuration. */\nexport interface BillingPlanConfig {\n  readonly id: string;\n  readonly name: string;\n  readonly description: string;\n  readonly tier: QuotaTier;\n  readonly prices: BillingPlanPrices;\n  readonly features: readonly string[];\n  readonly isActive: boolean;\n  readonly isDefault: boolean;\n  readonly sortOrder: number;\n}\n\n/**\n * A purchasable add-on bundle: a quantity-stackable pack that ADDS to the\n * account's base (tier) limits and adds a recurring line item. See\n * docs/billing-bundles.md.\n */\nexport interface BundleConfig {\n  readonly id: string;\n  readonly name: string;\n  readonly description: string;\n  /** Per-unit deltas on `QuotaTierLimits` fields, e.g. `{ seats: 5 }`. Keys are\n   *  constrained to real quota fields so a typo is a compile error (was\n   *  `Record<string, number>`, where a misspelled key was silently unenforceable). */\n  readonly grants: Readonly<Partial<Record<keyof QuotaTierLimits, number>>>;\n  /** Feature flags granted by a feature bundle (e.g. `audit_log`). */\n  readonly features?: readonly string[];\n  /** Per-unit price (cents). Stripe multiplies by quantity. */\n  readonly prices: BillingPlanPrices;\n  /** True for stackable resource packs; false for a boolean feature bundle. */\n  readonly stackable: boolean;\n  /**\n   * Maximum purchasable quantity for a stackable pack. Enforced by the addon\n   * purchase/preview route (`quantity ≤ maxQuantity`, reject over-cap). Used to\n   * keep retention packs under the 730-day retention ceiling (e.g. the Standard\n   * Retention Pack caps at 7 so 30 + 7×90 = 660 ≤ 730). Absent ⇒ unbounded.\n   */\n  readonly maxQuantity?: number;\n  /**\n   * Optional per-unit volume discount tiers for a stackable pack: at ≥ `minQuantity`\n   * purchased units, `discountPercent` comes off the line subtotal (unit × quantity).\n   * The highest matching tier wins. Realized as a recurring usage credit (like a\n   * combo), so the provider still charges unit×qty and the credit offsets the\n   * balance. Env-overridable via `BILLING_BUNDLE_<ID>_VOLUME_TIERS` (JSON). Used by\n   * the per-seat `seat` bundle. Absent ⇒ no volume discount.\n   */\n  readonly volumeTiers?: readonly { readonly minQuantity: number; readonly discountPercent: number }[];\n  /** Base tiers this bundle is offered to. */\n  readonly availableForTiers: readonly QuotaTier[];\n  /**\n   * Prerequisite bundle ids that must be held (or purchased in the same action)\n   * before this bundle can be added. Enforced by the addon purchase/preview route\n   * (reject with 400 when unmet); a combo that includes the prerequisite satisfies\n   * it. Used by `compliance_advanced` (`requires: ['compliance_standard']`).\n   * Absent ⇒ no prerequisite.\n   */\n  readonly requires?: readonly string[];\n  readonly isActive: boolean;\n  readonly sortOrder: number;\n}\n\n/**\n * A combo discount: when an account holds EVERY bundle in `bundleIds`, the pair\n * is billed at `prices` (the combined price) instead of the sum of the members'\n * individual prices. Realized as a recurring usage credit for the difference —\n * never a provider coupon — consistent with the usage-credit discount model. See\n * docs/billing-bundles.md §Combo pricing.\n */\nexport interface ComboDiscountConfig {\n  readonly id: string;\n  readonly name: string;\n  /** The member bundle ids that must ALL be present for the combo to apply. */\n  readonly bundleIds: readonly string[];\n  /** Per-member minimum quantity (bundleId → count; absent ⇒ 1). Lets a stackable\n   *  capacity pack anchor a combo — e.g. `{ seat: 5 }` = \"≥ 5 seats\". The credit\n   *  basis uses this minimum, so extra units never inflate the discount. */\n  readonly minQuantities?: Readonly<Record<string, number>>;\n  /** The combined price for the minimum set (cents). The credit is\n   *  `Σ member unit price × minQty − prices`, clamped ≥ 0. */\n  readonly prices: BillingPlanPrices;\n  /** Deterministic tie-break among equal-total optimal packings when combos overlap\n   *  (lower wins). */\n  readonly sortOrder: number;\n  readonly isActive: boolean;\n}\n\n/** Billing plans + add-on bundle configuration. */\nexport interface BillingConfig {\n  readonly plans: readonly BillingPlanConfig[];\n  readonly bundles: readonly BundleConfig[];\n  readonly comboDiscounts: readonly ComboDiscountConfig[];\n}\n"]}

package/lib/config/entitlements.d.ts

@@ -7,7 +7,7 @@
  * one implementation instead of re-deriving the coalesce. Pure: the tier limits
  * come from api-core (`getTierLimits`) and the bundle catalog is passed in.
  */
-import { type QuotaTier } from '@pipeline-builder/api-core';
+import { type QuotaTier, type QuotaTierLimits } from '@pipeline-builder/api-core';
 import type { BundleConfig } from './config-types.js';
 /**
  * Compute an account's EFFECTIVE entitlements = tier base limits + Σ(bundle
@@ -18,6 +18,6 @@ export declare function effectiveEntitlements(tier: QuotaTier, addons: ReadonlyA
     bundleId: string;
     quantity: number;
 }>, bundles: readonly BundleConfig[]): {
-    limits: Record<string, number>;
+    limits: Record<keyof QuotaTierLimits, number>;
     features: string[];
 };

package/lib/config/entitlements.js

@@ -23,15 +23,17 @@ export function effectiveEntitlements(tier, addons, bundles) {
         const bundle = byId.get(bundleId);
         if (!bundle || quantity <= 0)
             continue;
-        // Enforce the non-stackable invariant in the CANONICAL math, not just at the
-        // purchase route: a `stackable:false` bundle counts once regardless of a
-        // stored quantity > 1, so a non-route caller (drift reconciler,
-        // subscription-lifecycle) can't over-grant its quota.
-        const effectiveQty = bundle.stackable ? quantity : 1;
-        for (const [field, delta] of Object.entries(bundle.grants)) {
+        // Enforce the non-stackable invariant AND the maxQuantity ceiling in the
+        // CANONICAL math, not just at the purchase route: a `stackable:false` bundle
+        // counts once, and a stackable pack is clamped to its `maxQuantity` — so a
+        // non-route caller (drift reconciler, subscription-lifecycle) can't over-grant
+        // a quota from a stored/drifted quantity (e.g. a retention pack past its cap).
+        const effectiveQty = bundle.stackable ? Math.min(quantity, bundle.maxQuantity ?? quantity) : 1;
+        for (const [rawField, delta] of Object.entries(bundle.grants)) {
             // `grants` is a Partial map, so a value can be undefined — skip those.
             if (delta === undefined)
                 continue;
+            const field = rawField; // grants keys ARE quota fields
             if (limits[field] === -1)
                 continue; // already unlimited
             limits[field] = (limits[field] ?? 0) + delta * effectiveQty;
@@ -41,4 +43,4 @@ export function effectiveEntitlements(tier, addons, bundles) {
     }
     return { limits, features: [...features] };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -34,8 +34,8 @@
     "axios": "1.19.0",
     "jsonwebtoken": "9.0.3",
     "uuid": "14.0.1",
-    "@pipeline-builder/api-core": "3.4.123",
-    "@pipeline-builder/pipeline-data": "3.4.128"
+    "@pipeline-builder/api-core": "3.4.125",
+    "@pipeline-builder/pipeline-data": "3.4.130"
   },
   "keywords": [
     "ci-cd",
@@ -91,7 +91,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "3.4.143",
+  "version": "3.4.145",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },