@pipeline-builder/pipeline-core 0.0.1

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

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

package/lib/config/config-types.js

@@ -0,0 +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  /**\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

@@ -0,0 +1,23 @@
+/**
+ * Effective-entitlement math for the account/entitlement model.
+ *
+ * The canonical "effective limits = tier base + Σ(bundle grants)" computation
+ * lives here — next to the plan/bundle config it operates on — so ANY
+ * account-scoped consumer (billing, and future quota/platform readers) shares
+ * 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, type QuotaTierLimits } from '@pipeline-builder/api-core';
+import type { BundleConfig } from './config-types.js';
+/**
+ * Compute an account's EFFECTIVE entitlements = tier base limits + Σ(bundle
+ * grants × quantity), plus the union of bundle-granted feature flags. A field
+ * already `-1` (unlimited) stays `-1`. Pure; the catalog is passed in.
+ */
+export declare function effectiveEntitlements(tier: QuotaTier, addons: ReadonlyArray<{
+    bundleId: string;
+    quantity: number;
+}>, bundles: readonly BundleConfig[]): {
+    limits: Record<keyof QuotaTierLimits, number>;
+    features: string[];
+};

package/lib/config/entitlements.js

@@ -0,0 +1,46 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Effective-entitlement math for the account/entitlement model.
+ *
+ * The canonical "effective limits = tier base + Σ(bundle grants)" computation
+ * lives here — next to the plan/bundle config it operates on — so ANY
+ * account-scoped consumer (billing, and future quota/platform readers) shares
+ * 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 { getTierLimits } from '@pipeline-builder/api-core';
+/**
+ * Compute an account's EFFECTIVE entitlements = tier base limits + Σ(bundle
+ * grants × quantity), plus the union of bundle-granted feature flags. A field
+ * already `-1` (unlimited) stays `-1`. Pure; the catalog is passed in.
+ */
+export function effectiveEntitlements(tier, addons, bundles) {
+    const limits = { ...getTierLimits(tier) };
+    const features = new Set();
+    const byId = new Map(bundles.map((b) => [b.id, b]));
+    for (const { bundleId, quantity } of addons) {
+        const bundle = byId.get(bundleId);
+        if (!bundle || quantity <= 0)
+            continue;
+        // 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;
+        }
+        for (const f of bundle.features ?? [])
+            features.add(f);
+    }
+    return { limits, features: [...features] };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/config/handler-constants.d.ts

@@ -0,0 +1,10 @@
+/** Default platform URL fallback when PLATFORM_BASE_URL is not set. */
+export declare const DEFAULT_PLATFORM_URL = "https://localhost:8443";
+/** Custom-resource handler timeout (must be < the Lambda's 30s to allow response handling). */
+export declare const HANDLER_TIMEOUT_MS: number;
+/** Platform base URL the handler calls; overridable per-request via ResourceProperties.baseURL. */
+export declare const HANDLER_DEFAULT_BASE_URL: string;
+/** Max retries on transient plugin-lookup failures. */
+export declare const HANDLER_MAX_RETRIES: number;
+/** Base backoff between handler retries (exponential). */
+export declare const HANDLER_RETRY_DELAY_MS: number;

package/lib/config/handler-constants.js

@@ -0,0 +1,39 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Leaf constants for the PluginLookup Lambda handler.
+ *
+ * Deliberately dependency-free (only `process.env` reads, no imports) so the
+ * handler's esbuild bundle stays small — it does not drag in the whole config
+ * machinery via `app-config.ts`. The handler imports THIS module, not
+ * `CoreConstants`.
+ *
+ * This originally guarded a much sharper edge: `app-config.ts` →
+ * `infrastructure-config.ts` → `aws-cdk-lib`, which OOM-killed esbuild
+ * (hundreds of MB, SIGKILL during cold-start synth). That chain is gone —
+ * `infrastructure-config.ts` is now CDK-free and the constructs live behind the
+ * `/cdk` entry point — but the dependency-free contract is still worth keeping.
+ *
+ * `CoreConstants` (app-config.ts) re-exports these so synth-side consumers
+ * (api-server, server-config) keep using `CoreConstants.HANDLER_*` unchanged —
+ * single source of truth lives here.
+ */
+/** Parse an integer env var, falling back on unset OR malformed (NaN). A raw
+ *  `parseInt` returning NaN silently disables the handler's retry loop / axios
+ *  timeout — breaking every plugin lookup — so guard it. Kept inline to preserve
+ *  this module's dependency-free contract (no imports → small Lambda bundle). */
+function envInt(value, fallback) {
+    const n = parseInt(value ?? '', 10);
+    return Number.isNaN(n) ? fallback : n;
+}
+/** Default platform URL fallback when PLATFORM_BASE_URL is not set. */
+export const DEFAULT_PLATFORM_URL = 'https://localhost:8443';
+/** Custom-resource handler timeout (must be < the Lambda's 30s to allow response handling). */
+export const HANDLER_TIMEOUT_MS = envInt(process.env.HANDLER_TIMEOUT_MS, 25000); // 25s
+/** Platform base URL the handler calls; overridable per-request via ResourceProperties.baseURL. */
+export const HANDLER_DEFAULT_BASE_URL = process.env.PLATFORM_BASE_URL || DEFAULT_PLATFORM_URL;
+/** Max retries on transient plugin-lookup failures. */
+export const HANDLER_MAX_RETRIES = envInt(process.env.HANDLER_MAX_RETRIES, 2);
+/** Base backoff between handler retries (exponential). */
+export const HANDLER_RETRY_DELAY_MS = envInt(process.env.HANDLER_RETRY_DELAY_MS, 1000); // 1s
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,66 @@
+import type { AWSConfig, BuildConfig, ComplianceConfig, DatabaseConfig, ObservabilityConfig, PluginBuildConfig, RedisConfig, RegistryConfig } from './config-types.js';
+/**
+ * Load Docker registry configuration from environment variables.
+ *
+ * Environment variables:
+ * - `IMAGE_REGISTRY_HOST` — Registry hostname (default: `'registry'`)
+ * - `IMAGE_REGISTRY_PORT` — Registry port (default: `5000`)
+ * - `IMAGE_REGISTRY_PULL_HOST` — Host an out-of-cluster client (CodeBuild)
+ *   uses to pull plugin images. When unset, derived from `PLATFORM_BASE_URL`'s
+ *   host (the public endpoint CodeBuild can resolve), then `IMAGE_REGISTRY_HOST`.
+ * - `IMAGE_REGISTRY_PULL_PORT` — Port for the above. When unset, derived from
+ *   `PLATFORM_BASE_URL`'s port, then `IMAGE_REGISTRY_PORT`.
+ * - `DOCKER_NETWORK` — Docker network for build/push (default: `''`)
+ * - `IMAGE_REGISTRY_HTTP` — Use plain HTTP instead of HTTPS (default: `true`,
+ *   the in-cluster registry has no TLS).
+ *
+ * @returns Registry configuration
+ */
+export declare function loadRegistryConfig(): RegistryConfig;
+/** Extract host + port from PLATFORM_BASE_URL (e.g. `https://pipeline-builder.com`
+ *  → `{ host: 'pipeline-builder.com', port: 443 }`). Returns null when the value
+ *  is unset or not a valid URL. Exported so the CLI (pipeline-manager) derives
+ *  the registry pull target with the SAME parsing, instead of duplicating it. */
+export declare function parsePlatformBaseUrl(raw?: string): {
+    host: string;
+    port: number;
+} | null;
+export declare function loadRedisConfig(): RedisConfig;
+/**
+ * Load plugin build queue configuration.
+ *
+ * Environment variables:
+ * - `PLUGIN_BUILD_CONCURRENCY` — Max concurrent plugin builds (default: `1`)
+ */
+export declare function loadPluginBuildConfig(): PluginBuildConfig;
+export declare function loadDatabaseConfig(): DatabaseConfig;
+export declare function loadObservabilityConfig(): ObservabilityConfig;
+export declare function loadComplianceConfig(): ComplianceConfig;
+/**
+ * Load plugin build configuration. Builds run against a rootless `moby/buildkit`
+ * sidecar — see `BUILDKIT_HOST`.
+ *
+ * Environment variables:
+ * - `DOCKER_BUILD_TEMP_ROOT` — Temp directory for build contexts (default: `<cwd>/tmp`)
+ * - `DOCKER_BUILD_TIMEOUT_MS` — Build timeout in milliseconds (default: `900000` / 15 min)
+ * - `DOCKER_PUSH_TIMEOUT_MS` — Push timeout in milliseconds (default: `300000` / 5 min)
+ * - `BUILDKIT_HOST` — buildctl `--addr` value for the buildkitd sidecar
+ *   (default: `unix:///run/buildkit/buildkitd.sock`)
+ */
+export declare function loadDockerConfig(): BuildConfig;
+/**
+ * Load AWS infrastructure configuration from environment variables.
+ *
+ * Environment variables:
+ * - `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: `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`)
+ * - `LOG_REMOVAL_POLICY` — `'RETAIN'` or destroy (default: DESTROY)
+ * - `CODEBUILD_COMPUTE_TYPE` — CodeBuild compute type (default: `'SMALL'`)
+ *
+ * @returns AWS infrastructure configuration
+ */
+export declare function loadAWSConfig(): AWSConfig;