@pipeline-builder/pipeline-core 3.4.134 → 3.4.136

package/lib/pipeline/plugin-spec.d.ts

@@ -0,0 +1,138 @@
+/**
+ * The `PluginSpec` domain type — the shape of a plugin's declared contract as
+ * stored in the database and exchanged over the API.
+ *
+ * Kept in its own module, apart from the synth-time authoring types in
+ * `step-types.ts`, because those reference CDK types (`Construct`,
+ * `IFileSetProducer`, CodeBuild's `ComputeType`) while this one is pure data.
+ * API services consume `PluginSpec`; only the CDK entry point consumes the rest.
+ */
+import type { ComputeType, PluginType } from '../core/pipeline-types.js';
+/**
+ * Plugin spec defining plugin behavior and requirements.
+ * This is typically loaded from a plugin spec file (plugin-spec.yaml).
+ */
+export interface PluginSpec {
+    /**
+     * Unique identifier for the plugin
+     * @example 'nodejs-build'
+     */
+    readonly name: string;
+    /**
+     * Human-readable description of what the plugin does
+     * @example 'Builds and tests Node.js applications'
+     */
+    readonly description?: string;
+    /**
+     * Keywords for plugin discovery and categorization
+     * @example ['nodejs', 'typescript', 'build', 'test']
+     */
+    readonly keywords?: string[];
+    /**
+     * Plugin category for AI-assisted selection and organization.
+     * One of: language, security, quality, testing, deploy, artifact,
+     *         infrastructure, monitoring, notification, ai
+     */
+    readonly category?: string;
+    /**
+     * Semantic version of the plugin
+     * @example '1.0.0'
+     */
+    readonly version?: string;
+    /**
+     * Type of pipeline step this plugin creates
+     * @default PluginType.CODE_BUILD_STEP
+     */
+    readonly pluginType?: PluginType;
+    /**
+     * CodeBuild compute resource size to use
+     * @default ComputeType.SMALL
+     */
+    readonly computeType?: ComputeType;
+    /**
+     * Maximum execution time in minutes.
+     * Used as fallback when the pipeline step doesn't set timeout.
+     * @default 60 (AWS CodeBuild default)
+     */
+    readonly timeout?: number;
+    /**
+     * What happens when this step fails.
+     * - 'fail': Stop the pipeline (default)
+     * - 'warn': Log a warning and continue
+     * - 'ignore': Silently continue
+     * @default 'fail'
+     */
+    readonly failureBehavior?: 'fail' | 'warn' | 'ignore';
+    /**
+     * Secret requirements for this plugin.
+     * Declares named secrets the plugin expects at build time.
+     */
+    readonly secrets?: Array<{
+        name: string;
+        required: boolean;
+        description?: string;
+    }>;
+    /**
+     * Directory containing the primary build output artifacts
+     * @example 'dist'
+     */
+    readonly primaryOutputDirectory?: string;
+    /**
+     * Additional metadata that can be accessed during plugin execution
+     * Keys should use the format 'aws:cdk:{namespace}:{key}' (all lowercase)
+     */
+    readonly metadata?: Record<string, string | number | boolean>;
+    /**
+     * Path to Dockerfile or Dockerfile content
+     * Used to build the container environment for this plugin
+     */
+    readonly dockerfile?: string;
+    /**
+     * Commands to run during the install phase
+     * Typically used for installing dependencies
+     * @example ['npm ci', 'npm run build']
+     */
+    readonly installCommands?: string[];
+    /**
+     * Commands to run during the build/execution phase
+     * These are the main commands that perform the plugin's work
+     * @example ['npm test', 'npm run deploy']
+     */
+    readonly commands?: string[];
+    /**
+     * Environment variables to set in the build environment
+     * @example { API_URL: 'https://api.example.com', LOG_LEVEL: 'info' }
+     */
+    readonly env?: Record<string, string>;
+    /**
+     * Docker build arguments passed via --build-arg at image build time.
+     * Used to parameterize Dockerfile ARG values when building the plugin image.
+     * @example { PYTHON_VERSION: '3.12', NODE_ENV: 'production' }
+     */
+    readonly buildArgs?: Record<string, string>;
+    /**
+     * Pipeline metadata keys the plugin references via `{{ pipeline.metadata.X }}`.
+     * Declared as a contract — pipelines using this plugin must supply all
+     * listed keys unless the template uses `| default: '...'`.
+     * @example ['env', 'namespace', 'clusterName']
+     */
+    readonly requiredMetadata?: string[];
+    /**
+     * Pipeline vars keys the plugin references via `{{ pipeline.vars.X }}`.
+     * @example ['branch', 'slackChannel']
+     */
+    readonly requiredVars?: string[];
+    /**
+     * Optional type declarations for the metadata keys listed in `requiredMetadata`.
+     * Used at upload time to verify that coercion filters (`| number`, `| bool`,
+     * `| json`) match the declared type — e.g. `{{ pipeline.metadata.count | number }}`
+     * requires `count: 'number'` here, otherwise the plugin is rejected.
+     * Keys not declared default to `'string'`.
+     * @example { count: 'number', enabled: 'bool' }
+     */
+    readonly metadataTypes?: Record<string, 'string' | 'number' | 'bool' | 'json'>;
+    /**
+     * Optional type declarations for vars keys (same semantics as `metadataTypes`).
+     */
+    readonly varsTypes?: Record<string, 'string' | 'number' | 'bool' | 'json'>;
+}

package/lib/pipeline/plugin-spec.js

@@ -0,0 +1,4 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/pipeline/source-builder.js

@@ -145,4 +145,4 @@ export class SourceBuilder {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"source-builder.js","sourceRoot":"","sources":["../../src/pipeline/source-builder.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createLogger } from '@pipeline-builder/api-core';\nimport { SecretValue } from 'aws-cdk-lib';\nimport { Repository } from 'aws-cdk-lib/aws-codecommit';\nimport { CodeCommitTrigger, GitHubTrigger, S3Trigger } from 'aws-cdk-lib/aws-codepipeline-actions';\nimport { Bucket } from 'aws-cdk-lib/aws-s3';\nimport { CodePipelineSource } from 'aws-cdk-lib/pipelines';\nimport { Construct } from 'constructs';\nimport type { PipelineConfiguration } from './pipeline-configuration.js';\nimport type { GitHubOptions } from './source-types.js';\nimport { UniqueId } from '../core/id-generator.js';\nimport { unwrapSecret } from '../core/pipeline-helpers.js';\nimport { TriggerType, type SourceType } from '../core/pipeline-types.js';\n\nconst log = createLogger('source-builder');\n\n/** A Secrets Manager ARN (`arn:aws:secretsmanager:...`, incl. partition variants). */\nconst SECRETS_MANAGER_ARN = /^arn:aws[a-z-]*:secretsmanager:/i;\n/** A `secretsmanager:<secret-name>` shorthand reference. */\nconst SECRETS_MANAGER_REF_PREFIX = 'secretsmanager:';\n\n/**\n * Creates the appropriate CodePipelineSource based on the pipeline configuration.\n *\n * Supports S3, GitHub, CodeStar connection, and CodeCommit sources.\n *\n * **Note on SCHEDULE triggers:** Scheduled pipelines require an EventBridge rule\n * that starts the pipeline on a cron schedule. The source trigger is set to NONE\n * (no polling/webhook). The EventBridge rule must be created separately as a\n * pipeline-level construct, not at the source level. The `schedule` field on\n * source options captures the cron expression for API/frontend use. The actual\n * EventBridge rule creation is implemented in `PipelineBuilder` (the\n * `ScheduleRule` `events.Rule` targeting the pipeline), not at the source level.\n *\n * @example\n * ```typescript\n * const sourceBuilder = new SourceBuilder(this, config);\n * const source = sourceBuilder.create(uniqueId);\n * ```\n */\nexport class SourceBuilder {\n  constructor(\n    private readonly scope: Construct,\n    private readonly config: PipelineConfiguration,\n  ) {}\n\n  /**\n   * Creates the appropriate CodePipelineSource based on source type\n   */\n  create(id: UniqueId): CodePipelineSource {\n    switch (this.config.source.type) {\n      case 's3':\n        return this.createS3Source(id);\n      case 'github':\n        return this.createGitHubSource();\n      case 'codestar':\n        return this.createCodeStarSource();\n      case 'codecommit':\n        return this.createCodeCommitSource(id);\n      default: {\n        const _exhaustive: never = this.config.source;\n        throw new Error(`Unsupported source type: ${(_exhaustive as SourceType).type}`);\n      }\n    }\n  }\n\n  /**\n   * Creates an S3 source for the pipeline\n   */\n  private createS3Source(id: UniqueId): CodePipelineSource {\n    const options = this.config.getS3Options();\n\n    const bucket = Bucket.fromBucketName(\n      this.scope,\n      id.generate('source:bucket'),\n      options.bucketName,\n    );\n\n    const trigger =\n      options.trigger === TriggerType.AUTO ? S3Trigger.EVENTS : S3Trigger.NONE;\n\n    return CodePipelineSource.s3(bucket, options.objectKey, { trigger });\n  }\n\n  /**\n   * Creates a GitHub source for the pipeline\n   */\n  private createGitHubSource(): CodePipelineSource {\n    const options = this.config.getGitHubOptions();\n\n    return CodePipelineSource.gitHub(options.repo, options.branch, {\n      trigger: options.trigger === TriggerType.AUTO ? GitHubTrigger.POLL : GitHubTrigger.NONE,\n      authentication: this.resolveGitHubAuthentication(options),\n    });\n  }\n\n  /**\n   * Resolve the GitHub authentication token into a {@link SecretValue} without\n   * leaking the token value into the synthesized template.\n   *\n   * - `undefined` token → no authentication (CDK default).\n   * - A `SecretValue` → passed through (already a reference, never plaintext).\n   * - A Secrets Manager ARN or `secretsmanager:<name>` string → resolved via\n   *   `SecretValue.secretsManager`, so only the reference lands in the template.\n   * - A genuine raw plaintext token → rejected by default (it would be baked as\n   *   plaintext into CloudFormation/CDK context). Only when\n   *   `allowPlainTextToken` is explicitly set is it embedded via\n   *   `SecretValue.unsafePlainText`, and a loud warning is emitted.\n   */\n  private resolveGitHubAuthentication(options: GitHubOptions): SecretValue | undefined {\n    const token = options.token;\n    if (token === undefined) return undefined;\n\n    // A SecretValue is already a reference (e.g. Secrets Manager) — never plaintext.\n    if (typeof token !== 'string') return token;\n\n    // A string that names a Secrets Manager secret is resolved to a reference so\n    // only the pointer — not the token — is written to the template / CDK context.\n    if (SECRETS_MANAGER_ARN.test(token)) {\n      return SecretValue.secretsManager(token);\n    }\n    if (token.toLowerCase().startsWith(SECRETS_MANAGER_REF_PREFIX)) {\n      return SecretValue.secretsManager(token.slice(SECRETS_MANAGER_REF_PREFIX.length));\n    }\n\n    // Genuine raw plaintext token — this is the exposure. Reject by default and\n    // point the caller at a secret reference or a CodeStar connection.\n    if (!options.allowPlainTextToken) {\n      throw new Error(\n        'GitHub source `token` is a raw plaintext value, which would be baked into the ' +\n        'synthesized CloudFormation template (and CDK context / stack state). Provide a ' +\n        'Secrets Manager reference instead — an `arn:aws:secretsmanager:...` ARN, a ' +\n        '`secretsmanager:<secret-name>` string, or a `SecretValue.secretsManager(...)` — or ' +\n        'prefer a CodeStar connection (`type: \"codestar\"`). To intentionally embed the token ' +\n        'in plaintext, set `allowPlainTextToken: true`.',\n      );\n    }\n\n    log.warn(\n      'GitHub source `token` is being embedded as PLAINTEXT in the synthesized CloudFormation ' +\n      'template because `allowPlainTextToken` is set. Anyone with template, CDK context, or ' +\n      'stack state access can read this token. Use a Secrets Manager reference or a CodeStar ' +\n      'connection instead.',\n    );\n    return SecretValue.unsafePlainText(token);\n  }\n\n  /**\n   * Creates a CodeStar connection source for the pipeline\n   */\n  private createCodeStarSource(): CodePipelineSource {\n    const options = this.config.getCodeStarOptions();\n\n    return CodePipelineSource.connection(options.repo, options.branch, {\n      connectionArn: unwrapSecret(options.connectionArn),\n      triggerOnPush: options.trigger === TriggerType.AUTO,\n      codeBuildCloneOutput: options.codeBuildCloneOutput,\n    });\n  }\n\n  /**\n   * Creates a CodeCommit source for the pipeline\n   */\n  private createCodeCommitSource(id: UniqueId): CodePipelineSource {\n    const options = this.config.getCodeCommitOptions();\n\n    const repository = Repository.fromRepositoryName(\n      this.scope,\n      id.generate('source:repo'),\n      options.repositoryName,\n    );\n\n    return CodePipelineSource.codeCommit(repository, options.branch ?? 'main', {\n      trigger: options.trigger === TriggerType.AUTO ? CodeCommitTrigger.EVENTS : CodeCommitTrigger.NONE,\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"source-builder.js","sourceRoot":"","sources":["../../src/pipeline/source-builder.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createLogger } from '@pipeline-builder/api-core';\nimport { SecretValue } from 'aws-cdk-lib';\nimport { Repository } from 'aws-cdk-lib/aws-codecommit';\nimport { CodeCommitTrigger, GitHubTrigger, S3Trigger } from 'aws-cdk-lib/aws-codepipeline-actions';\nimport { Bucket } from 'aws-cdk-lib/aws-s3';\nimport { CodePipelineSource } from 'aws-cdk-lib/pipelines';\nimport { Construct } from 'constructs';\nimport type { PipelineConfiguration } from './pipeline-configuration.js';\nimport type { GitHubOptions, SourceType } from './source-types.js';\nimport { UniqueId } from '../core/id-generator.js';\nimport { unwrapSecret } from '../core/pipeline-helpers.js';\nimport { TriggerType } from '../core/pipeline-types.js';\n\nconst log = createLogger('source-builder');\n\n/** A Secrets Manager ARN (`arn:aws:secretsmanager:...`, incl. partition variants). */\nconst SECRETS_MANAGER_ARN = /^arn:aws[a-z-]*:secretsmanager:/i;\n/** A `secretsmanager:<secret-name>` shorthand reference. */\nconst SECRETS_MANAGER_REF_PREFIX = 'secretsmanager:';\n\n/**\n * Creates the appropriate CodePipelineSource based on the pipeline configuration.\n *\n * Supports S3, GitHub, CodeStar connection, and CodeCommit sources.\n *\n * **Note on SCHEDULE triggers:** Scheduled pipelines require an EventBridge rule\n * that starts the pipeline on a cron schedule. The source trigger is set to NONE\n * (no polling/webhook). The EventBridge rule must be created separately as a\n * pipeline-level construct, not at the source level. The `schedule` field on\n * source options captures the cron expression for API/frontend use. The actual\n * EventBridge rule creation is implemented in `PipelineBuilder` (the\n * `ScheduleRule` `events.Rule` targeting the pipeline), not at the source level.\n *\n * @example\n * ```typescript\n * const sourceBuilder = new SourceBuilder(this, config);\n * const source = sourceBuilder.create(uniqueId);\n * ```\n */\nexport class SourceBuilder {\n  constructor(\n    private readonly scope: Construct,\n    private readonly config: PipelineConfiguration,\n  ) {}\n\n  /**\n   * Creates the appropriate CodePipelineSource based on source type\n   */\n  create(id: UniqueId): CodePipelineSource {\n    switch (this.config.source.type) {\n      case 's3':\n        return this.createS3Source(id);\n      case 'github':\n        return this.createGitHubSource();\n      case 'codestar':\n        return this.createCodeStarSource();\n      case 'codecommit':\n        return this.createCodeCommitSource(id);\n      default: {\n        const _exhaustive: never = this.config.source;\n        throw new Error(`Unsupported source type: ${(_exhaustive as SourceType).type}`);\n      }\n    }\n  }\n\n  /**\n   * Creates an S3 source for the pipeline\n   */\n  private createS3Source(id: UniqueId): CodePipelineSource {\n    const options = this.config.getS3Options();\n\n    const bucket = Bucket.fromBucketName(\n      this.scope,\n      id.generate('source:bucket'),\n      options.bucketName,\n    );\n\n    const trigger =\n      options.trigger === TriggerType.AUTO ? S3Trigger.EVENTS : S3Trigger.NONE;\n\n    return CodePipelineSource.s3(bucket, options.objectKey, { trigger });\n  }\n\n  /**\n   * Creates a GitHub source for the pipeline\n   */\n  private createGitHubSource(): CodePipelineSource {\n    const options = this.config.getGitHubOptions();\n\n    return CodePipelineSource.gitHub(options.repo, options.branch, {\n      trigger: options.trigger === TriggerType.AUTO ? GitHubTrigger.POLL : GitHubTrigger.NONE,\n      authentication: this.resolveGitHubAuthentication(options),\n    });\n  }\n\n  /**\n   * Resolve the GitHub authentication token into a {@link SecretValue} without\n   * leaking the token value into the synthesized template.\n   *\n   * - `undefined` token → no authentication (CDK default).\n   * - A `SecretValue` → passed through (already a reference, never plaintext).\n   * - A Secrets Manager ARN or `secretsmanager:<name>` string → resolved via\n   *   `SecretValue.secretsManager`, so only the reference lands in the template.\n   * - A genuine raw plaintext token → rejected by default (it would be baked as\n   *   plaintext into CloudFormation/CDK context). Only when\n   *   `allowPlainTextToken` is explicitly set is it embedded via\n   *   `SecretValue.unsafePlainText`, and a loud warning is emitted.\n   */\n  private resolveGitHubAuthentication(options: GitHubOptions): SecretValue | undefined {\n    const token = options.token;\n    if (token === undefined) return undefined;\n\n    // A SecretValue is already a reference (e.g. Secrets Manager) — never plaintext.\n    if (typeof token !== 'string') return token;\n\n    // A string that names a Secrets Manager secret is resolved to a reference so\n    // only the pointer — not the token — is written to the template / CDK context.\n    if (SECRETS_MANAGER_ARN.test(token)) {\n      return SecretValue.secretsManager(token);\n    }\n    if (token.toLowerCase().startsWith(SECRETS_MANAGER_REF_PREFIX)) {\n      return SecretValue.secretsManager(token.slice(SECRETS_MANAGER_REF_PREFIX.length));\n    }\n\n    // Genuine raw plaintext token — this is the exposure. Reject by default and\n    // point the caller at a secret reference or a CodeStar connection.\n    if (!options.allowPlainTextToken) {\n      throw new Error(\n        'GitHub source `token` is a raw plaintext value, which would be baked into the ' +\n        'synthesized CloudFormation template (and CDK context / stack state). Provide a ' +\n        'Secrets Manager reference instead — an `arn:aws:secretsmanager:...` ARN, a ' +\n        '`secretsmanager:<secret-name>` string, or a `SecretValue.secretsManager(...)` — or ' +\n        'prefer a CodeStar connection (`type: \"codestar\"`). To intentionally embed the token ' +\n        'in plaintext, set `allowPlainTextToken: true`.',\n      );\n    }\n\n    log.warn(\n      'GitHub source `token` is being embedded as PLAINTEXT in the synthesized CloudFormation ' +\n      'template because `allowPlainTextToken` is set. Anyone with template, CDK context, or ' +\n      'stack state access can read this token. Use a Secrets Manager reference or a CodeStar ' +\n      'connection instead.',\n    );\n    return SecretValue.unsafePlainText(token);\n  }\n\n  /**\n   * Creates a CodeStar connection source for the pipeline\n   */\n  private createCodeStarSource(): CodePipelineSource {\n    const options = this.config.getCodeStarOptions();\n\n    return CodePipelineSource.connection(options.repo, options.branch, {\n      connectionArn: unwrapSecret(options.connectionArn),\n      triggerOnPush: options.trigger === TriggerType.AUTO,\n      codeBuildCloneOutput: options.codeBuildCloneOutput,\n    });\n  }\n\n  /**\n   * Creates a CodeCommit source for the pipeline\n   */\n  private createCodeCommitSource(id: UniqueId): CodePipelineSource {\n    const options = this.config.getCodeCommitOptions();\n\n    const repository = Repository.fromRepositoryName(\n      this.scope,\n      id.generate('source:repo'),\n      options.repositoryName,\n    );\n\n    return CodePipelineSource.codeCommit(repository, options.branch ?? 'main', {\n      trigger: options.trigger === TriggerType.AUTO ? CodeCommitTrigger.EVENTS : CodeCommitTrigger.NONE,\n    });\n  }\n}\n"]}

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

@@ -209,3 +209,13 @@ export interface CodeCommitOptions {
      */
     readonly trigger?: TriggerType;
 }
+/**
+ * Union type of all supported pipeline source types
+ *
+ * Supported sources:
+ * - S3SourceConfig: Source code from S3 bucket
+ * - GitHubSourceConfig: Source code from GitHub repository
+ * - CodeStarSourceConfig: Source code via CodeStar connection (GitHub, Bitbucket, GitLab)
+ * - CodeCommitSourceConfig: Source code from AWS CodeCommit repository
+ */
+export type SourceType = S3SourceConfig | GitHubSourceConfig | CodeStarSourceConfig | CodeCommitSourceConfig;

package/lib/pipeline/source-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":"source-types.js","sourceRoot":"","sources":["../../src/pipeline/source-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 { SecretValue } from 'aws-cdk-lib';\nimport type { TriggerType } from '../core/pipeline-types.js';\n\n/**\n * S3 source configuration for CodePipeline\n *\n * @example\n * ```typescript\n * const source: S3SourceConfig = {\n *   type: 's3',\n *   options: {\n *     bucketName: 'my-source-bucket',\n *     objectKey: 'source.zip',\n *     trigger: TriggerType.AUTO\n *   }\n * };\n * ```\n */\nexport interface S3SourceConfig {\n  readonly type: 's3';\n  readonly options: S3Options;\n}\n\n/**\n * GitHub source configuration for CodePipeline\n *\n * @example\n * ```typescript\n * const source: GitHubSourceConfig = {\n *   type: 'github',\n *   options: {\n *     repo: 'owner/repository',\n *     branch: 'main',\n *     trigger: TriggerType.AUTO\n *   }\n * };\n * ```\n */\nexport interface GitHubSourceConfig {\n  readonly type: 'github';\n  readonly options: GitHubOptions;\n}\n\n/**\n * CodeStar connection source configuration for CodePipeline\n *\n * @example\n * ```typescript\n * const source: CodeStarSourceConfig = {\n *   type: 'codestar',\n *   options: {\n *     repo: 'owner/repository',\n *     branch: 'main',\n *     connectionArn: 'arn:aws:codestar-connections:...',\n *     trigger: TriggerType.AUTO\n *   }\n * };\n * ```\n */\nexport interface CodeStarSourceConfig {\n  readonly type: 'codestar';\n  readonly options: CodeStarOptions;\n}\n\n/**\n * Configuration options for S3 pipeline source\n */\nexport interface S3Options {\n  /**\n   * Name of the S3 bucket containing the source code\n   * @example 'my-pipeline-source-bucket'\n   */\n  readonly bucketName: string;\n\n  /**\n   * Object key (path) to the source archive within the bucket\n   * @default 'source.zip'\n   */\n  readonly objectKey?: string;\n\n  /**\n   * Pipeline trigger behavior\n   * @default TriggerType.NONE\n   */\n  readonly trigger?: TriggerType;\n\n  /**\n   * Cron expression for scheduled trigger (e.g., 'cron(0 0 * * ? *)' for daily).\n   * Only used when trigger is SCHEDULE.\n   */\n  readonly schedule?: string;\n}\n\n/**\n * Configuration options for GitHub pipeline source\n */\nexport interface GitHubOptions {\n  /**\n   * GitHub repository in the format \"owner/repo\"\n   * @example 'myorg/myrepo'\n   */\n  readonly repo: string;\n\n  /**\n   * Branch to track\n   * @default 'main'\n   */\n  readonly branch?: string;\n\n  /**\n   * GitHub authentication token.\n   *\n   * Prefer a Secrets Manager reference so the token value never lands in the\n   * synthesized CloudFormation template / CDK context. Accepted forms:\n   *   - a `SecretValue` (e.g. `SecretValue.secretsManager(...)`),\n   *   - a Secrets Manager ARN string (`arn:aws:secretsmanager:...`),\n   *   - a `secretsmanager:<secret-name>` shorthand string.\n   *\n   * A genuine raw plaintext token (e.g. a `ghp_...` PAT) is rejected by default,\n   * because baking it in would expose it to anyone with template/state access —\n   * set {@link allowPlainTextToken} to intentionally embed it.\n   *\n   * If not provided, uses default GitHub authentication. Consider a CodeStar\n   * connection (`type: 'codestar'`) as the modern, credential-free path.\n   */\n  readonly token?: SecretValue | string;\n\n  /**\n   * Opt-in escape hatch to embed a raw plaintext {@link token} directly in the\n   * synthesized template. Insecure — the token becomes readable by anyone with\n   * template, CDK context, or stack state access. Leave unset (default) to force\n   * a Secrets Manager reference instead.\n   * @default false\n   */\n  readonly allowPlainTextToken?: boolean;\n\n  /**\n   * Pipeline trigger behavior\n   * @default TriggerType.NONE\n   */\n  readonly trigger?: TriggerType;\n\n  /**\n   * Cron expression for scheduled trigger (e.g., 'cron(0 0 * * ? *)' for daily).\n   * Only used when trigger is SCHEDULE.\n   */\n  readonly schedule?: string;\n}\n\n/**\n * Configuration options for CodeStar connection pipeline source\n */\nexport interface CodeStarOptions {\n  /**\n   * Repository identifier in the format \"owner/repo\"\n   * @example 'myorg/myrepo'\n   */\n  readonly repo: string;\n\n  /**\n   * Branch to track\n   * @default 'main'\n   */\n  readonly branch?: string;\n\n  /**\n   * ARN of the CodeStar connection to use\n   * Can be a string ARN or SecretValue\n   * @example 'arn:aws:codestar-connections:us-east-1:123456789012:connection/abc123'\n   */\n  readonly connectionArn: SecretValue | string;\n\n  /**\n   * Pipeline trigger behavior\n   * @default TriggerType.NONE\n   */\n  readonly trigger?: TriggerType;\n\n  /**\n   * Cron expression for scheduled trigger (e.g., 'cron(0 0 * * ? *)' for daily).\n   * Only used when trigger is SCHEDULE.\n   */\n  readonly schedule?: string;\n\n  /**\n   * Whether to enable full clone capability in CodeBuild\n   * When true, CodeBuild can perform git operations on the full repository\n   * @default false\n   */\n  readonly codeBuildCloneOutput?: boolean;\n}\n\n/**\n * CodeCommit source configuration for CodePipeline\n *\n * @example\n * ```typescript\n * const source: CodeCommitSourceConfig = {\n *   type: 'codecommit',\n *   options: {\n *     repositoryName: 'my-repo',\n *     branch: 'main',\n *     trigger: TriggerType.AUTO\n *   }\n * };\n * ```\n */\nexport interface CodeCommitSourceConfig {\n  readonly type: 'codecommit';\n  readonly options: CodeCommitOptions;\n}\n\n/**\n * Configuration options for CodeCommit pipeline source\n */\nexport interface CodeCommitOptions {\n  /**\n   * Name of the CodeCommit repository\n   * @example 'my-repo'\n   */\n  readonly repositoryName: string;\n\n  /**\n   * Branch to track\n   * @default 'main'\n   */\n  readonly branch?: string;\n\n  /**\n   * Pipeline trigger behavior\n   * @default TriggerType.NONE\n   */\n  readonly trigger?: TriggerType;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"source-types.js","sourceRoot":"","sources":["../../src/pipeline/source-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 { SecretValue } from 'aws-cdk-lib';\nimport type { TriggerType } from '../core/pipeline-types.js';\n\n/**\n * S3 source configuration for CodePipeline\n *\n * @example\n * ```typescript\n * const source: S3SourceConfig = {\n *   type: 's3',\n *   options: {\n *     bucketName: 'my-source-bucket',\n *     objectKey: 'source.zip',\n *     trigger: TriggerType.AUTO\n *   }\n * };\n * ```\n */\nexport interface S3SourceConfig {\n  readonly type: 's3';\n  readonly options: S3Options;\n}\n\n/**\n * GitHub source configuration for CodePipeline\n *\n * @example\n * ```typescript\n * const source: GitHubSourceConfig = {\n *   type: 'github',\n *   options: {\n *     repo: 'owner/repository',\n *     branch: 'main',\n *     trigger: TriggerType.AUTO\n *   }\n * };\n * ```\n */\nexport interface GitHubSourceConfig {\n  readonly type: 'github';\n  readonly options: GitHubOptions;\n}\n\n/**\n * CodeStar connection source configuration for CodePipeline\n *\n * @example\n * ```typescript\n * const source: CodeStarSourceConfig = {\n *   type: 'codestar',\n *   options: {\n *     repo: 'owner/repository',\n *     branch: 'main',\n *     connectionArn: 'arn:aws:codestar-connections:...',\n *     trigger: TriggerType.AUTO\n *   }\n * };\n * ```\n */\nexport interface CodeStarSourceConfig {\n  readonly type: 'codestar';\n  readonly options: CodeStarOptions;\n}\n\n/**\n * Configuration options for S3 pipeline source\n */\nexport interface S3Options {\n  /**\n   * Name of the S3 bucket containing the source code\n   * @example 'my-pipeline-source-bucket'\n   */\n  readonly bucketName: string;\n\n  /**\n   * Object key (path) to the source archive within the bucket\n   * @default 'source.zip'\n   */\n  readonly objectKey?: string;\n\n  /**\n   * Pipeline trigger behavior\n   * @default TriggerType.NONE\n   */\n  readonly trigger?: TriggerType;\n\n  /**\n   * Cron expression for scheduled trigger (e.g., 'cron(0 0 * * ? *)' for daily).\n   * Only used when trigger is SCHEDULE.\n   */\n  readonly schedule?: string;\n}\n\n/**\n * Configuration options for GitHub pipeline source\n */\nexport interface GitHubOptions {\n  /**\n   * GitHub repository in the format \"owner/repo\"\n   * @example 'myorg/myrepo'\n   */\n  readonly repo: string;\n\n  /**\n   * Branch to track\n   * @default 'main'\n   */\n  readonly branch?: string;\n\n  /**\n   * GitHub authentication token.\n   *\n   * Prefer a Secrets Manager reference so the token value never lands in the\n   * synthesized CloudFormation template / CDK context. Accepted forms:\n   *   - a `SecretValue` (e.g. `SecretValue.secretsManager(...)`),\n   *   - a Secrets Manager ARN string (`arn:aws:secretsmanager:...`),\n   *   - a `secretsmanager:<secret-name>` shorthand string.\n   *\n   * A genuine raw plaintext token (e.g. a `ghp_...` PAT) is rejected by default,\n   * because baking it in would expose it to anyone with template/state access —\n   * set {@link allowPlainTextToken} to intentionally embed it.\n   *\n   * If not provided, uses default GitHub authentication. Consider a CodeStar\n   * connection (`type: 'codestar'`) as the modern, credential-free path.\n   */\n  readonly token?: SecretValue | string;\n\n  /**\n   * Opt-in escape hatch to embed a raw plaintext {@link token} directly in the\n   * synthesized template. Insecure — the token becomes readable by anyone with\n   * template, CDK context, or stack state access. Leave unset (default) to force\n   * a Secrets Manager reference instead.\n   * @default false\n   */\n  readonly allowPlainTextToken?: boolean;\n\n  /**\n   * Pipeline trigger behavior\n   * @default TriggerType.NONE\n   */\n  readonly trigger?: TriggerType;\n\n  /**\n   * Cron expression for scheduled trigger (e.g., 'cron(0 0 * * ? *)' for daily).\n   * Only used when trigger is SCHEDULE.\n   */\n  readonly schedule?: string;\n}\n\n/**\n * Configuration options for CodeStar connection pipeline source\n */\nexport interface CodeStarOptions {\n  /**\n   * Repository identifier in the format \"owner/repo\"\n   * @example 'myorg/myrepo'\n   */\n  readonly repo: string;\n\n  /**\n   * Branch to track\n   * @default 'main'\n   */\n  readonly branch?: string;\n\n  /**\n   * ARN of the CodeStar connection to use\n   * Can be a string ARN or SecretValue\n   * @example 'arn:aws:codestar-connections:us-east-1:123456789012:connection/abc123'\n   */\n  readonly connectionArn: SecretValue | string;\n\n  /**\n   * Pipeline trigger behavior\n   * @default TriggerType.NONE\n   */\n  readonly trigger?: TriggerType;\n\n  /**\n   * Cron expression for scheduled trigger (e.g., 'cron(0 0 * * ? *)' for daily).\n   * Only used when trigger is SCHEDULE.\n   */\n  readonly schedule?: string;\n\n  /**\n   * Whether to enable full clone capability in CodeBuild\n   * When true, CodeBuild can perform git operations on the full repository\n   * @default false\n   */\n  readonly codeBuildCloneOutput?: boolean;\n}\n\n/**\n * CodeCommit source configuration for CodePipeline\n *\n * @example\n * ```typescript\n * const source: CodeCommitSourceConfig = {\n *   type: 'codecommit',\n *   options: {\n *     repositoryName: 'my-repo',\n *     branch: 'main',\n *     trigger: TriggerType.AUTO\n *   }\n * };\n * ```\n */\nexport interface CodeCommitSourceConfig {\n  readonly type: 'codecommit';\n  readonly options: CodeCommitOptions;\n}\n\n/**\n * Configuration options for CodeCommit pipeline source\n */\nexport interface CodeCommitOptions {\n  /**\n   * Name of the CodeCommit repository\n   * @example 'my-repo'\n   */\n  readonly repositoryName: string;\n\n  /**\n   * Branch to track\n   * @default 'main'\n   */\n  readonly branch?: string;\n\n  /**\n   * Pipeline trigger behavior\n   * @default TriggerType.NONE\n   */\n  readonly trigger?: TriggerType;\n}\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"]}

package/lib/pipeline/stage-builder.js

@@ -4,7 +4,8 @@ import { CodePipeline } from 'aws-cdk-lib/pipelines';
 import { Construct } from 'constructs';
 import { PluginLookup } from './plugin-lookup.js';
 import { UniqueId } from '../core/id-generator.js';
-import { createCodeBuildStep, merge, resolveFailureBehavior } from '../core/pipeline-helpers.js';
+import { merge, resolveFailureBehavior } from '../core/metadata-helpers.js';
+import { createCodeBuildStep } from '../core/pipeline-helpers.js';
 /**
  * Builds and adds pipeline stages (waves) to a CodePipeline.
  *
@@ -125,4 +126,4 @@ export class StageBuilder {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stage-builder.js","sourceRoot":"","sources":["../../src/pipeline/stage-builder.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { ComputeType as CdkComputeType } from 'aws-cdk-lib/aws-codebuild';\nimport { CodePipeline } from 'aws-cdk-lib/pipelines';\nimport { Construct } from 'constructs';\nimport { PluginLookup } from './plugin-lookup.js';\nimport type { StageOptions } from './step-types.js';\nimport type { ArtifactManager } from '../core/artifact-manager.js';\nimport { UniqueId } from '../core/id-generator.js';\nimport { createCodeBuildStep, merge, resolveFailureBehavior } from '../core/pipeline-helpers.js';\nimport type { MetaDataType } from '../core/pipeline-types.js';\n\n/**\n * Configuration properties for the StageBuilder\n */\nexport interface StageBuilderProps {\n  /** CDK construct scope for creating child constructs */\n  readonly scope: Construct;\n\n  /** Plugin lookup service for resolving plugin references to CDK constructs */\n  readonly pluginLookup: PluginLookup;\n\n  /** Unique ID generator for creating deterministic construct IDs */\n  readonly uniqueId: UniqueId;\n\n  /** Global metadata inherited by all stage steps */\n  readonly globalMetadata: MetaDataType;\n\n  /** Default CodeBuild compute type for steps that don't specify one */\n  readonly defaultComputeType?: CdkComputeType;\n\n  /** Artifact manager for resolving input artifact keys to FileSets */\n  readonly artifactManager?: ArtifactManager;\n\n  /** Tenant identifier for resolving per-org secrets from AWS Secrets Manager */\n  readonly orgId?: string;\n\n  /**\n   * Pipeline-level scope used to resolve `{{ pipeline.* }}` template tokens\n   * inside plugin specs. Required — passed through to `createCodeBuildStep`\n   * on every step.\n   */\n  readonly pipelineScope: Record<string, unknown>;\n}\n\n/**\n * Builds and adds pipeline stages (waves) to a CodePipeline.\n *\n * Each stage is resolved from high-level configuration (plugin names)\n * into CDK CodeBuild steps via PluginLookup, then added as a wave.\n *\n * @example\n * ```typescript\n * const stageBuilder = new StageBuilder({\n *   scope: this,\n *   pluginLookup,\n *   uniqueId,\n *   globalMetadata: mergedMetadata,\n * });\n * stageBuilder.addStage(pipeline, {\n *   stageName: 'Integration Tests',\n *   alias: 'integration',\n *   steps: [\n *     { plugin: { name: 'jest-integration' } },\n *     { plugin: { name: 'e2e-tests', alias: 'cypress' } },\n *   ],\n * });\n * ```\n */\nexport class StageBuilder {\n  private readonly scope: Construct;\n  private readonly pluginLookup: PluginLookup;\n  private readonly uniqueId: UniqueId;\n  private readonly globalMetadata: MetaDataType;\n  private readonly defaultComputeType?: CdkComputeType;\n  private readonly artifactManager?: ArtifactManager;\n  private readonly orgId?: string;\n  private readonly pipelineScope: Record<string, unknown>;\n\n  constructor(props: StageBuilderProps) {\n    this.scope = props.scope;\n    this.pluginLookup = props.pluginLookup;\n    this.uniqueId = props.uniqueId;\n    this.globalMetadata = props.globalMetadata;\n    this.defaultComputeType = props.defaultComputeType;\n    this.artifactManager = props.artifactManager;\n    this.orgId = props.orgId;\n    this.pipelineScope = props.pipelineScope;\n  }\n\n  /**\n   * Resolves a stage's plugin-based step configs into CodeBuild steps\n   * and adds them as a wave to the pipeline.\n   */\n  addStage(pipeline: CodePipeline, stage: StageOptions): void {\n    const stageAlias = stage.alias ?? `${stage.stageName}-alias`;\n\n    const preSteps = stage.steps\n      .filter(s => (s.position ?? 'pre') === 'pre')\n      .map(s => this.resolveStep(s, stage.stageName, stageAlias));\n    const postSteps = stage.steps\n      .filter(s => s.position === 'post')\n      .map(s => this.resolveStep(s, stage.stageName, stageAlias));\n\n    pipeline.addWave(stageAlias, {\n      ...(preSteps.length > 0 && { pre: preSteps }),\n      ...(postSteps.length > 0 && { post: postSteps }),\n    });\n  }\n\n  private resolveStep(stepConfig: StageOptions['steps'][number], stageName: string, stageAlias: string) {\n    const plugin = this.pluginLookup.plugin(stepConfig.plugin);\n    // Per-step plugin config lives on the plugin reference (`plugin.metadata` —\n    // e.g. JAVA_VERSION/KOTLIN_VERSION/computetype overrides). pluginLookup.plugin()\n    // returns the resolved CATALOG plugin and drops the reference metadata in the\n    // pre-resolved path, so merge it here too — otherwise per-step overrides are\n    // silently ignored and the build falls back to plugin defaults.\n    // Order (last wins): global < plugin-ref metadata < step-level metadata.\n    const stepMetadata = merge(this.globalMetadata, stepConfig.plugin.metadata ?? {}, stepConfig.metadata ?? {});\n    const pluginAlias = stepConfig.plugin.alias ?? stepConfig.plugin.name;\n\n    if (stepConfig.inputArtifact && !this.artifactManager) {\n      throw new Error(\n        `Step \"${pluginAlias}\" requires inputArtifact but no artifactManager is configured.`,\n      );\n    }\n    if (stepConfig.additionalInputArtifacts?.length && !this.artifactManager) {\n      throw new Error(\n        `Step \"${pluginAlias}\" requires additionalInputArtifacts but no artifactManager is configured.`,\n      );\n    }\n\n    const input = stepConfig.inputArtifact && this.artifactManager\n      ? this.artifactManager.getOutput(stepConfig.inputArtifact)\n      : undefined;\n\n    const additionalInputs = stepConfig.additionalInputArtifacts?.length && this.artifactManager\n      ? Object.fromEntries(\n        stepConfig.additionalInputArtifacts.map(({ artifact, directory }) => [\n          directory || artifact.outputDirectory,\n          this.artifactManager!.getOutput(artifact),\n        ]),\n      )\n      : undefined;\n\n    return createCodeBuildStep({\n      id: this.uniqueId.generate(`stage:${stageAlias}:${pluginAlias}`),\n      uniqueId: this.uniqueId,\n      plugin,\n      metadata: stepMetadata,\n      network: stepConfig.network,\n      scope: this.scope,\n      defaultComputeType: this.defaultComputeType,\n      input,\n      additionalInputs,\n      artifactManager: this.artifactManager,\n      stageName,\n      stageAlias,\n      pluginAlias,\n      preInstallCommands: stepConfig.preInstallCommands,\n      postInstallCommands: stepConfig.postInstallCommands,\n      preCommands: stepConfig.preCommands,\n      postCommands: stepConfig.postCommands,\n      env: stepConfig.env,\n      timeout: stepConfig.timeout ?? plugin.timeout ?? undefined,\n      // A scan/security-category plugin can never be downgraded from 'fail' — see resolveFailureBehavior.\n      failureBehavior: resolveFailureBehavior(plugin.category, stepConfig.failureBehavior ?? plugin.failureBehavior),\n      orgId: this.orgId,\n      pipelineScope: this.pipelineScope,\n    });\n  }\n\n  /**\n   * Resolves and adds multiple stages as waves to the pipeline, in order.\n   */\n  addStages(pipeline: CodePipeline, stages: StageOptions[]): void {\n    for (const stage of stages) {\n      this.addStage(pipeline, stage);\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stage-builder.js","sourceRoot":"","sources":["../../src/pipeline/stage-builder.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { ComputeType as CdkComputeType } from 'aws-cdk-lib/aws-codebuild';\nimport { CodePipeline } from 'aws-cdk-lib/pipelines';\nimport { Construct } from 'constructs';\nimport { PluginLookup } from './plugin-lookup.js';\nimport type { StageOptions } from './step-types.js';\nimport type { ArtifactManager } from '../core/artifact-manager.js';\nimport { UniqueId } from '../core/id-generator.js';\nimport { merge, resolveFailureBehavior } from '../core/metadata-helpers.js';\nimport { createCodeBuildStep } from '../core/pipeline-helpers.js';\nimport type { MetaDataType } from '../core/pipeline-types.js';\n\n/**\n * Configuration properties for the StageBuilder\n */\nexport interface StageBuilderProps {\n  /** CDK construct scope for creating child constructs */\n  readonly scope: Construct;\n\n  /** Plugin lookup service for resolving plugin references to CDK constructs */\n  readonly pluginLookup: PluginLookup;\n\n  /** Unique ID generator for creating deterministic construct IDs */\n  readonly uniqueId: UniqueId;\n\n  /** Global metadata inherited by all stage steps */\n  readonly globalMetadata: MetaDataType;\n\n  /** Default CodeBuild compute type for steps that don't specify one */\n  readonly defaultComputeType?: CdkComputeType;\n\n  /** Artifact manager for resolving input artifact keys to FileSets */\n  readonly artifactManager?: ArtifactManager;\n\n  /** Tenant identifier for resolving per-org secrets from AWS Secrets Manager */\n  readonly orgId?: string;\n\n  /**\n   * Pipeline-level scope used to resolve `{{ pipeline.* }}` template tokens\n   * inside plugin specs. Required — passed through to `createCodeBuildStep`\n   * on every step.\n   */\n  readonly pipelineScope: Record<string, unknown>;\n}\n\n/**\n * Builds and adds pipeline stages (waves) to a CodePipeline.\n *\n * Each stage is resolved from high-level configuration (plugin names)\n * into CDK CodeBuild steps via PluginLookup, then added as a wave.\n *\n * @example\n * ```typescript\n * const stageBuilder = new StageBuilder({\n *   scope: this,\n *   pluginLookup,\n *   uniqueId,\n *   globalMetadata: mergedMetadata,\n * });\n * stageBuilder.addStage(pipeline, {\n *   stageName: 'Integration Tests',\n *   alias: 'integration',\n *   steps: [\n *     { plugin: { name: 'jest-integration' } },\n *     { plugin: { name: 'e2e-tests', alias: 'cypress' } },\n *   ],\n * });\n * ```\n */\nexport class StageBuilder {\n  private readonly scope: Construct;\n  private readonly pluginLookup: PluginLookup;\n  private readonly uniqueId: UniqueId;\n  private readonly globalMetadata: MetaDataType;\n  private readonly defaultComputeType?: CdkComputeType;\n  private readonly artifactManager?: ArtifactManager;\n  private readonly orgId?: string;\n  private readonly pipelineScope: Record<string, unknown>;\n\n  constructor(props: StageBuilderProps) {\n    this.scope = props.scope;\n    this.pluginLookup = props.pluginLookup;\n    this.uniqueId = props.uniqueId;\n    this.globalMetadata = props.globalMetadata;\n    this.defaultComputeType = props.defaultComputeType;\n    this.artifactManager = props.artifactManager;\n    this.orgId = props.orgId;\n    this.pipelineScope = props.pipelineScope;\n  }\n\n  /**\n   * Resolves a stage's plugin-based step configs into CodeBuild steps\n   * and adds them as a wave to the pipeline.\n   */\n  addStage(pipeline: CodePipeline, stage: StageOptions): void {\n    const stageAlias = stage.alias ?? `${stage.stageName}-alias`;\n\n    const preSteps = stage.steps\n      .filter(s => (s.position ?? 'pre') === 'pre')\n      .map(s => this.resolveStep(s, stage.stageName, stageAlias));\n    const postSteps = stage.steps\n      .filter(s => s.position === 'post')\n      .map(s => this.resolveStep(s, stage.stageName, stageAlias));\n\n    pipeline.addWave(stageAlias, {\n      ...(preSteps.length > 0 && { pre: preSteps }),\n      ...(postSteps.length > 0 && { post: postSteps }),\n    });\n  }\n\n  private resolveStep(stepConfig: StageOptions['steps'][number], stageName: string, stageAlias: string) {\n    const plugin = this.pluginLookup.plugin(stepConfig.plugin);\n    // Per-step plugin config lives on the plugin reference (`plugin.metadata` —\n    // e.g. JAVA_VERSION/KOTLIN_VERSION/computetype overrides). pluginLookup.plugin()\n    // returns the resolved CATALOG plugin and drops the reference metadata in the\n    // pre-resolved path, so merge it here too — otherwise per-step overrides are\n    // silently ignored and the build falls back to plugin defaults.\n    // Order (last wins): global < plugin-ref metadata < step-level metadata.\n    const stepMetadata = merge(this.globalMetadata, stepConfig.plugin.metadata ?? {}, stepConfig.metadata ?? {});\n    const pluginAlias = stepConfig.plugin.alias ?? stepConfig.plugin.name;\n\n    if (stepConfig.inputArtifact && !this.artifactManager) {\n      throw new Error(\n        `Step \"${pluginAlias}\" requires inputArtifact but no artifactManager is configured.`,\n      );\n    }\n    if (stepConfig.additionalInputArtifacts?.length && !this.artifactManager) {\n      throw new Error(\n        `Step \"${pluginAlias}\" requires additionalInputArtifacts but no artifactManager is configured.`,\n      );\n    }\n\n    const input = stepConfig.inputArtifact && this.artifactManager\n      ? this.artifactManager.getOutput(stepConfig.inputArtifact)\n      : undefined;\n\n    const additionalInputs = stepConfig.additionalInputArtifacts?.length && this.artifactManager\n      ? Object.fromEntries(\n        stepConfig.additionalInputArtifacts.map(({ artifact, directory }) => [\n          directory || artifact.outputDirectory,\n          this.artifactManager!.getOutput(artifact),\n        ]),\n      )\n      : undefined;\n\n    return createCodeBuildStep({\n      id: this.uniqueId.generate(`stage:${stageAlias}:${pluginAlias}`),\n      uniqueId: this.uniqueId,\n      plugin,\n      metadata: stepMetadata,\n      network: stepConfig.network,\n      scope: this.scope,\n      defaultComputeType: this.defaultComputeType,\n      input,\n      additionalInputs,\n      artifactManager: this.artifactManager,\n      stageName,\n      stageAlias,\n      pluginAlias,\n      preInstallCommands: stepConfig.preInstallCommands,\n      postInstallCommands: stepConfig.postInstallCommands,\n      preCommands: stepConfig.preCommands,\n      postCommands: stepConfig.postCommands,\n      env: stepConfig.env,\n      timeout: stepConfig.timeout ?? plugin.timeout ?? undefined,\n      // A scan/security-category plugin can never be downgraded from 'fail' — see resolveFailureBehavior.\n      failureBehavior: resolveFailureBehavior(plugin.category, stepConfig.failureBehavior ?? plugin.failureBehavior),\n      orgId: this.orgId,\n      pipelineScope: this.pipelineScope,\n    });\n  }\n\n  /**\n   * Resolves and adds multiple stages as waves to the pipeline, in order.\n   */\n  addStages(pipeline: CodePipeline, stages: StageOptions[]): void {\n    for (const stage of stages) {\n      this.addStage(pipeline, stage);\n    }\n  }\n}\n"]}

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

@@ -2,10 +2,11 @@ import type { PluginFilter, Plugin } from '@pipeline-builder/pipeline-data';
 import type { ComputeType as CdkComputeType } from 'aws-cdk-lib/aws-codebuild';
 import type { IFileSetProducer } from 'aws-cdk-lib/pipelines';
 import type { Construct } from 'constructs';
+import type { SourceType } from './source-types.js';
 import type { ArtifactKey, ArtifactManager } from '../core/artifact-manager.js';
 import type { UniqueId } from '../core/id-generator.js';
 import type { NetworkConfig } from '../core/network-types.js';
-import type { ComputeType, PluginType, MetaDataType, SourceType } from '../core/pipeline-types.js';
+import type { MetaDataType } from '../core/pipeline-types.js';
 /**
  * Options for selecting and configuring a plugin
  */
@@ -56,134 +57,6 @@ export interface SynthOptions extends StepCustomization {
      */
     readonly network?: NetworkConfig;
 }
-/**
- * Plugin spec defining plugin behavior and requirements.
- * This is typically loaded from a plugin spec file (plugin-spec.yaml).
- */
-export interface PluginSpec {
-    /**
-     * Unique identifier for the plugin
-     * @example 'nodejs-build'
-     */
-    readonly name: string;
-    /**
-     * Human-readable description of what the plugin does
-     * @example 'Builds and tests Node.js applications'
-     */
-    readonly description?: string;
-    /**
-     * Keywords for plugin discovery and categorization
-     * @example ['nodejs', 'typescript', 'build', 'test']
-     */
-    readonly keywords?: string[];
-    /**
-     * Plugin category for AI-assisted selection and organization.
-     * One of: language, security, quality, testing, deploy, artifact,
-     *         infrastructure, monitoring, notification, ai
-     */
-    readonly category?: string;
-    /**
-     * Semantic version of the plugin
-     * @example '1.0.0'
-     */
-    readonly version?: string;
-    /**
-     * Type of pipeline step this plugin creates
-     * @default PluginType.CODE_BUILD_STEP
-     */
-    readonly pluginType?: PluginType;
-    /**
-     * CodeBuild compute resource size to use
-     * @default ComputeType.SMALL
-     */
-    readonly computeType?: ComputeType;
-    /**
-     * Maximum execution time in minutes.
-     * Used as fallback when the pipeline step doesn't set timeout.
-     * @default 60 (AWS CodeBuild default)
-     */
-    readonly timeout?: number;
-    /**
-     * What happens when this step fails.
-     * - 'fail': Stop the pipeline (default)
-     * - 'warn': Log a warning and continue
-     * - 'ignore': Silently continue
-     * @default 'fail'
-     */
-    readonly failureBehavior?: 'fail' | 'warn' | 'ignore';
-    /**
-     * Secret requirements for this plugin.
-     * Declares named secrets the plugin expects at build time.
-     */
-    readonly secrets?: Array<{
-        name: string;
-        required: boolean;
-        description?: string;
-    }>;
-    /**
-     * Directory containing the primary build output artifacts
-     * @example 'dist'
-     */
-    readonly primaryOutputDirectory?: string;
-    /**
-     * Additional metadata that can be accessed during plugin execution
-     * Keys should use the format 'aws:cdk:{namespace}:{key}' (all lowercase)
-     */
-    readonly metadata?: Record<string, string | number | boolean>;
-    /**
-     * Path to Dockerfile or Dockerfile content
-     * Used to build the container environment for this plugin
-     */
-    readonly dockerfile?: string;
-    /**
-     * Commands to run during the install phase
-     * Typically used for installing dependencies
-     * @example ['npm ci', 'npm run build']
-     */
-    readonly installCommands?: string[];
-    /**
-     * Commands to run during the build/execution phase
-     * These are the main commands that perform the plugin's work
-     * @example ['npm test', 'npm run deploy']
-     */
-    readonly commands?: string[];
-    /**
-     * Environment variables to set in the build environment
-     * @example { API_URL: 'https://api.example.com', LOG_LEVEL: 'info' }
-     */
-    readonly env?: Record<string, string>;
-    /**
-     * Docker build arguments passed via --build-arg at image build time.
-     * Used to parameterize Dockerfile ARG values when building the plugin image.
-     * @example { PYTHON_VERSION: '3.12', NODE_ENV: 'production' }
-     */
-    readonly buildArgs?: Record<string, string>;
-    /**
-     * Pipeline metadata keys the plugin references via `{{ pipeline.metadata.X }}`.
-     * Declared as a contract — pipelines using this plugin must supply all
-     * listed keys unless the template uses `| default: '...'`.
-     * @example ['env', 'namespace', 'clusterName']
-     */
-    readonly requiredMetadata?: string[];
-    /**
-     * Pipeline vars keys the plugin references via `{{ pipeline.vars.X }}`.
-     * @example ['branch', 'slackChannel']
-     */
-    readonly requiredVars?: string[];
-    /**
-     * Optional type declarations for the metadata keys listed in `requiredMetadata`.
-     * Used at upload time to verify that coercion filters (`| number`, `| bool`,
-     * `| json`) match the declared type — e.g. `{{ pipeline.metadata.count | number }}`
-     * requires `count: 'number'` here, otherwise the plugin is rejected.
-     * Keys not declared default to `'string'`.
-     * @example { count: 'number', enabled: 'bool' }
-     */
-    readonly metadataTypes?: Record<string, 'string' | 'number' | 'bool' | 'json'>;
-    /**
-     * Optional type declarations for vars keys (same semantics as `metadataTypes`).
-     */
-    readonly varsTypes?: Record<string, 'string' | 'number' | 'bool' | 'json'>;
-}
 /**
  * Per-step customization options for commands and environment variables.
  * Custom commands are injected before/after the plugin's commands.

package/lib/pipeline/step-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":"step-types.js","sourceRoot":"","sources":["../../src/pipeline/step-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 { PluginFilter, Plugin } from '@pipeline-builder/pipeline-data';\nimport type { ComputeType as CdkComputeType } from 'aws-cdk-lib/aws-codebuild';\nimport type { IFileSetProducer } from 'aws-cdk-lib/pipelines';\nimport type { Construct } from 'constructs';\nimport type { ArtifactKey, ArtifactManager } from '../core/artifact-manager.js';\nimport type { UniqueId } from '../core/id-generator.js';\nimport type { NetworkConfig } from '../core/network-types.js';\nimport type { ComputeType, PluginType, MetaDataType, SourceType } from '../core/pipeline-types.js';\n\n/**\n * Options for selecting and configuring a plugin\n */\nexport interface PluginOptions {\n  /**\n   * Name of the plugin to use\n   * Must match a registered plugin in the database\n   */\n  readonly name: string;\n\n  /**\n   * Optional alias for the plugin instance\n   * Useful when using the same plugin multiple times with different configurations\n   */\n  readonly alias?: string;\n\n  /**\n   * Optional filter criteria for plugin selection\n   * Can be used to select specific plugin versions or variants\n   */\n  readonly filter?: PluginFilter;\n\n  /**\n   * Additional metadata to merge with plugin's default metadata\n   * This metadata will be available to the plugin during execution\n   */\n  readonly metadata?: MetaDataType;\n}\n\n/**\n * Synthesis step configuration combining source and plugin.\n * Extends StepCustomization to support injecting custom commands and env vars\n * into the synth CodeBuild step (same hooks available as stage steps).\n */\nexport interface SynthOptions extends StepCustomization {\n  /**\n   * Source configuration (S3, GitHub, or CodeStar)\n   */\n  readonly source: SourceType;\n\n  /**\n   * Plugin to use for synthesis\n   */\n  readonly plugin: PluginOptions;\n\n  /**\n   * Additional metadata for the synthesis step\n   * This will be merged with global metadata and plugin metadata\n   */\n  readonly metadata?: MetaDataType;\n\n  /**\n   * Step-level network configuration applied only to the synth CodeBuild step.\n   * Overrides the pipeline-level `defaults.network` when both are provided.\n   */\n  readonly network?: NetworkConfig;\n}\n\n/**\n * Plugin spec defining plugin behavior and requirements.\n * This is typically loaded from a plugin spec file (plugin-spec.yaml).\n */\nexport interface PluginSpec {\n  /**\n   * Unique identifier for the plugin\n   * @example 'nodejs-build'\n   */\n  readonly name: string;\n\n  /**\n   * Human-readable description of what the plugin does\n   * @example 'Builds and tests Node.js applications'\n   */\n  readonly description?: string;\n\n  /**\n   * Keywords for plugin discovery and categorization\n   * @example ['nodejs', 'typescript', 'build', 'test']\n   */\n  readonly keywords?: string[];\n\n  /**\n   * Plugin category for AI-assisted selection and organization.\n   * One of: language, security, quality, testing, deploy, artifact,\n   *         infrastructure, monitoring, notification, ai\n   */\n  readonly category?: string;\n\n  /**\n   * Semantic version of the plugin\n   * @example '1.0.0'\n   */\n  readonly version?: string;\n\n  /**\n   * Type of pipeline step this plugin creates\n   * @default PluginType.CODE_BUILD_STEP\n   */\n  readonly pluginType?: PluginType;\n\n  /**\n   * CodeBuild compute resource size to use\n   * @default ComputeType.SMALL\n   */\n  readonly computeType?: ComputeType;\n\n  /**\n   * Maximum execution time in minutes.\n   * Used as fallback when the pipeline step doesn't set timeout.\n   * @default 60 (AWS CodeBuild default)\n   */\n  readonly timeout?: number;\n\n  /**\n   * What happens when this step fails.\n   * - 'fail': Stop the pipeline (default)\n   * - 'warn': Log a warning and continue\n   * - 'ignore': Silently continue\n   * @default 'fail'\n   */\n  readonly failureBehavior?: 'fail' | 'warn' | 'ignore';\n\n  /**\n   * Secret requirements for this plugin.\n   * Declares named secrets the plugin expects at build time.\n   */\n  readonly secrets?: Array<{ name: string; required: boolean; description?: string }>;\n\n  /**\n   * Directory containing the primary build output artifacts\n   * @example 'dist'\n   */\n  readonly primaryOutputDirectory?: string;\n  /**\n   * Additional metadata that can be accessed during plugin execution\n   * Keys should use the format 'aws:cdk:{namespace}:{key}' (all lowercase)\n   */\n  readonly metadata?: Record<string, string | number | boolean>;\n\n  /**\n   * Path to Dockerfile or Dockerfile content\n   * Used to build the container environment for this plugin\n   */\n  readonly dockerfile?: string;\n\n  /**\n   * Commands to run during the install phase\n   * Typically used for installing dependencies\n   * @example ['npm ci', 'npm run build']\n   */\n  readonly installCommands?: string[];\n\n  /**\n   * Commands to run during the build/execution phase\n   * These are the main commands that perform the plugin's work\n   * @example ['npm test', 'npm run deploy']\n   */\n  readonly commands?: string[];\n\n  /**\n   * Environment variables to set in the build environment\n   * @example { API_URL: 'https://api.example.com', LOG_LEVEL: 'info' }\n   */\n  readonly env?: Record<string, string>;\n\n  /**\n   * Docker build arguments passed via --build-arg at image build time.\n   * Used to parameterize Dockerfile ARG values when building the plugin image.\n   * @example { PYTHON_VERSION: '3.12', NODE_ENV: 'production' }\n   */\n  readonly buildArgs?: Record<string, string>;\n\n  /**\n   * Pipeline metadata keys the plugin references via `{{ pipeline.metadata.X }}`.\n   * Declared as a contract — pipelines using this plugin must supply all\n   * listed keys unless the template uses `| default: '...'`.\n   * @example ['env', 'namespace', 'clusterName']\n   */\n  readonly requiredMetadata?: string[];\n\n  /**\n   * Pipeline vars keys the plugin references via `{{ pipeline.vars.X }}`.\n   * @example ['branch', 'slackChannel']\n   */\n  readonly requiredVars?: string[];\n\n  /**\n   * Optional type declarations for the metadata keys listed in `requiredMetadata`.\n   * Used at upload time to verify that coercion filters (`| number`, `| bool`,\n   * `| json`) match the declared type — e.g. `{{ pipeline.metadata.count | number }}`\n   * requires `count: 'number'` here, otherwise the plugin is rejected.\n   * Keys not declared default to `'string'`.\n   * @example { count: 'number', enabled: 'bool' }\n   */\n  readonly metadataTypes?: Record<string, 'string' | 'number' | 'bool' | 'json'>;\n\n  /**\n   * Optional type declarations for vars keys (same semantics as `metadataTypes`).\n   */\n  readonly varsTypes?: Record<string, 'string' | 'number' | 'bool' | 'json'>;\n}\n\n/**\n * Per-step customization options for commands and environment variables.\n * Custom commands are injected before/after the plugin's commands.\n * Custom env vars are merged on top of the plugin's defaults.\n */\nexport interface StepCustomization {\n  /** Commands to run before the plugin's install commands */\n  readonly preInstallCommands?: string[];\n\n  /** Commands to run after the plugin's install commands */\n  readonly postInstallCommands?: string[];\n\n  /** Commands to run before the plugin's build commands */\n  readonly preCommands?: string[];\n\n  /** Commands to run after the plugin's build commands */\n  readonly postCommands?: string[];\n\n  /** Custom environment variables merged on top of the plugin's env */\n  readonly env?: Record<string, string>;\n}\n\n/**\n * An additional input artifact with an optional mount directory.\n * When directory is omitted, defaults to the artifact's outputDirectory.\n */\nexport interface AdditionalInputArtifactConfig {\n  /** Artifact key identifying the source step's output */\n  readonly artifact: ArtifactKey;\n\n  /** Directory to mount the input at. Defaults to artifact.outputDirectory when omitted. */\n  readonly directory?: string;\n}\n\n/**\n * Configuration for a single step within a pipeline stage.\n * Uses PluginOptions for name-based plugin selection (resolved at build time).\n */\nexport interface StageStepOptions extends StepCustomization {\n  /** Plugin to use for this step */\n  readonly plugin: PluginOptions;\n\n  /** Step-level metadata merged with stage and global metadata */\n  readonly metadata?: MetaDataType;\n\n  /** Optional network configuration for this step's CodeBuild action */\n  readonly network?: NetworkConfig;\n\n  /**\n   * CodeBuild timeout in minutes.\n   * @default 60 (AWS CodeBuild default)\n   */\n  readonly timeout?: number;\n\n  /**\n   * Position of this step within the pipeline wave.\n   * - 'pre': Runs before the stage deployment (default)\n   * - 'post': Runs after the stage deployment\n   * @default 'pre'\n   */\n  readonly position?: 'pre' | 'post';\n\n  /** Artifact key for this step's primary input (resolved via ArtifactManager) */\n  readonly inputArtifact?: ArtifactKey;\n\n  /** Additional input artifacts for this step. Each entry specifies an artifact and an optional mount directory. */\n  readonly additionalInputArtifacts?: AdditionalInputArtifactConfig[];\n\n  /** Override the plugin's failure behavior for this step. */\n  readonly failureBehavior?: 'fail' | 'warn' | 'ignore';\n}\n\n/**\n * A pipeline stage containing one or more build steps.\n * Each stage maps to a CDK Pipeline wave, with steps executing within the wave.\n */\nexport interface StageOptions {\n  /** Display name for this stage */\n  readonly stageName: string;\n\n  /** Optional alias used for wave/construct ID generation. Defaults to stageName. */\n  readonly alias?: string;\n\n  /** Build steps to execute within this stage */\n  readonly steps: StageStepOptions[];\n}\n\n/**\n * Options for creating a CodeBuild step in the pipeline\n */\nexport interface CodeBuildStepOptions extends StepCustomization {\n  /**\n   * Unique identifier for this CodeBuild step\n   * Should be descriptive and unique within the pipeline\n   * @example 'my-org-my-project-synth'\n   */\n  readonly id: string;\n\n  /**\n   * UniqueId instance for generating unique construct IDs\n   * Used for network resource lookups (VPC, subnets, security groups)\n   */\n  readonly uniqueId: UniqueId;\n\n  /**\n   * Plugin configuration from the database\n   * Contains all the plugin's spec data and runtime information\n   */\n  readonly plugin: Plugin;\n\n  /**\n   * CDK scope used to create constructs (VPC/subnet/security-group lookups).\n   */\n  readonly scope: Construct;\n\n  /**\n   * Input source for this step\n   * Typically the output from a previous step or the pipeline source\n   */\n  readonly input?: IFileSetProducer;\n\n  /**\n   * Additional metadata to merge with plugin metadata\n   * Will override conflicting keys from plugin metadata\n   */\n  readonly metadata?: MetaDataType;\n\n  /**\n   * Optional network configuration for the CodeBuild step.\n   * When provided, resolves VPC, subnet selection, and security groups\n   * so the build runs inside the specified network.\n   */\n  readonly network?: NetworkConfig;\n\n  /**\n   * Fallback CodeBuild compute type when the plugin doesn't specify one.\n   * @default ComputeType.SMALL\n   */\n  readonly defaultComputeType?: CdkComputeType;\n\n  /**\n   * CodeBuild timeout in minutes.\n   * @default 60 (AWS CodeBuild default)\n   */\n  readonly timeout?: number;\n\n  /** Additional inputs mapped by directory path (resolved FileSets) */\n  readonly additionalInputs?: Record<string, IFileSetProducer>;\n\n  /**\n   * Optional artifact manager for tracking build outputs\n   * When provided and primaryOutputDirectory is set, the step will be registered\n   */\n  readonly artifactManager?: ArtifactManager;\n\n  /**\n   * Stage name for artifact key generation\n   */\n  readonly stageName?: string;\n\n  /**\n   * Stage alias for artifact key generation\n   */\n  readonly stageAlias?: string;\n\n  /**\n   * Plugin alias for artifact key generation\n   */\n  readonly pluginAlias?: string;\n\n  /**\n   * Failure behavior for this step's build commands.\n   * Applied at shell level: 'fail' = default, 'warn' = log + continue, 'ignore' = || true.\n   */\n  readonly failureBehavior?: 'fail' | 'warn' | 'ignore';\n\n  /** Tenant identifier for resolving per-org secrets from AWS Secrets Manager */\n  readonly orgId?: string;\n\n  /**\n   * Pipeline-level config used as the `pipeline.*` scope when resolving\n   * template tokens inside plugin specs. Required — every `{{ pipeline.* }}`\n   * reference in a plugin spec is evaluated against this object at synth time.\n   *\n   * Callers constructing a step directly must provide the pipeline identity\n   * + metadata + vars so template resolution is never silently skipped.\n   */\n  readonly pipelineScope: Record<string, unknown>;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-types.js","sourceRoot":"","sources":["../../src/pipeline/step-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 { PluginFilter, Plugin } from '@pipeline-builder/pipeline-data';\nimport type { ComputeType as CdkComputeType } from 'aws-cdk-lib/aws-codebuild';\nimport type { IFileSetProducer } from 'aws-cdk-lib/pipelines';\nimport type { Construct } from 'constructs';\nimport type { SourceType } from './source-types.js';\nimport type { ArtifactKey, ArtifactManager } from '../core/artifact-manager.js';\nimport type { UniqueId } from '../core/id-generator.js';\nimport type { NetworkConfig } from '../core/network-types.js';\nimport type { MetaDataType } from '../core/pipeline-types.js';\n\n/**\n * Options for selecting and configuring a plugin\n */\nexport interface PluginOptions {\n  /**\n   * Name of the plugin to use\n   * Must match a registered plugin in the database\n   */\n  readonly name: string;\n\n  /**\n   * Optional alias for the plugin instance\n   * Useful when using the same plugin multiple times with different configurations\n   */\n  readonly alias?: string;\n\n  /**\n   * Optional filter criteria for plugin selection\n   * Can be used to select specific plugin versions or variants\n   */\n  readonly filter?: PluginFilter;\n\n  /**\n   * Additional metadata to merge with plugin's default metadata\n   * This metadata will be available to the plugin during execution\n   */\n  readonly metadata?: MetaDataType;\n}\n\n/**\n * Synthesis step configuration combining source and plugin.\n * Extends StepCustomization to support injecting custom commands and env vars\n * into the synth CodeBuild step (same hooks available as stage steps).\n */\nexport interface SynthOptions extends StepCustomization {\n  /**\n   * Source configuration (S3, GitHub, or CodeStar)\n   */\n  readonly source: SourceType;\n\n  /**\n   * Plugin to use for synthesis\n   */\n  readonly plugin: PluginOptions;\n\n  /**\n   * Additional metadata for the synthesis step\n   * This will be merged with global metadata and plugin metadata\n   */\n  readonly metadata?: MetaDataType;\n\n  /**\n   * Step-level network configuration applied only to the synth CodeBuild step.\n   * Overrides the pipeline-level `defaults.network` when both are provided.\n   */\n  readonly network?: NetworkConfig;\n}\n\n/**\n * Per-step customization options for commands and environment variables.\n * Custom commands are injected before/after the plugin's commands.\n * Custom env vars are merged on top of the plugin's defaults.\n */\nexport interface StepCustomization {\n  /** Commands to run before the plugin's install commands */\n  readonly preInstallCommands?: string[];\n\n  /** Commands to run after the plugin's install commands */\n  readonly postInstallCommands?: string[];\n\n  /** Commands to run before the plugin's build commands */\n  readonly preCommands?: string[];\n\n  /** Commands to run after the plugin's build commands */\n  readonly postCommands?: string[];\n\n  /** Custom environment variables merged on top of the plugin's env */\n  readonly env?: Record<string, string>;\n}\n\n/**\n * An additional input artifact with an optional mount directory.\n * When directory is omitted, defaults to the artifact's outputDirectory.\n */\nexport interface AdditionalInputArtifactConfig {\n  /** Artifact key identifying the source step's output */\n  readonly artifact: ArtifactKey;\n\n  /** Directory to mount the input at. Defaults to artifact.outputDirectory when omitted. */\n  readonly directory?: string;\n}\n\n/**\n * Configuration for a single step within a pipeline stage.\n * Uses PluginOptions for name-based plugin selection (resolved at build time).\n */\nexport interface StageStepOptions extends StepCustomization {\n  /** Plugin to use for this step */\n  readonly plugin: PluginOptions;\n\n  /** Step-level metadata merged with stage and global metadata */\n  readonly metadata?: MetaDataType;\n\n  /** Optional network configuration for this step's CodeBuild action */\n  readonly network?: NetworkConfig;\n\n  /**\n   * CodeBuild timeout in minutes.\n   * @default 60 (AWS CodeBuild default)\n   */\n  readonly timeout?: number;\n\n  /**\n   * Position of this step within the pipeline wave.\n   * - 'pre': Runs before the stage deployment (default)\n   * - 'post': Runs after the stage deployment\n   * @default 'pre'\n   */\n  readonly position?: 'pre' | 'post';\n\n  /** Artifact key for this step's primary input (resolved via ArtifactManager) */\n  readonly inputArtifact?: ArtifactKey;\n\n  /** Additional input artifacts for this step. Each entry specifies an artifact and an optional mount directory. */\n  readonly additionalInputArtifacts?: AdditionalInputArtifactConfig[];\n\n  /** Override the plugin's failure behavior for this step. */\n  readonly failureBehavior?: 'fail' | 'warn' | 'ignore';\n}\n\n/**\n * A pipeline stage containing one or more build steps.\n * Each stage maps to a CDK Pipeline wave, with steps executing within the wave.\n */\nexport interface StageOptions {\n  /** Display name for this stage */\n  readonly stageName: string;\n\n  /** Optional alias used for wave/construct ID generation. Defaults to stageName. */\n  readonly alias?: string;\n\n  /** Build steps to execute within this stage */\n  readonly steps: StageStepOptions[];\n}\n\n/**\n * Options for creating a CodeBuild step in the pipeline\n */\nexport interface CodeBuildStepOptions extends StepCustomization {\n  /**\n   * Unique identifier for this CodeBuild step\n   * Should be descriptive and unique within the pipeline\n   * @example 'my-org-my-project-synth'\n   */\n  readonly id: string;\n\n  /**\n   * UniqueId instance for generating unique construct IDs\n   * Used for network resource lookups (VPC, subnets, security groups)\n   */\n  readonly uniqueId: UniqueId;\n\n  /**\n   * Plugin configuration from the database\n   * Contains all the plugin's spec data and runtime information\n   */\n  readonly plugin: Plugin;\n\n  /**\n   * CDK scope used to create constructs (VPC/subnet/security-group lookups).\n   */\n  readonly scope: Construct;\n\n  /**\n   * Input source for this step\n   * Typically the output from a previous step or the pipeline source\n   */\n  readonly input?: IFileSetProducer;\n\n  /**\n   * Additional metadata to merge with plugin metadata\n   * Will override conflicting keys from plugin metadata\n   */\n  readonly metadata?: MetaDataType;\n\n  /**\n   * Optional network configuration for the CodeBuild step.\n   * When provided, resolves VPC, subnet selection, and security groups\n   * so the build runs inside the specified network.\n   */\n  readonly network?: NetworkConfig;\n\n  /**\n   * Fallback CodeBuild compute type when the plugin doesn't specify one.\n   * @default ComputeType.SMALL\n   */\n  readonly defaultComputeType?: CdkComputeType;\n\n  /**\n   * CodeBuild timeout in minutes.\n   * @default 60 (AWS CodeBuild default)\n   */\n  readonly timeout?: number;\n\n  /** Additional inputs mapped by directory path (resolved FileSets) */\n  readonly additionalInputs?: Record<string, IFileSetProducer>;\n\n  /**\n   * Optional artifact manager for tracking build outputs\n   * When provided and primaryOutputDirectory is set, the step will be registered\n   */\n  readonly artifactManager?: ArtifactManager;\n\n  /**\n   * Stage name for artifact key generation\n   */\n  readonly stageName?: string;\n\n  /**\n   * Stage alias for artifact key generation\n   */\n  readonly stageAlias?: string;\n\n  /**\n   * Plugin alias for artifact key generation\n   */\n  readonly pluginAlias?: string;\n\n  /**\n   * Failure behavior for this step's build commands.\n   * Applied at shell level: 'fail' = default, 'warn' = log + continue, 'ignore' = || true.\n   */\n  readonly failureBehavior?: 'fail' | 'warn' | 'ignore';\n\n  /** Tenant identifier for resolving per-org secrets from AWS Secrets Manager */\n  readonly orgId?: string;\n\n  /**\n   * Pipeline-level config used as the `pipeline.*` scope when resolving\n   * template tokens inside plugin specs. Required — every `{{ pipeline.* }}`\n   * reference in a plugin spec is evaluated against this object at synth time.\n   *\n   * Callers constructing a step directly must provide the pipeline identity\n   * + metadata + vars so template resolution is never silently skipped.\n   */\n  readonly pipelineScope: Record<string, unknown>;\n}\n"]}