@pipeline-builder/pipeline-core 3.4.99 → 3.4.101

package/lib/config/billing-config.js

@@ -13,7 +13,7 @@
  *
  * All defaults match the original hardcoded seed data for backward compatibility.
  */
-import { QUOTA_TIERS } from '@pipeline-builder/api-core';
+import { QUOTA_TIERS, isValidTier } from '@pipeline-builder/api-core';
 // -- Default features ---------------------------------------------------------
 // Derived from each tier's EFFECTIVE quota limits so the marketing copy stays
 // honest when limits change (including via QUOTA_TIER_* env overrides). Per-tier
@@ -135,6 +135,89 @@ export function loadBillingConfig() {
             sortOrder: 3,
         },
     ];
-    return { plans };
+    return { plans, bundles: loadBundles() };
 }
-//# 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 for backward compatibility.\n */\nimport { QUOTA_TIERS, type QuotaTier } from '@pipeline-builder/api-core';\nimport type { BillingConfig, BillingPlanConfig } from './config-types.js';\n\n// -- Default features ---------------------------------------------------------\n// Derived from each tier's EFFECTIVE quota limits so the marketing copy stays\n// honest when limits change (including via QUOTA_TIER_* env overrides). Per-tier\n// perks (support level, dashboards, etc.) are appended.\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    ...perks,\n  ];\n}\n\nconst DEFAULT_DEVELOPER_FEATURES = defaultFeatures('developer', ['Community support']);\nconst DEFAULT_PRO_FEATURES = defaultFeatures('pro', ['Community support', 'Reporting dashboard']);\nconst DEFAULT_TEAM_FEATURES = defaultFeatures('team', [\n  'RBAC & team roles', 'SSO / IdP configs', 'Audit log', 'Priority support',\n]);\nconst DEFAULT_ENTERPRISE_FEATURES = defaultFeatures('enterprise', [\n  'RBAC & team roles', 'SSO / IdP configs', 'Audit log',\n  'Priority support', 'Reporting dashboard', 'Custom integrations',\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  const n = parseInt(envVar, 10);\n  return Number.isNaN(n) ? fallback : n;\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    return Array.isArray(parsed) ? parsed : fallback;\n  } catch {\n    return fallback;\n  }\n}\n\n/**\n * Load billing plan configuration from environment variables.\n */\nexport function loadBillingConfig(): BillingConfig {\n  const plans: BillingPlanConfig[] = [\n    {\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    {\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, 1900),\n        annual: envCents(process.env.BILLING_PLAN_PRO_ANNUAL, 19000),\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    {\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, 4900),\n        annual: envCents(process.env.BILLING_PLAN_TEAM_ANNUAL, 49000),\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    {\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, 9900),\n        annual: envCents(process.env.BILLING_PLAN_ENTERPRISE_ANNUAL, 99000),\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  ];\n\n  return { plans };\n}\n"]}
+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.
+ * Ignored for multi-dimension or feature-only (empty-grant) bundles, and for a
+ * malformed/negative value.
+ */
+function applyGrantOverride(id, grants) {
+    const raw = process.env[`BILLING_BUNDLE_${id.toUpperCase()}_GRANT`];
+    const keys = Object.keys(grants);
+    if (raw === undefined || raw === '' || keys.length !== 1)
+        return grants;
+    const n = parseInt(raw, 10);
+    if (Number.isNaN(n) || n < 0)
+        return grants;
+    // `keys` came from a GrantMap, so its sole key is a QuotaTierLimits field.
+    return { [keys[0]]: n };
+}
+/**
+ * Apply a per-bundle tier-availability override. `BILLING_BUNDLE_<ID>_TIERS` is a
+ * JSON array of tier IDs that may purchase the bundle (e.g. `["developer","pro"]`)
+ * — parallel to the price/grant overrides. Falls back to `defaultTiers` when
+ * unset, malformed, empty, or containing an unknown tier.
+ */
+function applyTiersOverride(id, defaultTiers) {
+    const raw = process.env[`BILLING_BUNDLE_${id.toUpperCase()}_TIERS`];
+    if (!raw)
+        return defaultTiers;
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed) || parsed.length === 0)
+            return defaultTiers;
+        const valid = parsed.filter((t) => typeof t === 'string' && isValidTier(t));
+        return valid.length === parsed.length ? valid : defaultTiers;
+    }
+    catch {
+        return defaultTiers;
+    }
+}
+/**
+ * Purchasable add-on bundles (docs/billing-bundles.md §3). Grants are per-unit
+ * deltas on QuotaTierLimits; prices (cents, `BILLING_BUNDLE_<ID>_MONTHLY` /
+ * `_ANNUAL`), the single-dimension grant amount (`BILLING_BUNDLE_<ID>_GRANT`),
+ * and the purchasable-tier list (`BILLING_BUNDLE_<ID>_TIERS`) are all
+ * env-overridable. Annual ≈ 10× monthly.
+ */
+function loadBundles() {
+    const b = (id, name, description, grants, monthly, availableForTiers, sortOrder, extra = {}) => {
+        // 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);
+        return {
+            id,
+            name,
+            description,
+            grants: applyGrantOverride(id, grants),
+            ...(extra.features ? { features: extra.features } : {}),
+            prices: {
+                monthly: resolvedMonthly,
+                annual: envCents(process.env[`BILLING_BUNDLE_${id.toUpperCase()}_ANNUAL`], resolvedMonthly * 10),
+            },
+            stackable: extra.stackable ?? true,
+            availableForTiers: applyTiersOverride(id, availableForTiers),
+            isActive: true,
+            sortOrder,
+        };
+    };
+    const ALL = ['developer', 'pro', 'team', 'enterprise'];
+    return [
+        // Capacity packs (seats/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.
+        b('seat_pack', 'Seat Pack (+5)', '5 additional member seats', { seats: 5 }, 2500, ALL, 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 }, 1000, ALL, 2),
+        b('api_pack', 'API Pack (+1M)', '1,000,000 additional API calls / period', { apiCalls: 1_000_000 }, 2000, ['developer', 'pro'], 3),
+        b('ai_pack', 'AI Pack (+5k)', '5,000 additional AI calls / period', { aiCalls: 5000 }, 3000, ALL, 4),
+        b('storage_pack', 'Storage Pack (+50 GB)', '50 GB additional registry storage', { storageBytes: 50 * BUNDLE_GB }, 1000, ALL, 5),
+        b('audit_log', 'Audit Log', 'Audit log capability', {}, 2000, ['pro'], 6, { features: ['audit_log'], stackable: false }),
+        b('sso', 'SSO / IdP', 'SSO + up to 5 IdP configs', { idpConfigs: 5 }, 4000, ['pro', 'team'], 7, { features: ['sso'], stackable: false }),
+    ];
+}
+//# 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 for backward compatibility.\n */\nimport { QUOTA_TIERS, isValidTier, type QuotaTier, type QuotaTierLimits } from '@pipeline-builder/api-core';\nimport type { BillingConfig, BillingPlanConfig, BundleConfig } 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// Derived from each tier's EFFECTIVE quota limits so the marketing copy stays\n// honest when limits change (including via QUOTA_TIER_* env overrides). Per-tier\n// perks (support level, dashboards, etc.) are appended.\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    ...perks,\n  ];\n}\n\nconst DEFAULT_DEVELOPER_FEATURES = defaultFeatures('developer', ['Community support']);\nconst DEFAULT_PRO_FEATURES = defaultFeatures('pro', ['Community support', 'Reporting dashboard']);\nconst DEFAULT_TEAM_FEATURES = defaultFeatures('team', [\n  'RBAC & team roles', 'SSO / IdP configs', 'Audit log', 'Priority support',\n]);\nconst DEFAULT_ENTERPRISE_FEATURES = defaultFeatures('enterprise', [\n  'RBAC & team roles', 'SSO / IdP configs', 'Audit log',\n  'Priority support', 'Reporting dashboard', 'Custom integrations',\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  const n = parseInt(envVar, 10);\n  return Number.isNaN(n) ? fallback : n;\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    return Array.isArray(parsed) ? parsed : fallback;\n  } catch {\n    return fallback;\n  }\n}\n\n/**\n * Load billing plan configuration from environment variables.\n */\nexport function loadBillingConfig(): BillingConfig {\n  const plans: BillingPlanConfig[] = [\n    {\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    {\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, 1900),\n        annual: envCents(process.env.BILLING_PLAN_PRO_ANNUAL, 19000),\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    {\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, 4900),\n        annual: envCents(process.env.BILLING_PLAN_TEAM_ANNUAL, 49000),\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    {\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, 9900),\n        annual: envCents(process.env.BILLING_PLAN_ENTERPRISE_ANNUAL, 99000),\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  ];\n\n  return { plans, bundles: loadBundles() };\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 } = {},\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      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  const ALL: QuotaTier[] = ['developer', 'pro', 'team', 'enterprise'];\n  return [\n    // Capacity packs (seats/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    b('seat_pack', 'Seat Pack (+5)', '5 additional member seats', { seats: 5 }, 2500, ALL, 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 }, 1000, ALL, 2),\n    b('api_pack', 'API Pack (+1M)', '1,000,000 additional API calls / period', { apiCalls: 1_000_000 }, 2000, ['developer', 'pro'], 3),\n    b('ai_pack', 'AI Pack (+5k)', '5,000 additional AI calls / period', { aiCalls: 5000 }, 3000, ALL, 4),\n    b('storage_pack', 'Storage Pack (+50 GB)', '50 GB additional registry storage', { storageBytes: 50 * BUNDLE_GB }, 1000, ALL, 5),\n    b('audit_log', 'Audit Log', 'Audit log capability', {}, 2000, ['pro'], 6, { features: ['audit_log'], stackable: false }),\n    b('sso', 'SSO / IdP', 'SSO + up to 5 IdP configs', { idpConfigs: 5 }, 4000, ['pro', 'team'], 7, { features: ['sso'], stackable: false }),\n  ];\n}\n"]}

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

@@ -1,4 +1,4 @@
-import type { QuotaTier } from '@pipeline-builder/api-core';
+import type { QuotaTier, QuotaTierLimits } from '@pipeline-builder/api-core';
 import type { Duration, RemovalPolicy } from 'aws-cdk-lib';
 import type { ComputeType } from 'aws-cdk-lib/aws-codebuild';
 import type { Architecture, Runtime } from 'aws-cdk-lib/aws-lambda';
@@ -252,7 +252,32 @@ export interface BillingPlanConfig {
     readonly isDefault: boolean;
     readonly sortOrder: number;
 }
-/** Billing plans configuration. */
+/**
+ * A purchasable add-on bundle: a quantity-stackable pack that ADDS to the
+ * account's base (tier) limits and adds a recurring line item. See
+ * docs/billing-bundles.md.
+ */
+export interface BundleConfig {
+    readonly id: string;
+    readonly name: string;
+    readonly description: string;
+    /** Per-unit deltas on `QuotaTierLimits` fields, e.g. `{ seats: 5 }`. Keys are
+     *  constrained to real quota fields so a typo is a compile error (was
+     *  `Record<string, number>`, where a misspelled key was silently unenforceable). */
+    readonly grants: Readonly<Partial<Record<keyof QuotaTierLimits, number>>>;
+    /** Feature flags granted by a feature bundle (e.g. `audit_log`). */
+    readonly features?: readonly string[];
+    /** Per-unit price (cents). Stripe multiplies by quantity. */
+    readonly prices: BillingPlanPrices;
+    /** True for stackable resource packs; false for a boolean feature bundle. */
+    readonly stackable: boolean;
+    /** Base tiers this bundle is offered to. */
+    readonly availableForTiers: readonly QuotaTier[];
+    readonly isActive: boolean;
+    readonly sortOrder: number;
+}
+/** Billing plans + add-on bundle configuration. */
 export interface BillingConfig {
     readonly plans: readonly BillingPlanConfig[];
+    readonly bundles: readonly BundleConfig[];
 }

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 } from '@pipeline-builder/api-core';\nimport type { Duration, RemovalPolicy } from 'aws-cdk-lib';\nimport type { ComputeType } from 'aws-cdk-lib/aws-codebuild';\nimport type { Architecture, Runtime } from 'aws-cdk-lib/aws-lambda';\nimport type { RetentionDays } from 'aws-cdk-lib/aws-logs';\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\nexport interface AWSConfig {\n  readonly lambda: {\n    readonly runtime: Runtime;\n    readonly timeout: Duration;\n    readonly memorySize: number;\n    readonly architecture: Architecture;\n    readonly reservedConcurrentExecutions?: number;\n  };\n  readonly logging: {\n    readonly groupName: string;\n    readonly retention: RetentionDays;\n    readonly removalPolicy: RemovalPolicy;\n  };\n  readonly codeBuild: {\n    readonly computeType: ComputeType;\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/** Billing plans configuration. */\nexport interface BillingConfig {\n  readonly plans: readonly BillingPlanConfig[];\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 { Duration, RemovalPolicy } from 'aws-cdk-lib';\nimport type { ComputeType } from 'aws-cdk-lib/aws-codebuild';\nimport type { Architecture, Runtime } from 'aws-cdk-lib/aws-lambda';\nimport type { RetentionDays } from 'aws-cdk-lib/aws-logs';\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\nexport interface AWSConfig {\n  readonly lambda: {\n    readonly runtime: Runtime;\n    readonly timeout: Duration;\n    readonly memorySize: number;\n    readonly architecture: Architecture;\n    readonly reservedConcurrentExecutions?: number;\n  };\n  readonly logging: {\n    readonly groupName: string;\n    readonly retention: RetentionDays;\n    readonly removalPolicy: RemovalPolicy;\n  };\n  readonly codeBuild: {\n    readonly computeType: ComputeType;\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  /** Base tiers this bundle is offered to. */\n  readonly availableForTiers: readonly QuotaTier[];\n  readonly isActive: boolean;\n  readonly sortOrder: number;\n}\n\n/** Billing plans + add-on bundle configuration. */\nexport interface BillingConfig {\n  readonly plans: readonly BillingPlanConfig[];\n  readonly bundles: readonly BundleConfig[];\n}\n"]}

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

@@ -52,9 +52,9 @@ export declare function loadDockerConfig(): BuildConfig;
  * Load AWS infrastructure configuration from environment variables.
  *
  * Environment variables:
- * - `LAMBDA_RUNTIME` — Lambda runtime (default: `'nodejs24.x'`; supports nodejs22.x, nodejs24.x)
+ * - `LAMBDA_RUNTIME` — Lambda runtime (default: `'nodejs24.x'`; unknown values fall back to it)
  * - `LAMBDA_TIMEOUT` — Lambda timeout in seconds (default: `900`)
- * - `LAMBDA_MEMORY_SIZE` — Lambda memory in MB (default: `128`)
+ * - `LAMBDA_MEMORY_SIZE` — Lambda memory in MB (default: `512`)
  * - `LAMBDA_ARCHITECTURE` — `'x86_64'` or ARM (default: ARM_64)
  * - `LOG_GROUP_NAME` — CloudWatch log group (default: `'/pipeline-builder/logs'`)
  * - `LOG_RETENTION` — Log retention in days (default: `7`)

package/lib/config/infrastructure-config.js

@@ -145,9 +145,9 @@ export function loadDockerConfig() {
  * Load AWS infrastructure configuration from environment variables.
  *
  * Environment variables:
- * - `LAMBDA_RUNTIME` — Lambda runtime (default: `'nodejs24.x'`; supports nodejs22.x, nodejs24.x)
+ * - `LAMBDA_RUNTIME` — Lambda runtime (default: `'nodejs24.x'`; unknown values fall back to it)
  * - `LAMBDA_TIMEOUT` — Lambda timeout in seconds (default: `900`)
- * - `LAMBDA_MEMORY_SIZE` — Lambda memory in MB (default: `128`)
+ * - `LAMBDA_MEMORY_SIZE` — Lambda memory in MB (default: `512`)
  * - `LAMBDA_ARCHITECTURE` — `'x86_64'` or ARM (default: ARM_64)
  * - `LOG_GROUP_NAME` — CloudWatch log group (default: `'/pipeline-builder/logs'`)
  * - `LOG_RETENTION` — Log retention in days (default: `7`)
@@ -207,4 +207,4 @@ function parseRetention(days) {
     const parsed = parseInt(days, 10);
     return VALID_RETENTION_DAYS.has(parsed) ? parsed : RetentionDays.ONE_DAY;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"infrastructure-config.js","sourceRoot":"","sources":["../../src/config/infrastructure-config.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport path from 'path';\nimport { Duration, RemovalPolicy } from 'aws-cdk-lib';\nimport { Architecture, Runtime } from 'aws-cdk-lib/aws-lambda';\nimport { RetentionDays } from 'aws-cdk-lib/aws-logs';\nimport type { AWSConfig, BuildConfig, ComplianceConfig, DatabaseConfig, ObservabilityConfig, PluginBuildConfig, RedisConfig, RegistryConfig } from './config-types.js';\nimport { getComputeType } from '../core/pipeline-helpers.js';\n\n/**\n * Load Docker registry configuration from environment variables.\n *\n * Environment variables:\n * - `IMAGE_REGISTRY_HOST` — Registry hostname (default: `'registry'`)\n * - `IMAGE_REGISTRY_PORT` — Registry port (default: `5000`)\n * - `IMAGE_REGISTRY_PULL_HOST` — Host an out-of-cluster client (CodeBuild)\n *   uses to pull plugin images. When unset, derived from `PLATFORM_BASE_URL`'s\n *   host (the public endpoint CodeBuild can resolve), then `IMAGE_REGISTRY_HOST`.\n * - `IMAGE_REGISTRY_PULL_PORT` — Port for the above. When unset, derived from\n *   `PLATFORM_BASE_URL`'s port, then `IMAGE_REGISTRY_PORT`.\n * - `DOCKER_NETWORK` — Docker network for build/push (default: `''`)\n * - `IMAGE_REGISTRY_HTTP` — Use plain HTTP instead of HTTPS (default: `true`,\n *   the in-cluster registry has no TLS).\n *\n * @returns Registry configuration\n */\nexport function loadRegistryConfig(): RegistryConfig {\n  const host = process.env.IMAGE_REGISTRY_HOST || 'registry';\n  const port = parseInt(process.env.IMAGE_REGISTRY_PORT || '5000', 10);\n  // When no explicit pull host is set, derive it from PLATFORM_BASE_URL — the\n  // public platform endpoint an out-of-cluster client (AWS CodeBuild) can\n  // resolve, unlike the in-cluster `registry` ClusterIP. Only falls back to the\n  // in-cluster host when PLATFORM_BASE_URL is unset/unparseable (e.g. local).\n  const platform = parsePlatformBaseUrl(process.env.PLATFORM_BASE_URL);\n  return {\n    host,\n    port,\n    pullHost: process.env.IMAGE_REGISTRY_PULL_HOST || platform?.host || host,\n    pullPort: process.env.IMAGE_REGISTRY_PULL_PORT\n      ? parseInt(process.env.IMAGE_REGISTRY_PULL_PORT, 10)\n      : (platform?.port ?? port),\n    network: process.env.DOCKER_NETWORK || '',\n    http: process.env.IMAGE_REGISTRY_HTTP !== 'false',\n  };\n}\n\n/** Extract host + port from PLATFORM_BASE_URL (e.g. `https://pipeline-builder.com`\n *  → `{ host: 'pipeline-builder.com', port: 443 }`). Returns null when the value\n *  is unset or not a valid URL. Exported so the CLI (pipeline-manager) derives\n *  the registry pull target with the SAME parsing, instead of duplicating it. */\nexport function parsePlatformBaseUrl(raw?: string): { host: string; port: number } | null {\n  if (!raw) return null;\n  try {\n    const u = new URL(raw);\n    // A scheme-less value like `host:8443` parses with a custom protocol and an\n    // EMPTY hostname — reject it so callers fall back rather than derive a\n    // host-less endpoint.\n    if (!u.hostname) return null;\n    const port = u.port ? parseInt(u.port, 10) : (u.protocol === 'https:' ? 443 : 80);\n    return { host: u.hostname, port };\n  } catch {\n    return null;\n  }\n}\n\nexport function loadRedisConfig(): RedisConfig {\n  return {\n    host: process.env.REDIS_HOST || 'localhost',\n    port: parseInt(process.env.REDIS_PORT || '6379', 10),\n  };\n}\n\n/**\n * Load plugin build queue configuration.\n *\n * Environment variables:\n * - `PLUGIN_BUILD_CONCURRENCY` — Max concurrent plugin builds (default: `1`)\n */\nexport function loadPluginBuildConfig(): PluginBuildConfig {\n  return {\n    concurrency: parseInt(process.env.PLUGIN_BUILD_CONCURRENCY || '1', 10),\n    maxAttempts: parseInt(process.env.PLUGIN_BUILD_MAX_ATTEMPTS || '2', 10),\n    backoffDelayMs: parseInt(process.env.PLUGIN_BUILD_BACKOFF_DELAY_MS || '5000', 10),\n    workerTimeoutMs: parseInt(process.env.PLUGIN_BUILD_WORKER_TIMEOUT_MS || '10000', 10),\n    tempDirMaxAgeMs: parseInt(process.env.TEMP_DIR_MAX_AGE_MS || '14400000', 10),\n    dlqMaxAttempts: parseInt(process.env.PLUGIN_DLQ_MAX_ATTEMPTS || '3', 10),\n    dlqBackoffBaseMs: parseInt(process.env.PLUGIN_DLQ_BACKOFF_BASE_MS || '300000', 10),\n    dlqMaxSize: parseInt(process.env.PLUGIN_DLQ_MAX_SIZE || '20', 10),\n  };\n}\n\nexport function loadDatabaseConfig(): DatabaseConfig {\n  return {\n    postgres: {\n      host: process.env.DB_HOST || 'postgres',\n      port: parseInt(process.env.DB_PORT || '5432', 10),\n      database: process.env.DATABASE || 'pipeline_builder',\n      user: process.env.DB_USER || 'postgres',\n      password: process.env.DB_PASSWORD || '',\n    },\n    drizzle: {\n      maxPoolSize: parseInt(process.env.DRIZZLE_MAX_POOL_SIZE || '20', 10),\n      idleTimeoutMillis: parseInt(process.env.DRIZZLE_IDLE_TIMEOUT_MILLIS || '30000', 10),\n      connectionTimeoutMillis: parseInt(process.env.DRIZZLE_CONNECTION_TIMEOUT_MILLIS || '10000', 10),\n    },\n  };\n}\n\nexport function loadObservabilityConfig(): ObservabilityConfig {\n  return {\n    logLevel: process.env.LOG_LEVEL || 'info',\n    logFormat: process.env.LOG_FORMAT || 'json',\n    serviceName: process.env.SERVICE_NAME || 'api',\n    tracing: {\n      enabled: process.env.OTEL_TRACING_ENABLED === 'true',\n      endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT || 'http://localhost:4318/v1/traces',\n    },\n  };\n}\n\nexport function loadComplianceConfig(): ComplianceConfig {\n  return {\n    scanSchedulerIntervalMs: parseInt(process.env.SCAN_SCHEDULER_INTERVAL_MS || '60000', 10),\n    systemOrgScansEnabled: process.env.SYSTEM_ORG_SCANS_ENABLED === 'true',\n    scanLockTtlMs: parseInt(process.env.SCAN_LOCK_TTL_MS || '300000', 10),\n    digestSchedulerIntervalMs: parseInt(process.env.DIGEST_SCHEDULER_INTERVAL_MS || '3600000', 10),\n    digestLockTtlMs: parseInt(process.env.DIGEST_LOCK_TTL_MS || '300000', 10),\n  };\n}\n\n/**\n * Load plugin build configuration. Builds run against a rootless `moby/buildkit`\n * sidecar — see `BUILDKIT_HOST`.\n *\n * Environment variables:\n * - `DOCKER_BUILD_TEMP_ROOT` — Temp directory for build contexts (default: `<cwd>/tmp`)\n * - `DOCKER_BUILD_TIMEOUT_MS` — Build timeout in milliseconds (default: `900000` / 15 min)\n * - `DOCKER_PUSH_TIMEOUT_MS` — Push timeout in milliseconds (default: `300000` / 5 min)\n * - `BUILDKIT_HOST` — buildctl `--addr` value for the buildkitd sidecar\n *   (default: `unix:///run/buildkit/buildkitd.sock`)\n */\nexport function loadDockerConfig(): BuildConfig {\n  return {\n    tempRoot: process.env.DOCKER_BUILD_TEMP_ROOT || path.join(process.cwd(), 'tmp'),\n    timeoutMs: parseInt(process.env.DOCKER_BUILD_TIMEOUT_MS || '900000', 10),\n    pushTimeoutMs: parseInt(process.env.DOCKER_PUSH_TIMEOUT_MS || '300000', 10),\n    buildkitAddr: process.env.BUILDKIT_HOST || 'unix:///run/buildkit/buildkitd.sock',\n  };\n}\n\n/**\n * Load AWS infrastructure configuration from environment variables.\n *\n * Environment variables:\n * - `LAMBDA_RUNTIME` — Lambda runtime (default: `'nodejs24.x'`; supports nodejs22.x, nodejs24.x)\n * - `LAMBDA_TIMEOUT` — Lambda timeout in seconds (default: `900`)\n * - `LAMBDA_MEMORY_SIZE` — Lambda memory in MB (default: `128`)\n * - `LAMBDA_ARCHITECTURE` — `'x86_64'` or ARM (default: ARM_64)\n * - `LOG_GROUP_NAME` — CloudWatch log group (default: `'/pipeline-builder/logs'`)\n * - `LOG_RETENTION` — Log retention in days (default: `7`)\n * - `LOG_REMOVAL_POLICY` — `'RETAIN'` or destroy (default: DESTROY)\n * - `CODEBUILD_COMPUTE_TYPE` — CodeBuild compute type (default: `'SMALL'`)\n *\n * @returns AWS infrastructure configuration\n */\nexport function loadAWSConfig(): AWSConfig {\n  return {\n    lambda: {\n      runtime: parseRuntime(process.env.LAMBDA_RUNTIME || 'nodejs24.x'),\n      timeout: Duration.seconds(parseInt(process.env.LAMBDA_TIMEOUT || '900', 10)),\n      memorySize: parseInt(process.env.LAMBDA_MEMORY_SIZE || '512', 10),\n      architecture: process.env.LAMBDA_ARCHITECTURE === 'x86_64'\n        ? Architecture.X86_64\n        : Architecture.ARM_64,\n      reservedConcurrentExecutions: process.env.LAMBDA_RESERVED_CONCURRENCY\n        ? parseInt(process.env.LAMBDA_RESERVED_CONCURRENCY, 10)\n        : undefined,\n    },\n\n    logging: {\n      groupName: process.env.LOG_GROUP_NAME || '/pipeline-builder/logs',\n      retention: parseRetention(process.env.LOG_RETENTION || '7'),\n      removalPolicy: process.env.LOG_REMOVAL_POLICY === 'RETAIN'\n        ? RemovalPolicy.RETAIN\n        : RemovalPolicy.DESTROY,\n    },\n\n    codeBuild: {\n      computeType: getComputeType(process.env.CODEBUILD_COMPUTE_TYPE || 'SMALL'),\n      defaultImage: process.env.CODEBUILD_DEFAULT_IMAGE || 'pipeline-bootstrap:1.0',\n    },\n  };\n}\n\n/**\n * Parse Lambda runtime string into a CDK Runtime enum value.\n *\n * @param runtime - Runtime string (e.g. `'nodejs24.x'`)\n * @returns CDK Runtime enum; falls back to NODEJS_24_X for unknown values\n */\nfunction parseRuntime(runtime: string): Runtime {\n  const runtimeMap: Record<string, Runtime> = {\n    'nodejs24.x': Runtime.NODEJS_24_X,\n  };\n  return runtimeMap[runtime] || Runtime.NODEJS_24_X;\n}\n\n/**\n * Parse log retention days string into a CDK RetentionDays enum value.\n * RetentionDays enum values are the numeric day counts themselves,\n * so we parse the string and check if it's a valid enum member.\n *\n * @param days - Retention period in days as a string (e.g. `'30'`)\n * @returns CDK RetentionDays enum; falls back to ONE_DAY for unknown values\n */\nconst VALID_RETENTION_DAYS = new Set(Object.values(RetentionDays).filter((v): v is number => typeof v === 'number'));\n\nfunction parseRetention(days: string): RetentionDays {\n  const parsed = parseInt(days, 10);\n  return VALID_RETENTION_DAYS.has(parsed) ? parsed as RetentionDays : RetentionDays.ONE_DAY;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"infrastructure-config.js","sourceRoot":"","sources":["../../src/config/infrastructure-config.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport path from 'path';\nimport { Duration, RemovalPolicy } from 'aws-cdk-lib';\nimport { Architecture, Runtime } from 'aws-cdk-lib/aws-lambda';\nimport { RetentionDays } from 'aws-cdk-lib/aws-logs';\nimport type { AWSConfig, BuildConfig, ComplianceConfig, DatabaseConfig, ObservabilityConfig, PluginBuildConfig, RedisConfig, RegistryConfig } from './config-types.js';\nimport { getComputeType } from '../core/pipeline-helpers.js';\n\n/**\n * Load Docker registry configuration from environment variables.\n *\n * Environment variables:\n * - `IMAGE_REGISTRY_HOST` — Registry hostname (default: `'registry'`)\n * - `IMAGE_REGISTRY_PORT` — Registry port (default: `5000`)\n * - `IMAGE_REGISTRY_PULL_HOST` — Host an out-of-cluster client (CodeBuild)\n *   uses to pull plugin images. When unset, derived from `PLATFORM_BASE_URL`'s\n *   host (the public endpoint CodeBuild can resolve), then `IMAGE_REGISTRY_HOST`.\n * - `IMAGE_REGISTRY_PULL_PORT` — Port for the above. When unset, derived from\n *   `PLATFORM_BASE_URL`'s port, then `IMAGE_REGISTRY_PORT`.\n * - `DOCKER_NETWORK` — Docker network for build/push (default: `''`)\n * - `IMAGE_REGISTRY_HTTP` — Use plain HTTP instead of HTTPS (default: `true`,\n *   the in-cluster registry has no TLS).\n *\n * @returns Registry configuration\n */\nexport function loadRegistryConfig(): RegistryConfig {\n  const host = process.env.IMAGE_REGISTRY_HOST || 'registry';\n  const port = parseInt(process.env.IMAGE_REGISTRY_PORT || '5000', 10);\n  // When no explicit pull host is set, derive it from PLATFORM_BASE_URL — the\n  // public platform endpoint an out-of-cluster client (AWS CodeBuild) can\n  // resolve, unlike the in-cluster `registry` ClusterIP. Only falls back to the\n  // in-cluster host when PLATFORM_BASE_URL is unset/unparseable (e.g. local).\n  const platform = parsePlatformBaseUrl(process.env.PLATFORM_BASE_URL);\n  return {\n    host,\n    port,\n    pullHost: process.env.IMAGE_REGISTRY_PULL_HOST || platform?.host || host,\n    pullPort: process.env.IMAGE_REGISTRY_PULL_PORT\n      ? parseInt(process.env.IMAGE_REGISTRY_PULL_PORT, 10)\n      : (platform?.port ?? port),\n    network: process.env.DOCKER_NETWORK || '',\n    http: process.env.IMAGE_REGISTRY_HTTP !== 'false',\n  };\n}\n\n/** Extract host + port from PLATFORM_BASE_URL (e.g. `https://pipeline-builder.com`\n *  → `{ host: 'pipeline-builder.com', port: 443 }`). Returns null when the value\n *  is unset or not a valid URL. Exported so the CLI (pipeline-manager) derives\n *  the registry pull target with the SAME parsing, instead of duplicating it. */\nexport function parsePlatformBaseUrl(raw?: string): { host: string; port: number } | null {\n  if (!raw) return null;\n  try {\n    const u = new URL(raw);\n    // A scheme-less value like `host:8443` parses with a custom protocol and an\n    // EMPTY hostname — reject it so callers fall back rather than derive a\n    // host-less endpoint.\n    if (!u.hostname) return null;\n    const port = u.port ? parseInt(u.port, 10) : (u.protocol === 'https:' ? 443 : 80);\n    return { host: u.hostname, port };\n  } catch {\n    return null;\n  }\n}\n\nexport function loadRedisConfig(): RedisConfig {\n  return {\n    host: process.env.REDIS_HOST || 'localhost',\n    port: parseInt(process.env.REDIS_PORT || '6379', 10),\n  };\n}\n\n/**\n * Load plugin build queue configuration.\n *\n * Environment variables:\n * - `PLUGIN_BUILD_CONCURRENCY` — Max concurrent plugin builds (default: `1`)\n */\nexport function loadPluginBuildConfig(): PluginBuildConfig {\n  return {\n    concurrency: parseInt(process.env.PLUGIN_BUILD_CONCURRENCY || '1', 10),\n    maxAttempts: parseInt(process.env.PLUGIN_BUILD_MAX_ATTEMPTS || '2', 10),\n    backoffDelayMs: parseInt(process.env.PLUGIN_BUILD_BACKOFF_DELAY_MS || '5000', 10),\n    workerTimeoutMs: parseInt(process.env.PLUGIN_BUILD_WORKER_TIMEOUT_MS || '10000', 10),\n    tempDirMaxAgeMs: parseInt(process.env.TEMP_DIR_MAX_AGE_MS || '14400000', 10),\n    dlqMaxAttempts: parseInt(process.env.PLUGIN_DLQ_MAX_ATTEMPTS || '3', 10),\n    dlqBackoffBaseMs: parseInt(process.env.PLUGIN_DLQ_BACKOFF_BASE_MS || '300000', 10),\n    dlqMaxSize: parseInt(process.env.PLUGIN_DLQ_MAX_SIZE || '20', 10),\n  };\n}\n\nexport function loadDatabaseConfig(): DatabaseConfig {\n  return {\n    postgres: {\n      host: process.env.DB_HOST || 'postgres',\n      port: parseInt(process.env.DB_PORT || '5432', 10),\n      database: process.env.DATABASE || 'pipeline_builder',\n      user: process.env.DB_USER || 'postgres',\n      password: process.env.DB_PASSWORD || '',\n    },\n    drizzle: {\n      maxPoolSize: parseInt(process.env.DRIZZLE_MAX_POOL_SIZE || '20', 10),\n      idleTimeoutMillis: parseInt(process.env.DRIZZLE_IDLE_TIMEOUT_MILLIS || '30000', 10),\n      connectionTimeoutMillis: parseInt(process.env.DRIZZLE_CONNECTION_TIMEOUT_MILLIS || '10000', 10),\n    },\n  };\n}\n\nexport function loadObservabilityConfig(): ObservabilityConfig {\n  return {\n    logLevel: process.env.LOG_LEVEL || 'info',\n    logFormat: process.env.LOG_FORMAT || 'json',\n    serviceName: process.env.SERVICE_NAME || 'api',\n    tracing: {\n      enabled: process.env.OTEL_TRACING_ENABLED === 'true',\n      endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT || 'http://localhost:4318/v1/traces',\n    },\n  };\n}\n\nexport function loadComplianceConfig(): ComplianceConfig {\n  return {\n    scanSchedulerIntervalMs: parseInt(process.env.SCAN_SCHEDULER_INTERVAL_MS || '60000', 10),\n    systemOrgScansEnabled: process.env.SYSTEM_ORG_SCANS_ENABLED === 'true',\n    scanLockTtlMs: parseInt(process.env.SCAN_LOCK_TTL_MS || '300000', 10),\n    digestSchedulerIntervalMs: parseInt(process.env.DIGEST_SCHEDULER_INTERVAL_MS || '3600000', 10),\n    digestLockTtlMs: parseInt(process.env.DIGEST_LOCK_TTL_MS || '300000', 10),\n  };\n}\n\n/**\n * Load plugin build configuration. Builds run against a rootless `moby/buildkit`\n * sidecar — see `BUILDKIT_HOST`.\n *\n * Environment variables:\n * - `DOCKER_BUILD_TEMP_ROOT` — Temp directory for build contexts (default: `<cwd>/tmp`)\n * - `DOCKER_BUILD_TIMEOUT_MS` — Build timeout in milliseconds (default: `900000` / 15 min)\n * - `DOCKER_PUSH_TIMEOUT_MS` — Push timeout in milliseconds (default: `300000` / 5 min)\n * - `BUILDKIT_HOST` — buildctl `--addr` value for the buildkitd sidecar\n *   (default: `unix:///run/buildkit/buildkitd.sock`)\n */\nexport function loadDockerConfig(): BuildConfig {\n  return {\n    tempRoot: process.env.DOCKER_BUILD_TEMP_ROOT || path.join(process.cwd(), 'tmp'),\n    timeoutMs: parseInt(process.env.DOCKER_BUILD_TIMEOUT_MS || '900000', 10),\n    pushTimeoutMs: parseInt(process.env.DOCKER_PUSH_TIMEOUT_MS || '300000', 10),\n    buildkitAddr: process.env.BUILDKIT_HOST || 'unix:///run/buildkit/buildkitd.sock',\n  };\n}\n\n/**\n * Load AWS infrastructure configuration from environment variables.\n *\n * Environment variables:\n * - `LAMBDA_RUNTIME` — Lambda runtime (default: `'nodejs24.x'`; unknown values fall back to it)\n * - `LAMBDA_TIMEOUT` — Lambda timeout in seconds (default: `900`)\n * - `LAMBDA_MEMORY_SIZE` — Lambda memory in MB (default: `512`)\n * - `LAMBDA_ARCHITECTURE` — `'x86_64'` or ARM (default: ARM_64)\n * - `LOG_GROUP_NAME` — CloudWatch log group (default: `'/pipeline-builder/logs'`)\n * - `LOG_RETENTION` — Log retention in days (default: `7`)\n * - `LOG_REMOVAL_POLICY` — `'RETAIN'` or destroy (default: DESTROY)\n * - `CODEBUILD_COMPUTE_TYPE` — CodeBuild compute type (default: `'SMALL'`)\n *\n * @returns AWS infrastructure configuration\n */\nexport function loadAWSConfig(): AWSConfig {\n  return {\n    lambda: {\n      runtime: parseRuntime(process.env.LAMBDA_RUNTIME || 'nodejs24.x'),\n      timeout: Duration.seconds(parseInt(process.env.LAMBDA_TIMEOUT || '900', 10)),\n      memorySize: parseInt(process.env.LAMBDA_MEMORY_SIZE || '512', 10),\n      architecture: process.env.LAMBDA_ARCHITECTURE === 'x86_64'\n        ? Architecture.X86_64\n        : Architecture.ARM_64,\n      reservedConcurrentExecutions: process.env.LAMBDA_RESERVED_CONCURRENCY\n        ? parseInt(process.env.LAMBDA_RESERVED_CONCURRENCY, 10)\n        : undefined,\n    },\n\n    logging: {\n      groupName: process.env.LOG_GROUP_NAME || '/pipeline-builder/logs',\n      retention: parseRetention(process.env.LOG_RETENTION || '7'),\n      removalPolicy: process.env.LOG_REMOVAL_POLICY === 'RETAIN'\n        ? RemovalPolicy.RETAIN\n        : RemovalPolicy.DESTROY,\n    },\n\n    codeBuild: {\n      computeType: getComputeType(process.env.CODEBUILD_COMPUTE_TYPE || 'SMALL'),\n      defaultImage: process.env.CODEBUILD_DEFAULT_IMAGE || 'pipeline-bootstrap:1.0',\n    },\n  };\n}\n\n/**\n * Parse Lambda runtime string into a CDK Runtime enum value.\n *\n * @param runtime - Runtime string (e.g. `'nodejs24.x'`)\n * @returns CDK Runtime enum; falls back to NODEJS_24_X for unknown values\n */\nfunction parseRuntime(runtime: string): Runtime {\n  const runtimeMap: Record<string, Runtime> = {\n    'nodejs24.x': Runtime.NODEJS_24_X,\n  };\n  return runtimeMap[runtime] || Runtime.NODEJS_24_X;\n}\n\n/**\n * Parse log retention days string into a CDK RetentionDays enum value.\n * RetentionDays enum values are the numeric day counts themselves,\n * so we parse the string and check if it's a valid enum member.\n *\n * @param days - Retention period in days as a string (e.g. `'30'`)\n * @returns CDK RetentionDays enum; falls back to ONE_DAY for unknown values\n */\nconst VALID_RETENTION_DAYS = new Set(Object.values(RetentionDays).filter((v): v is number => typeof v === 'number'));\n\nfunction parseRetention(days: string): RetentionDays {\n  const parsed = parseInt(days, 10);\n  return VALID_RETENTION_DAYS.has(parsed) ? parsed as RetentionDays : RetentionDays.ONE_DAY;\n}\n"]}

package/lib/core/pipeline-types.d.ts

@@ -121,10 +121,6 @@ export declare const MetadataKeys: {
     readonly PIPELINE_VARIABLES: "aws:cdk:operations:variables";
     readonly KMS_KEY_ARN: "aws:cdk:encryption:kmskeyarn";
 };
-/**
- * Type for MetadataKeys values
- */
-export type MetadataKey = typeof MetadataKeys[keyof typeof MetadataKeys];
 /**
  * Prefix for AWS CDK metadata keys.
  * Keys with this prefix are handled by the metadata extraction functions

package/lib/core/pipeline-types.js

@@ -128,4 +128,4 @@ export const MetadataKeys = {
  * (metadataForCodePipeline, etc.) and should NOT be passed as CodeBuild environment variables.
  */
 export const CDK_METADATA_PREFIX = 'aws:cdk:';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipeline-types.js","sourceRoot":"","sources":["../../src/core/pipeline-types.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { CodeCommitSourceConfig, CodeStarSourceConfig, GitHubSourceConfig, S3SourceConfig } from '../pipeline/source-types.js';\n\n// Re-export shared types from api-core for convenience\nexport { AccessModifier, ComputeType, PluginType, type MetaDataType } from '@pipeline-builder/api-core';\n\n/**\n * Pipeline trigger behavior.\n *\n * @property NONE - Manual trigger only, pipeline does not start automatically\n * @property AUTO - Automatic trigger on source changes (S3/GitHub: polling, CodeStar: push-based webhook)\n */\nexport const TriggerType = {\n  NONE: 'NONE',\n  /** Automatic trigger on source changes. Uses polling for S3/GitHub, push-based webhook for CodeStar. */\n  AUTO: 'AUTO',\n  /** Scheduled trigger via EventBridge rule. Requires a cron expression in the source options. */\n  SCHEDULE: 'SCHEDULE',\n} as const;\nexport type TriggerType = (typeof TriggerType)[keyof typeof TriggerType];\n\n/**\n * Union type of all supported pipeline source types\n *\n * Supported sources:\n * - S3SourceConfig: Source code from S3 bucket\n * - GitHubSourceConfig: Source code from GitHub repository\n * - CodeStarSourceConfig: Source code via CodeStar connection (GitHub, Bitbucket, GitLab)\n * - CodeCommitSourceConfig: Source code from AWS CodeCommit repository\n */\nexport type SourceType = S3SourceConfig | GitHubSourceConfig | CodeStarSourceConfig | CodeCommitSourceConfig;\n\n/**\n * Constants for metadata keys to avoid string typos.\n *\n * Key format: `aws:cdk:{namespace}:{property}` (all lowercase).\n * These match the keys produced by `getCustomKey(namespace, property)`\n * and looked up by `buildConfigFromMetadata`.\n *\n * @example\n * ```typescript\n * const metadata = {\n *   [MetadataKeys.SELF_MUTATION]: true,\n *   [MetadataKeys.PUBLISH_ASSETS_IN_PARALLEL]: true\n * };\n * ```\n */\nexport const MetadataKeys = {\n  // ── CodePipeline (namespace: pipelines:codepipeline) ──\n  SELF_MUTATION: 'aws:cdk:pipelines:codepipeline:selfmutation',\n  CROSS_ACCOUNT_KEYS: 'aws:cdk:pipelines:codepipeline:crossaccountkeys',\n  DOCKER_ENABLED_FOR_SELF_MUTATION: 'aws:cdk:pipelines:codepipeline:dockerenabledforselfmutation',\n  DOCKER_ENABLED_FOR_SYNTH: 'aws:cdk:pipelines:codepipeline:dockerenabledforsynth',\n  ENABLE_KEY_ROTATION: 'aws:cdk:pipelines:codepipeline:enablekeyrotation',\n  PUBLISH_ASSETS_IN_PARALLEL: 'aws:cdk:pipelines:codepipeline:publishassetsinparallel',\n  REUSE_CROSS_REGION_SUPPORT_STACKS: 'aws:cdk:pipelines:codepipeline:reusecrossregionsupportstacks',\n  USE_CHANGE_SETS: 'aws:cdk:pipelines:codepipeline:usechangesets',\n  USE_PIPELINE_ROLE_FOR_ACTIONS: 'aws:cdk:pipelines:codepipeline:usepipelineroleforactions',\n  ARTIFACT_BUCKET: 'aws:cdk:pipelines:codepipeline:artifactbucket',\n  ASSET_PUBLISHING_CODE_BUILD_DEFAULTS: 'aws:cdk:pipelines:codepipeline:assetpublishingcodebuilddefaults',\n  CDK_ASSETS_CLI_VERSION: 'aws:cdk:pipelines:codepipeline:cdkassetscliversion',\n  CLI_VERSION: 'aws:cdk:pipelines:codepipeline:cliversion',\n  CODE_BUILD_DEFAULTS: 'aws:cdk:pipelines:codepipeline:codebuilddefaults',\n  CODE_PIPELINE: 'aws:cdk:pipelines:codepipeline:codepipeline',\n  CROSS_REGION_REPLICATION_BUCKETS: 'aws:cdk:pipelines:codepipeline:crossregionreplicationbuckets',\n  DOCKER_CREDENTIALS: 'aws:cdk:pipelines:codepipeline:dockercredentials',\n  PIPELINE_NAME: 'aws:cdk:pipelines:codepipeline:pipelinename',\n  PIPELINE_TYPE: 'aws:cdk:pipelines:codepipeline:pipelinetype',\n  PIPELINE_ROLE: 'aws:cdk:pipelines:codepipeline:role',\n  SELF_MUTATION_CODE_BUILD_DEFAULTS: 'aws:cdk:pipelines:codepipeline:selfmutationcodebuilddefaults',\n  SYNTH: 'aws:cdk:pipelines:codepipeline:synth',\n  SYNTH_CODE_BUILD_DEFAULTS: 'aws:cdk:pipelines:codepipeline:synthcodebuilddefaults',\n\n  // ── CodeBuildStep (namespace: pipelines:codebuildstep) ──\n  ACTION_ROLE: 'aws:cdk:pipelines:codebuildstep:actionrole',\n  ADDITIONAL_INPUTS: 'aws:cdk:pipelines:codebuildstep:additionalinputs',\n  BUILD_ENVIRONMENT: 'aws:cdk:pipelines:codebuildstep:buildenvironment',\n  CACHE: 'aws:cdk:pipelines:codebuildstep:cache',\n  COMMANDS: 'aws:cdk:pipelines:codebuildstep:commands',\n  CODE_BUILD_ENV: 'aws:cdk:pipelines:codebuildstep:env',\n  ENV_FROM_CFN_OUTPUTS: 'aws:cdk:pipelines:codebuildstep:envfromcfnoutputs',\n  FILE_SYSTEM_LOCATIONS: 'aws:cdk:pipelines:codebuildstep:filesystemlocations',\n  INPUT: 'aws:cdk:pipelines:codebuildstep:input',\n  INSTALL_COMMANDS: 'aws:cdk:pipelines:codebuildstep:installcommands',\n  LOGGING: 'aws:cdk:pipelines:codebuildstep:logging',\n  PARTIAL_BUILD_SPEC: 'aws:cdk:pipelines:codebuildstep:partialbuildspec',\n  PRIMARY_OUTPUT_DIRECTORY: 'aws:cdk:pipelines:codebuildstep:primaryoutputdirectory',\n  PROJECT_NAME: 'aws:cdk:pipelines:codebuildstep:projectname',\n  STEP_ROLE: 'aws:cdk:pipelines:codebuildstep:role',\n  ROLE_POLICY_STATEMENTS: 'aws:cdk:pipelines:codebuildstep:rolepolicystatements',\n  TIMEOUT: 'aws:cdk:pipelines:codebuildstep:timeout',\n\n  // ── ShellStep (namespace: pipelines:shellstep) ──\n  SHELL_ADDITIONAL_INPUTS: 'aws:cdk:pipelines:shellstep:additionalinputs',\n  SHELL_COMMANDS: 'aws:cdk:pipelines:shellstep:commands',\n  SHELL_ENV: 'aws:cdk:pipelines:shellstep:env',\n  SHELL_ENV_FROM_CFN_OUTPUTS: 'aws:cdk:pipelines:shellstep:envfromcfnoutputs',\n  SHELL_INPUT: 'aws:cdk:pipelines:shellstep:input',\n  SHELL_INSTALL_COMMANDS: 'aws:cdk:pipelines:shellstep:installcommands',\n  SHELL_PRIMARY_OUTPUT_DIRECTORY: 'aws:cdk:pipelines:shellstep:primaryoutputdirectory',\n\n  // ── BuildEnvironment (namespace: codebuild:buildenvironment) ──\n  PRIVILEGED: 'aws:cdk:codebuild:buildenvironment:privileged',\n  BUILD_IMAGE: 'aws:cdk:codebuild:buildenvironment:buildimage',\n  CERTIFICATE: 'aws:cdk:codebuild:buildenvironment:certificate',\n  COMPUTE_TYPE: 'aws:cdk:codebuild:buildenvironment:computetype',\n  DOCKER_SERVER: 'aws:cdk:codebuild:buildenvironment:dockerserver',\n  ENVIRONMENT_VARIABLES: 'aws:cdk:codebuild:buildenvironment:environmentvariables',\n  FLEET: 'aws:cdk:codebuild:buildenvironment:fleet',\n\n  // ── Network configuration (namespace: ec2:network) ──\n  NETWORK_TYPE: 'aws:cdk:ec2:network:type',\n  NETWORK_VPC_ID: 'aws:cdk:ec2:network:vpcid',\n  NETWORK_SUBNET_IDS: 'aws:cdk:ec2:network:subnetids',\n  NETWORK_SUBNET_TYPE: 'aws:cdk:ec2:network:subnettype',\n  NETWORK_AVAILABILITY_ZONES: 'aws:cdk:ec2:network:availabilityzones',\n  NETWORK_SUBNET_GROUP_NAME: 'aws:cdk:ec2:network:subnetgroupname',\n  NETWORK_SECURITY_GROUP_IDS: 'aws:cdk:ec2:network:securitygroupids',\n  NETWORK_TAGS: 'aws:cdk:ec2:network:tags',\n  NETWORK_VPC_NAME: 'aws:cdk:ec2:network:vpcname',\n  NETWORK_REGION: 'aws:cdk:ec2:network:region',\n\n  // ── IAM role configuration (namespace: iam:role) ──\n  ROLE_TYPE: 'aws:cdk:iam:role:type',\n  ROLE_ARN: 'aws:cdk:iam:role:rolearn',\n  ROLE_NAME: 'aws:cdk:iam:role:rolename',\n  ROLE_MUTABLE: 'aws:cdk:iam:role:mutable',\n\n  // ── Security group configuration (namespace: ec2:securitygroup) ──\n  SECURITY_GROUP_TYPE: 'aws:cdk:ec2:securitygroup:type',\n  SECURITY_GROUP_IDS: 'aws:cdk:ec2:securitygroup:securitygroupids',\n  SECURITY_GROUP_MUTABLE: 'aws:cdk:ec2:securitygroup:mutable',\n  SECURITY_GROUP_NAME: 'aws:cdk:ec2:securitygroup:securitygroupname',\n  SECURITY_GROUP_VPC_ID: 'aws:cdk:ec2:securitygroup:vpcid',\n\n  // ── Notifications (namespace: notifications) ──\n  NOTIFICATION_TOPIC_ARN: 'aws:cdk:notifications:topic:arn',\n  NOTIFICATION_EVENTS: 'aws:cdk:notifications:events',\n\n  // ── Pipeline operations (namespace: operations — custom synth in PipelineBuilder) ──\n  ENABLE_EXECUTION_EVENTS: 'aws:cdk:operations:executionevents',\n  ENABLE_METRICS: 'aws:cdk:operations:metrics',\n  ARTIFACT_RETENTION_DAYS: 'aws:cdk:operations:artifactretentiondays',\n  PIPELINE_VARIABLES: 'aws:cdk:operations:variables',\n\n  // ── Encryption (namespace: encryption — custom synth in PipelineBuilder) ──\n  KMS_KEY_ARN: 'aws:cdk:encryption:kmskeyarn',\n} as const;\n\n/**\n * Type for MetadataKeys values\n */\nexport type MetadataKey = typeof MetadataKeys[keyof typeof MetadataKeys];\n\n/**\n * Prefix for AWS CDK metadata keys.\n * Keys with this prefix are handled by the metadata extraction functions\n * (metadataForCodePipeline, etc.) and should NOT be passed as CodeBuild environment variables.\n */\nexport const CDK_METADATA_PREFIX = 'aws:cdk:';"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipeline-types.js","sourceRoot":"","sources":["../../src/core/pipeline-types.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { CodeCommitSourceConfig, CodeStarSourceConfig, GitHubSourceConfig, S3SourceConfig } from '../pipeline/source-types.js';\n\n// Re-export shared types from api-core for convenience\nexport { AccessModifier, ComputeType, PluginType, type MetaDataType } from '@pipeline-builder/api-core';\n\n/**\n * Pipeline trigger behavior.\n *\n * @property NONE - Manual trigger only, pipeline does not start automatically\n * @property AUTO - Automatic trigger on source changes (S3/GitHub: polling, CodeStar: push-based webhook)\n */\nexport const TriggerType = {\n  NONE: 'NONE',\n  /** Automatic trigger on source changes. Uses polling for S3/GitHub, push-based webhook for CodeStar. */\n  AUTO: 'AUTO',\n  /** Scheduled trigger via EventBridge rule. Requires a cron expression in the source options. */\n  SCHEDULE: 'SCHEDULE',\n} as const;\nexport type TriggerType = (typeof TriggerType)[keyof typeof TriggerType];\n\n/**\n * Union type of all supported pipeline source types\n *\n * Supported sources:\n * - S3SourceConfig: Source code from S3 bucket\n * - GitHubSourceConfig: Source code from GitHub repository\n * - CodeStarSourceConfig: Source code via CodeStar connection (GitHub, Bitbucket, GitLab)\n * - CodeCommitSourceConfig: Source code from AWS CodeCommit repository\n */\nexport type SourceType = S3SourceConfig | GitHubSourceConfig | CodeStarSourceConfig | CodeCommitSourceConfig;\n\n/**\n * Constants for metadata keys to avoid string typos.\n *\n * Key format: `aws:cdk:{namespace}:{property}` (all lowercase).\n * These match the keys produced by `getCustomKey(namespace, property)`\n * and looked up by `buildConfigFromMetadata`.\n *\n * @example\n * ```typescript\n * const metadata = {\n *   [MetadataKeys.SELF_MUTATION]: true,\n *   [MetadataKeys.PUBLISH_ASSETS_IN_PARALLEL]: true\n * };\n * ```\n */\nexport const MetadataKeys = {\n  // ── CodePipeline (namespace: pipelines:codepipeline) ──\n  SELF_MUTATION: 'aws:cdk:pipelines:codepipeline:selfmutation',\n  CROSS_ACCOUNT_KEYS: 'aws:cdk:pipelines:codepipeline:crossaccountkeys',\n  DOCKER_ENABLED_FOR_SELF_MUTATION: 'aws:cdk:pipelines:codepipeline:dockerenabledforselfmutation',\n  DOCKER_ENABLED_FOR_SYNTH: 'aws:cdk:pipelines:codepipeline:dockerenabledforsynth',\n  ENABLE_KEY_ROTATION: 'aws:cdk:pipelines:codepipeline:enablekeyrotation',\n  PUBLISH_ASSETS_IN_PARALLEL: 'aws:cdk:pipelines:codepipeline:publishassetsinparallel',\n  REUSE_CROSS_REGION_SUPPORT_STACKS: 'aws:cdk:pipelines:codepipeline:reusecrossregionsupportstacks',\n  USE_CHANGE_SETS: 'aws:cdk:pipelines:codepipeline:usechangesets',\n  USE_PIPELINE_ROLE_FOR_ACTIONS: 'aws:cdk:pipelines:codepipeline:usepipelineroleforactions',\n  ARTIFACT_BUCKET: 'aws:cdk:pipelines:codepipeline:artifactbucket',\n  ASSET_PUBLISHING_CODE_BUILD_DEFAULTS: 'aws:cdk:pipelines:codepipeline:assetpublishingcodebuilddefaults',\n  CDK_ASSETS_CLI_VERSION: 'aws:cdk:pipelines:codepipeline:cdkassetscliversion',\n  CLI_VERSION: 'aws:cdk:pipelines:codepipeline:cliversion',\n  CODE_BUILD_DEFAULTS: 'aws:cdk:pipelines:codepipeline:codebuilddefaults',\n  CODE_PIPELINE: 'aws:cdk:pipelines:codepipeline:codepipeline',\n  CROSS_REGION_REPLICATION_BUCKETS: 'aws:cdk:pipelines:codepipeline:crossregionreplicationbuckets',\n  DOCKER_CREDENTIALS: 'aws:cdk:pipelines:codepipeline:dockercredentials',\n  PIPELINE_NAME: 'aws:cdk:pipelines:codepipeline:pipelinename',\n  PIPELINE_TYPE: 'aws:cdk:pipelines:codepipeline:pipelinetype',\n  PIPELINE_ROLE: 'aws:cdk:pipelines:codepipeline:role',\n  SELF_MUTATION_CODE_BUILD_DEFAULTS: 'aws:cdk:pipelines:codepipeline:selfmutationcodebuilddefaults',\n  SYNTH: 'aws:cdk:pipelines:codepipeline:synth',\n  SYNTH_CODE_BUILD_DEFAULTS: 'aws:cdk:pipelines:codepipeline:synthcodebuilddefaults',\n\n  // ── CodeBuildStep (namespace: pipelines:codebuildstep) ──\n  ACTION_ROLE: 'aws:cdk:pipelines:codebuildstep:actionrole',\n  ADDITIONAL_INPUTS: 'aws:cdk:pipelines:codebuildstep:additionalinputs',\n  BUILD_ENVIRONMENT: 'aws:cdk:pipelines:codebuildstep:buildenvironment',\n  CACHE: 'aws:cdk:pipelines:codebuildstep:cache',\n  COMMANDS: 'aws:cdk:pipelines:codebuildstep:commands',\n  CODE_BUILD_ENV: 'aws:cdk:pipelines:codebuildstep:env',\n  ENV_FROM_CFN_OUTPUTS: 'aws:cdk:pipelines:codebuildstep:envfromcfnoutputs',\n  FILE_SYSTEM_LOCATIONS: 'aws:cdk:pipelines:codebuildstep:filesystemlocations',\n  INPUT: 'aws:cdk:pipelines:codebuildstep:input',\n  INSTALL_COMMANDS: 'aws:cdk:pipelines:codebuildstep:installcommands',\n  LOGGING: 'aws:cdk:pipelines:codebuildstep:logging',\n  PARTIAL_BUILD_SPEC: 'aws:cdk:pipelines:codebuildstep:partialbuildspec',\n  PRIMARY_OUTPUT_DIRECTORY: 'aws:cdk:pipelines:codebuildstep:primaryoutputdirectory',\n  PROJECT_NAME: 'aws:cdk:pipelines:codebuildstep:projectname',\n  STEP_ROLE: 'aws:cdk:pipelines:codebuildstep:role',\n  ROLE_POLICY_STATEMENTS: 'aws:cdk:pipelines:codebuildstep:rolepolicystatements',\n  TIMEOUT: 'aws:cdk:pipelines:codebuildstep:timeout',\n\n  // ── ShellStep (namespace: pipelines:shellstep) ──\n  SHELL_ADDITIONAL_INPUTS: 'aws:cdk:pipelines:shellstep:additionalinputs',\n  SHELL_COMMANDS: 'aws:cdk:pipelines:shellstep:commands',\n  SHELL_ENV: 'aws:cdk:pipelines:shellstep:env',\n  SHELL_ENV_FROM_CFN_OUTPUTS: 'aws:cdk:pipelines:shellstep:envfromcfnoutputs',\n  SHELL_INPUT: 'aws:cdk:pipelines:shellstep:input',\n  SHELL_INSTALL_COMMANDS: 'aws:cdk:pipelines:shellstep:installcommands',\n  SHELL_PRIMARY_OUTPUT_DIRECTORY: 'aws:cdk:pipelines:shellstep:primaryoutputdirectory',\n\n  // ── BuildEnvironment (namespace: codebuild:buildenvironment) ──\n  PRIVILEGED: 'aws:cdk:codebuild:buildenvironment:privileged',\n  BUILD_IMAGE: 'aws:cdk:codebuild:buildenvironment:buildimage',\n  CERTIFICATE: 'aws:cdk:codebuild:buildenvironment:certificate',\n  COMPUTE_TYPE: 'aws:cdk:codebuild:buildenvironment:computetype',\n  DOCKER_SERVER: 'aws:cdk:codebuild:buildenvironment:dockerserver',\n  ENVIRONMENT_VARIABLES: 'aws:cdk:codebuild:buildenvironment:environmentvariables',\n  FLEET: 'aws:cdk:codebuild:buildenvironment:fleet',\n\n  // ── Network configuration (namespace: ec2:network) ──\n  NETWORK_TYPE: 'aws:cdk:ec2:network:type',\n  NETWORK_VPC_ID: 'aws:cdk:ec2:network:vpcid',\n  NETWORK_SUBNET_IDS: 'aws:cdk:ec2:network:subnetids',\n  NETWORK_SUBNET_TYPE: 'aws:cdk:ec2:network:subnettype',\n  NETWORK_AVAILABILITY_ZONES: 'aws:cdk:ec2:network:availabilityzones',\n  NETWORK_SUBNET_GROUP_NAME: 'aws:cdk:ec2:network:subnetgroupname',\n  NETWORK_SECURITY_GROUP_IDS: 'aws:cdk:ec2:network:securitygroupids',\n  NETWORK_TAGS: 'aws:cdk:ec2:network:tags',\n  NETWORK_VPC_NAME: 'aws:cdk:ec2:network:vpcname',\n  NETWORK_REGION: 'aws:cdk:ec2:network:region',\n\n  // ── IAM role configuration (namespace: iam:role) ──\n  ROLE_TYPE: 'aws:cdk:iam:role:type',\n  ROLE_ARN: 'aws:cdk:iam:role:rolearn',\n  ROLE_NAME: 'aws:cdk:iam:role:rolename',\n  ROLE_MUTABLE: 'aws:cdk:iam:role:mutable',\n\n  // ── Security group configuration (namespace: ec2:securitygroup) ──\n  SECURITY_GROUP_TYPE: 'aws:cdk:ec2:securitygroup:type',\n  SECURITY_GROUP_IDS: 'aws:cdk:ec2:securitygroup:securitygroupids',\n  SECURITY_GROUP_MUTABLE: 'aws:cdk:ec2:securitygroup:mutable',\n  SECURITY_GROUP_NAME: 'aws:cdk:ec2:securitygroup:securitygroupname',\n  SECURITY_GROUP_VPC_ID: 'aws:cdk:ec2:securitygroup:vpcid',\n\n  // ── Notifications (namespace: notifications) ──\n  NOTIFICATION_TOPIC_ARN: 'aws:cdk:notifications:topic:arn',\n  NOTIFICATION_EVENTS: 'aws:cdk:notifications:events',\n\n  // ── Pipeline operations (namespace: operations — custom synth in PipelineBuilder) ──\n  ENABLE_EXECUTION_EVENTS: 'aws:cdk:operations:executionevents',\n  ENABLE_METRICS: 'aws:cdk:operations:metrics',\n  ARTIFACT_RETENTION_DAYS: 'aws:cdk:operations:artifactretentiondays',\n  PIPELINE_VARIABLES: 'aws:cdk:operations:variables',\n\n  // ── Encryption (namespace: encryption — custom synth in PipelineBuilder) ──\n  KMS_KEY_ARN: 'aws:cdk:encryption:kmskeyarn',\n} as const;\n\n/**\n * Prefix for AWS CDK metadata keys.\n * Keys with this prefix are handled by the metadata extraction functions\n * (metadataForCodePipeline, etc.) and should NOT be passed as CodeBuild environment variables.\n */\nexport const CDK_METADATA_PREFIX = 'aws:cdk:';"]}

package/lib/index.d.ts

@@ -27,12 +27,9 @@
  * **Re-exports from api-core**
  * - ErrorCode, createLogger
  *
- * **Re-exports from pipeline-data**
- * - db, schema, getConnection, closeConnection  database access
- * - CrudService, BaseEntity  CRUD service infrastructure
- * - All query condition builders and filter types
- * - Compliance domain types (RuleSeverity, RuleTarget, etc.)
- * - drizzleRows, drizzleCount  type helpers
+ * The Postgres/Drizzle data layer (db, schema, CrudService, query builders,
+ * filter/compliance types, etc.) is NOT re-exported here  import those
+ * directly from `@pipeline-builder/pipeline-data`.
  */
 export * from './config/app-config.js';
 export * from './config/config-types.js';
@@ -47,7 +44,6 @@ export { replaceNonAlphanumeric, extractMetadataEnv } from './core/pipeline-help
 export { buildConfigFromMetadata, metadataForCodePipeline, metadataForCodeBuildStep, metadataForShellStep, metadataForBuildEnvironment, } from './core/metadata-builder.js';
 export * from './core/artifact-manager.js';
 export { ErrorCode, createLogger, } from '@pipeline-builder/api-core';
-export { db, getConnection, closeConnection, schema, tenantContext, runWithTenantContext, getTenantContext, withTenantTx, type TenantContext, buildPluginConditions, buildPipelineConditions, buildMessageConditions, validateMessageFilter, buildCompliancePolicyConditions, buildComplianceRuleConditions, buildComplianceExemptionConditions, buildComplianceAuditConditions, buildComplianceScanConditions, buildPublishedRuleCatalogConditions, buildComplianceRuleSubscriptionConditions, type PluginFilter, type PipelineFilter, type MessageFilter, type CompliancePolicyFilter, type ComplianceRuleFilter, type ComplianceExemptionFilter, type ComplianceAuditFilter, type ComplianceScanFilter, type ComplianceRuleSubscriptionFilter, type PluginSecret, type RuleSeverity, type RuleTarget, type RuleOperator, type RuleConditionMode, type RuleScope, type RuleCondition, type ComplianceRoleType, CrudService, type BaseEntity, drizzleRows, drizzleCount, runMigrations, type MigrateOptions, reportingService, } from '@pipeline-builder/pipeline-data';
 export * from './pipeline/source-types.js';
 export * from './pipeline/step-types.js';
 export * from './pipeline/stage-builder.js';

package/lib/index.js

@@ -29,12 +29,9 @@
  * **Re-exports from api-core**
  * - ErrorCode, createLogger
  *
- * **Re-exports from pipeline-data**
- * - db, schema, getConnection, closeConnection  database access
- * - CrudService, BaseEntity  CRUD service infrastructure
- * - All query condition builders and filter types
- * - Compliance domain types (RuleSeverity, RuleTarget, etc.)
- * - drizzleRows, drizzleCount  type helpers
+ * The Postgres/Drizzle data layer (db, schema, CrudService, query builders,
+ * filter/compliance types, etc.) is NOT re-exported here  import those
+ * directly from `@pipeline-builder/pipeline-data`.
  */
 // Configuration
 export * from './config/app-config.js';
@@ -52,24 +49,6 @@ export { buildConfigFromMetadata, metadataForCodePipeline, metadataForCodeBuildS
 export * from './core/artifact-manager.js';
 // Re-export from api-core (only items consumed by external packages)
 export { ErrorCode, createLogger, } from '@pipeline-builder/api-core';
-// Re-export database layer from pipeline-data (only items consumed externally)
-export { 
-// Database connection
-db, getConnection, closeConnection, 
-// Schema & tables
-schema, 
-// Tenant-context primitives (Postgres RLS enforcement)
-tenantContext, runWithTenantContext, getTenantContext, withTenantTx, 
-// Query builders
-buildPluginConditions, buildPipelineConditions, buildMessageConditions, validateMessageFilter, buildCompliancePolicyConditions, buildComplianceRuleConditions, buildComplianceExemptionConditions, buildComplianceAuditConditions, buildComplianceScanConditions, buildPublishedRuleCatalogConditions, buildComplianceRuleSubscriptionConditions, 
-// CRUD service
-CrudService, 
-// Drizzle type helpers
-drizzleRows, drizzleCount, 
-// Migration runner (idempotent startup hook)
-runMigrations, 
-// Reporting service (cache invalidation hook for plugin/reporting events)
-reportingService, } from '@pipeline-builder/pipeline-data';
 // Pipeline (CDK constructs)
 export * from './pipeline/source-types.js';
 export * from './pipeline/step-types.js';
@@ -79,4 +58,4 @@ export * from './pipeline/plugin-lookup.js';
 export { PipelineConfiguration } from './pipeline/pipeline-configuration.js';
 // Template engine  synth-time scripting for pipeline config + plugin specs
 export * from './template/index.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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