@pipeline-builder/pipeline-core 3.4.111 → 3.4.112

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

@@ -36,6 +36,20 @@ export declare class SourceBuilder {
      * Creates a GitHub source for the pipeline
      */
     private createGitHubSource;
+    /**
+     * Resolve the GitHub authentication token into a {@link SecretValue} without
+     * leaking the token value into the synthesized template.
+     *
+     * - `undefined` token → no authentication (CDK default).
+     * - A `SecretValue` → passed through (already a reference, never plaintext).
+     * - A Secrets Manager ARN or `secretsmanager:<name>` string → resolved via
+     *   `SecretValue.secretsManager`, so only the reference lands in the template.
+     * - A genuine raw plaintext token → rejected by default (it would be baked as
+     *   plaintext into CloudFormation/CDK context). Only when
+     *   `allowPlainTextToken` is explicitly set is it embedded via
+     *   `SecretValue.unsafePlainText`, and a loud warning is emitted.
+     */
+    private resolveGitHubAuthentication;
     /**
      * Creates a CodeStar connection source for the pipeline
      */

package/lib/pipeline/source-builder.js

@@ -1,5 +1,6 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
+import { createLogger } from '@pipeline-builder/api-core';
 import { SecretValue } from 'aws-cdk-lib';
 import { Repository } from 'aws-cdk-lib/aws-codecommit';
 import { CodeCommitTrigger, GitHubTrigger, S3Trigger } from 'aws-cdk-lib/aws-codepipeline-actions';
@@ -9,6 +10,11 @@ import { Construct } from 'constructs';
 import { UniqueId } from '../core/id-generator.js';
 import { unwrapSecret } from '../core/pipeline-helpers.js';
 import { TriggerType } from '../core/pipeline-types.js';
+const log = createLogger('source-builder');
+/** A Secrets Manager ARN (`arn:aws:secretsmanager:...`, incl. partition variants). */
+const SECRETS_MANAGER_ARN = /^arn:aws[a-z-]*:secretsmanager:/i;
+/** A `secretsmanager:<secret-name>` shorthand reference. */
+const SECRETS_MANAGER_REF_PREFIX = 'secretsmanager:';
 /**
  * Creates the appropriate CodePipelineSource based on the pipeline configuration.
  *
@@ -76,14 +82,55 @@ export class SourceBuilder {
      */
     createGitHubSource() {
         const options = this.config.getGitHubOptions();
-        const authentication = options.token
-            ? (typeof options.token === 'string' ? SecretValue.unsafePlainText(options.token) : options.token)
-            : undefined;
         return CodePipelineSource.gitHub(options.repo, options.branch, {
             trigger: options.trigger === TriggerType.AUTO ? GitHubTrigger.POLL : GitHubTrigger.NONE,
-            authentication,
+            authentication: this.resolveGitHubAuthentication(options),
         });
     }
+    /**
+     * Resolve the GitHub authentication token into a {@link SecretValue} without
+     * leaking the token value into the synthesized template.
+     *
+     * - `undefined` token → no authentication (CDK default).
+     * - A `SecretValue` → passed through (already a reference, never plaintext).
+     * - A Secrets Manager ARN or `secretsmanager:<name>` string → resolved via
+     *   `SecretValue.secretsManager`, so only the reference lands in the template.
+     * - A genuine raw plaintext token → rejected by default (it would be baked as
+     *   plaintext into CloudFormation/CDK context). Only when
+     *   `allowPlainTextToken` is explicitly set is it embedded via
+     *   `SecretValue.unsafePlainText`, and a loud warning is emitted.
+     */
+    resolveGitHubAuthentication(options) {
+        const token = options.token;
+        if (token === undefined)
+            return undefined;
+        // A SecretValue is already a reference (e.g. Secrets Manager) — never plaintext.
+        if (typeof token !== 'string')
+            return token;
+        // A string that names a Secrets Manager secret is resolved to a reference so
+        // only the pointer — not the token — is written to the template / CDK context.
+        if (SECRETS_MANAGER_ARN.test(token)) {
+            return SecretValue.secretsManager(token);
+        }
+        if (token.toLowerCase().startsWith(SECRETS_MANAGER_REF_PREFIX)) {
+            return SecretValue.secretsManager(token.slice(SECRETS_MANAGER_REF_PREFIX.length));
+        }
+        // Genuine raw plaintext token — this is the exposure. Reject by default and
+        // point the caller at a secret reference or a CodeStar connection.
+        if (!options.allowPlainTextToken) {
+            throw new Error('GitHub source `token` is a raw plaintext value, which would be baked into the ' +
+                'synthesized CloudFormation template (and CDK context / stack state). Provide a ' +
+                'Secrets Manager reference instead — an `arn:aws:secretsmanager:...` ARN, a ' +
+                '`secretsmanager:<secret-name>` string, or a `SecretValue.secretsManager(...)` — or ' +
+                'prefer a CodeStar connection (`type: "codestar"`). To intentionally embed the token ' +
+                'in plaintext, set `allowPlainTextToken: true`.');
+        }
+        log.warn('GitHub source `token` is being embedded as PLAINTEXT in the synthesized CloudFormation ' +
+            'template because `allowPlainTextToken` is set. Anyone with template, CDK context, or ' +
+            'stack state access can read this token. Use a Secrets Manager reference or a CodeStar ' +
+            'connection instead.');
+        return SecretValue.unsafePlainText(token);
+    }
     /**
      * Creates a CodeStar connection source for the pipeline
      */
@@ -106,4 +153,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 { 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 { UniqueId } from '../core/id-generator.js';\nimport { unwrapSecret } from '../core/pipeline-helpers.js';\nimport { TriggerType, type SourceType } from '../core/pipeline-types.js';\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, but the\n * actual EventBridge rule creation is not yet implemented in this builder.\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    let trigger: S3Trigger;\n    switch (options.trigger) {\n      case TriggerType.AUTO: trigger = S3Trigger.EVENTS; break;\n      case TriggerType.SCHEDULE: trigger = S3Trigger.NONE; break;\n      default: trigger = S3Trigger.NONE;\n    }\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    const authentication = options.token\n      ? (typeof options.token === 'string' ? SecretValue.unsafePlainText(options.token) : options.token)\n      : undefined;\n\n    return CodePipelineSource.gitHub(options.repo, options.branch, {\n      trigger: options.trigger === TriggerType.AUTO ? GitHubTrigger.POLL : GitHubTrigger.NONE,\n      authentication,\n    });\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 } 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, but the\n * actual EventBridge rule creation is not yet implemented in this builder.\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    let trigger: S3Trigger;\n    switch (options.trigger) {\n      case TriggerType.AUTO: trigger = S3Trigger.EVENTS; break;\n      case TriggerType.SCHEDULE: trigger = S3Trigger.NONE; break;\n      default: trigger = S3Trigger.NONE;\n    }\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

@@ -98,10 +98,30 @@ export interface GitHubOptions {
      */
     readonly branch?: string;
     /**
-     * GitHub personal access token or SecretValue
-     * If not provided, uses default GitHub authentication
+     * GitHub authentication token.
+     *
+     * Prefer a Secrets Manager reference so the token value never lands in the
+     * synthesized CloudFormation template / CDK context. Accepted forms:
+     *   - a `SecretValue` (e.g. `SecretValue.secretsManager(...)`),
+     *   - a Secrets Manager ARN string (`arn:aws:secretsmanager:...`),
+     *   - a `secretsmanager:<secret-name>` shorthand string.
+     *
+     * A genuine raw plaintext token (e.g. a `ghp_...` PAT) is rejected by default,
+     * because baking it in would expose it to anyone with template/state access —
+     * set {@link allowPlainTextToken} to intentionally embed it.
+     *
+     * If not provided, uses default GitHub authentication. Consider a CodeStar
+     * connection (`type: 'codestar'`) as the modern, credential-free path.
      */
     readonly token?: SecretValue | string;
+    /**
+     * Opt-in escape hatch to embed a raw plaintext {@link token} directly in the
+     * synthesized template. Insecure — the token becomes readable by anyone with
+     * template, CDK context, or stack state access. Leave unset (default) to force
+     * a Secrets Manager reference instead.
+     * @default false
+     */
+    readonly allowPlainTextToken?: boolean;
     /**
      * Pipeline trigger behavior
      * @default TriggerType.NONE

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,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
+//# 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"]}

package/lib/template/evaluator.d.ts

@@ -11,6 +11,16 @@ export interface EvalError {
 /**
  * Look up a dot-separated path inside a scope object. Returns `undefined`
  * if any intermediate segment is missing or not an object.
+ *
+ * Only OWN enumerable-or-not-inherited properties are traversed: a segment is
+ * resolved via `Object.prototype.hasOwnProperty.call` so inherited members of
+ * the prototype chain (`constructor`, `toString`, `valueOf`, `hasOwnProperty`,
+ * the `__proto__` accessor, …) never resolve — they return `undefined` and thus
+ * fall through to the caller's normal unknown-path handling (a `| default:`
+ * fallback or a `TEMPLATE_UNKNOWN_PATH` error). Applied at every level,
+ * including the root segment, this also makes the scope's own top-level keys
+ * the effective root allow-list, so an unknown/prototype root is rejected even
+ * on the synth path that skips `validateTemplates`.
  */
 export declare function lookupPath(scope: Scope, path: string[]): unknown;
 /**

package/lib/template/evaluator.js

@@ -5,12 +5,24 @@ const RESERVED_ROOT_PATHS = new Set(['secrets']);
 /**
  * Look up a dot-separated path inside a scope object. Returns `undefined`
  * if any intermediate segment is missing or not an object.
+ *
+ * Only OWN enumerable-or-not-inherited properties are traversed: a segment is
+ * resolved via `Object.prototype.hasOwnProperty.call` so inherited members of
+ * the prototype chain (`constructor`, `toString`, `valueOf`, `hasOwnProperty`,
+ * the `__proto__` accessor, …) never resolve — they return `undefined` and thus
+ * fall through to the caller's normal unknown-path handling (a `| default:`
+ * fallback or a `TEMPLATE_UNKNOWN_PATH` error). Applied at every level,
+ * including the root segment, this also makes the scope's own top-level keys
+ * the effective root allow-list, so an unknown/prototype root is rejected even
+ * on the synth path that skips `validateTemplates`.
  */
 export function lookupPath(scope, path) {
     let cur = scope;
     for (const segment of path) {
         if (cur == null || typeof cur !== 'object')
             return undefined;
+        if (!Object.prototype.hasOwnProperty.call(cur, segment))
+            return undefined;
         cur = cur[segment];
     }
     return cur;
@@ -147,4 +159,4 @@ function makeEvalError(e) {
     err.pos = e.pos;
     return err;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"evaluator.js","sourceRoot":"","sources":["../../src/template/evaluator.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { ErrorCode } from '@pipeline-builder/api-core';\nimport type { CoerceKind, SourcePosition, Token } from './tokenizer.js';\n\nexport type Scope = Record<string, unknown>;\n\nexport interface EvalError {\n  code: ErrorCode;\n  message: string;\n  field?: string;\n  path?: string;\n  pos?: SourcePosition;\n}\n\nconst RESERVED_ROOT_PATHS = new Set(['secrets']);\n\n/**\n * Look up a dot-separated path inside a scope object. Returns `undefined`\n * if any intermediate segment is missing or not an object.\n */\nexport function lookupPath(scope: Scope, path: string[]): unknown {\n  let cur: unknown = scope;\n  for (const segment of path) {\n    if (cur == null || typeof cur !== 'object') return undefined;\n    cur = (cur as Record<string, unknown>)[segment];\n  }\n  return cur;\n}\n\n/**\n * Resolve a token stream against a scope. Returns the resolved string.\n * Throws `EvalError` when an unresolved path has no default filter.\n *\n * Coercion filters (`| number`, `| bool`, `| json`) only take effect\n * when the template expression is the entire field — e.g.\n * `replicas: \"{{ vars.count | number }}\"` yields `3` (number) while\n * `replicas: \"count={{ vars.count | number }}\"` yields `\"count=3\"`\n * (string, because the template is embedded in surrounding literals).\n * Mixed-literal fields always return a string.\n */\nexport function resolve(\n  tokens: Token[],\n  scope: Scope,\n  field?: string,\n): string | number | boolean | null | unknown[] | Record<string, unknown> {\n  // Whole-field coercion shortcut: only apply coercion when the entire field\n  // is a single expression (no surrounding literal text).\n  if (tokens.length === 1 && tokens[0]!.kind === 'expr' && tokens[0]!.coerce) {\n    const tok = tokens[0]! as Extract<Token, { kind: 'expr' }>;\n    const raw = resolveOne(tok, scope, field);\n    return applyCoercion(raw, tok.coerce!, tok, field);\n  }\n\n  const parts: string[] = [];\n  for (const tok of tokens) {\n    if (tok.kind === 'literal') {\n      parts.push(tok.value);\n      continue;\n    }\n    const raw = resolveOne(tok, scope, field);\n    parts.push(typeof raw === 'string' ? raw : String(raw));\n  }\n  return parts.join('');\n}\n\n/** Resolve a single expression token to its string form (no coercion). */\nfunction resolveOne(tok: Extract<Token, { kind: 'expr' }>, scope: Scope, field?: string): string {\n  const root = tok.path[0]!;\n  if (RESERVED_ROOT_PATHS.has(root)) {\n    throw makeEvalError({\n      code: ErrorCode.TEMPLATE_SECRETS_RESERVED,\n      message: `'${root}' is a reserved scope — use the plugin's 'secrets:' field instead`,\n      field,\n      path: tok.path.join('.'),\n      pos: tok.pos,\n    });\n  }\n  const value = lookupPath(scope, tok.path);\n  if (value == null || value === '') {\n    if (tok.defaultValue !== undefined) return tok.defaultValue;\n    throw makeEvalError({\n      code: ErrorCode.TEMPLATE_UNKNOWN_PATH,\n      message: `Template references unknown path '${tok.path.join('.')}' and no default provided`,\n      field,\n      path: tok.path.join('.'),\n      pos: tok.pos,\n    });\n  }\n  if (typeof value === 'object') {\n    throw makeEvalError({\n      code: ErrorCode.TEMPLATE_TYPE_MISMATCH,\n      message: `Template path '${tok.path.join('.')}' resolved to an object; only strings/numbers/booleans are interpolatable`,\n      field,\n      path: tok.path.join('.'),\n      pos: tok.pos,\n    });\n  }\n  return String(value);\n}\n\n/** Apply a whole-field coercion filter to a resolved string value. */\nfunction applyCoercion(\n  raw: string,\n  kind: CoerceKind,\n  tok: Extract<Token, { kind: 'expr' }>,\n  field?: string,\n): number | boolean | null | string | unknown[] | Record<string, unknown> {\n  switch (kind) {\n    case 'number': {\n      const n = Number(raw);\n      if (!Number.isFinite(n)) {\n        throw makeEvalError({\n          code: ErrorCode.TEMPLATE_TYPE_MISMATCH,\n          message: `'${raw}' cannot be coerced to number at path '${tok.path.join('.')}'`,\n          field,\n          path: tok.path.join('.'),\n          pos: tok.pos,\n        });\n      }\n      return n;\n    }\n    case 'bool': {\n      const v = raw.trim().toLowerCase();\n      if (v === 'true' || v === '1' || v === 'yes') return true;\n      if (v === 'false' || v === '0' || v === 'no' || v === '') return false;\n      throw makeEvalError({\n        code: ErrorCode.TEMPLATE_TYPE_MISMATCH,\n        message: `'${raw}' cannot be coerced to bool at path '${tok.path.join('.')}'`,\n        field,\n        path: tok.path.join('.'),\n        pos: tok.pos,\n      });\n    }\n    case 'json': {\n      try {\n        return JSON.parse(raw) as string | number | boolean | null | unknown[] | Record<string, unknown>;\n      } catch (err) {\n        throw makeEvalError({\n          code: ErrorCode.TEMPLATE_TYPE_MISMATCH,\n          message: `'${raw}' is not valid JSON at path '${tok.path.join('.')}': ${(err as Error).message}`,\n          field,\n          path: tok.path.join('.'),\n          pos: tok.pos,\n        });\n      }\n    }\n  }\n}\n\n/**\n * Extract dependency paths from a token stream. Used by the topological\n * sort pass to order resolution of self-referencing documents.\n */\nexport function dependencies(tokens: Token[]): string[] {\n  const out: string[] = [];\n  for (const tok of tokens) {\n    if (tok.kind === 'expr') out.push(tok.path.join('.'));\n  }\n  return out;\n}\n\nfunction makeEvalError(e: EvalError): Error & EvalError {\n  const err = new Error(e.message) as Error & EvalError;\n  err.name = 'TemplateEvalError';\n  err.code = e.code;\n  err.field = e.field;\n  err.path = e.path;\n  err.pos = e.pos;\n  return err;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"evaluator.js","sourceRoot":"","sources":["../../src/template/evaluator.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { ErrorCode } from '@pipeline-builder/api-core';\nimport type { CoerceKind, SourcePosition, Token } from './tokenizer.js';\n\nexport type Scope = Record<string, unknown>;\n\nexport interface EvalError {\n  code: ErrorCode;\n  message: string;\n  field?: string;\n  path?: string;\n  pos?: SourcePosition;\n}\n\nconst RESERVED_ROOT_PATHS = new Set(['secrets']);\n\n/**\n * Look up a dot-separated path inside a scope object. Returns `undefined`\n * if any intermediate segment is missing or not an object.\n *\n * Only OWN enumerable-or-not-inherited properties are traversed: a segment is\n * resolved via `Object.prototype.hasOwnProperty.call` so inherited members of\n * the prototype chain (`constructor`, `toString`, `valueOf`, `hasOwnProperty`,\n * the `__proto__` accessor, …) never resolve — they return `undefined` and thus\n * fall through to the caller's normal unknown-path handling (a `| default:`\n * fallback or a `TEMPLATE_UNKNOWN_PATH` error). Applied at every level,\n * including the root segment, this also makes the scope's own top-level keys\n * the effective root allow-list, so an unknown/prototype root is rejected even\n * on the synth path that skips `validateTemplates`.\n */\nexport function lookupPath(scope: Scope, path: string[]): unknown {\n  let cur: unknown = scope;\n  for (const segment of path) {\n    if (cur == null || typeof cur !== 'object') return undefined;\n    if (!Object.prototype.hasOwnProperty.call(cur, segment)) return undefined;\n    cur = (cur as Record<string, unknown>)[segment];\n  }\n  return cur;\n}\n\n/**\n * Resolve a token stream against a scope. Returns the resolved string.\n * Throws `EvalError` when an unresolved path has no default filter.\n *\n * Coercion filters (`| number`, `| bool`, `| json`) only take effect\n * when the template expression is the entire field — e.g.\n * `replicas: \"{{ vars.count | number }}\"` yields `3` (number) while\n * `replicas: \"count={{ vars.count | number }}\"` yields `\"count=3\"`\n * (string, because the template is embedded in surrounding literals).\n * Mixed-literal fields always return a string.\n */\nexport function resolve(\n  tokens: Token[],\n  scope: Scope,\n  field?: string,\n): string | number | boolean | null | unknown[] | Record<string, unknown> {\n  // Whole-field coercion shortcut: only apply coercion when the entire field\n  // is a single expression (no surrounding literal text).\n  if (tokens.length === 1 && tokens[0]!.kind === 'expr' && tokens[0]!.coerce) {\n    const tok = tokens[0]! as Extract<Token, { kind: 'expr' }>;\n    const raw = resolveOne(tok, scope, field);\n    return applyCoercion(raw, tok.coerce!, tok, field);\n  }\n\n  const parts: string[] = [];\n  for (const tok of tokens) {\n    if (tok.kind === 'literal') {\n      parts.push(tok.value);\n      continue;\n    }\n    const raw = resolveOne(tok, scope, field);\n    parts.push(typeof raw === 'string' ? raw : String(raw));\n  }\n  return parts.join('');\n}\n\n/** Resolve a single expression token to its string form (no coercion). */\nfunction resolveOne(tok: Extract<Token, { kind: 'expr' }>, scope: Scope, field?: string): string {\n  const root = tok.path[0]!;\n  if (RESERVED_ROOT_PATHS.has(root)) {\n    throw makeEvalError({\n      code: ErrorCode.TEMPLATE_SECRETS_RESERVED,\n      message: `'${root}' is a reserved scope — use the plugin's 'secrets:' field instead`,\n      field,\n      path: tok.path.join('.'),\n      pos: tok.pos,\n    });\n  }\n  const value = lookupPath(scope, tok.path);\n  if (value == null || value === '') {\n    if (tok.defaultValue !== undefined) return tok.defaultValue;\n    throw makeEvalError({\n      code: ErrorCode.TEMPLATE_UNKNOWN_PATH,\n      message: `Template references unknown path '${tok.path.join('.')}' and no default provided`,\n      field,\n      path: tok.path.join('.'),\n      pos: tok.pos,\n    });\n  }\n  if (typeof value === 'object') {\n    throw makeEvalError({\n      code: ErrorCode.TEMPLATE_TYPE_MISMATCH,\n      message: `Template path '${tok.path.join('.')}' resolved to an object; only strings/numbers/booleans are interpolatable`,\n      field,\n      path: tok.path.join('.'),\n      pos: tok.pos,\n    });\n  }\n  return String(value);\n}\n\n/** Apply a whole-field coercion filter to a resolved string value. */\nfunction applyCoercion(\n  raw: string,\n  kind: CoerceKind,\n  tok: Extract<Token, { kind: 'expr' }>,\n  field?: string,\n): number | boolean | null | string | unknown[] | Record<string, unknown> {\n  switch (kind) {\n    case 'number': {\n      const n = Number(raw);\n      if (!Number.isFinite(n)) {\n        throw makeEvalError({\n          code: ErrorCode.TEMPLATE_TYPE_MISMATCH,\n          message: `'${raw}' cannot be coerced to number at path '${tok.path.join('.')}'`,\n          field,\n          path: tok.path.join('.'),\n          pos: tok.pos,\n        });\n      }\n      return n;\n    }\n    case 'bool': {\n      const v = raw.trim().toLowerCase();\n      if (v === 'true' || v === '1' || v === 'yes') return true;\n      if (v === 'false' || v === '0' || v === 'no' || v === '') return false;\n      throw makeEvalError({\n        code: ErrorCode.TEMPLATE_TYPE_MISMATCH,\n        message: `'${raw}' cannot be coerced to bool at path '${tok.path.join('.')}'`,\n        field,\n        path: tok.path.join('.'),\n        pos: tok.pos,\n      });\n    }\n    case 'json': {\n      try {\n        return JSON.parse(raw) as string | number | boolean | null | unknown[] | Record<string, unknown>;\n      } catch (err) {\n        throw makeEvalError({\n          code: ErrorCode.TEMPLATE_TYPE_MISMATCH,\n          message: `'${raw}' is not valid JSON at path '${tok.path.join('.')}': ${(err as Error).message}`,\n          field,\n          path: tok.path.join('.'),\n          pos: tok.pos,\n        });\n      }\n    }\n  }\n}\n\n/**\n * Extract dependency paths from a token stream. Used by the topological\n * sort pass to order resolution of self-referencing documents.\n */\nexport function dependencies(tokens: Token[]): string[] {\n  const out: string[] = [];\n  for (const tok of tokens) {\n    if (tok.kind === 'expr') out.push(tok.path.join('.'));\n  }\n  return out;\n}\n\nfunction makeEvalError(e: EvalError): Error & EvalError {\n  const err = new Error(e.message) as Error & EvalError;\n  err.name = 'TemplateEvalError';\n  err.code = e.code;\n  err.field = e.field;\n  err.path = e.path;\n  err.pos = e.pos;\n  return err;\n}\n"]}

package/lib/template/walker.js

@@ -54,9 +54,22 @@ export function walkAndBind(root, isTemplatable, includeLiteralOnly = false) {
     });
     return entries;
 }
+/**
+ * Keys that must never be walked into or written through: assigning to
+ * `__proto__` / `constructor` / `prototype` could retarget an object's
+ * prototype. `Object.entries` yields own enumerable keys only, but a JSON
+ * document parsed with `JSON.parse` can carry a genuine own enumerable
+ * `__proto__` (or `constructor`) key, so a captured keyPath could contain one.
+ * Refuse the write in that case rather than mutating the prototype.
+ */
+const UNSAFE_WRITE_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
 function writeField(root, parts, value) {
     if (parts.length === 0)
         return;
+    for (const p of parts) {
+        if (typeof p === 'string' && UNSAFE_WRITE_KEYS.has(p))
+            return;
+    }
     let cur = root;
     for (let i = 0; i < parts.length - 1; i++) {
         if (cur == null || typeof cur !== 'object')
@@ -67,4 +80,4 @@ function writeField(root, parts, value) {
         return;
     cur[parts[parts.length - 1]] = value;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"walker.js","sourceRoot":"","sources":["../../src/template/walker.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { hasTemplate, tokenize, type Token } from './tokenizer.js';\n\nexport interface WalkEntry {\n  /** Dotted path to the field inside the document, e.g. 'commands[3]' or 'env.STAGE' */\n  field: string;\n  /** Raw source string containing template tokens */\n  source: string;\n  /** Parsed token stream */\n  tokens: Token[];\n  /** Setter to write back a resolved value into the original `root` object */\n  set: (value: unknown) => void;\n}\n\nexport type FieldPredicate = (field: string) => boolean;\n\n/**\n * Visit every templatable string leaf under `root`. Calls `handler(field, source)`\n * for each string whose field path satisfies `isTemplatable` and contains `{{`.\n * Does NOT tokenize — callers decide whether to throw or collect errors.\n */\nexport function visitStrings(\n  root: unknown,\n  isTemplatable: FieldPredicate,\n  handler: (field: string, source: string, keyPath: Array<string | number>) => void,\n): void {\n  step(root, '', [], isTemplatable, handler);\n}\n\nfunction step(\n  node: unknown,\n  field: string,\n  keyPath: Array<string | number>,\n  isTemplatable: FieldPredicate,\n  handler: (field: string, source: string, keyPath: Array<string | number>) => void,\n): void {\n  if (Array.isArray(node)) {\n    node.forEach((child, idx) => step(child, `${field}[${idx}]`, [...keyPath, idx], isTemplatable, handler));\n    return;\n  }\n  if (node !== null && typeof node === 'object') {\n    for (const [key, child] of Object.entries(node as Record<string, unknown>)) {\n      step(child, field ? `${field}.${key}` : key, [...keyPath, key], isTemplatable, handler);\n    }\n    return;\n  }\n  if (typeof node === 'string' && isTemplatable(field) && hasTemplate(node)) {\n    handler(field, node, keyPath);\n  }\n}\n\n/**\n * Walk all templatable string fields under `root`, returning one entry per\n * templated field with a bound `set()` that mutates `root` in place.\n * Tokenization happens eagerly here — parse errors throw.\n *\n * By default only fields containing at least one `{{ expr }}` are returned.\n * Pass `includeLiteralOnly` to also return fields whose only template content\n * is a `{{{{` escape sequence — these still need rewriting so the tokenizer's\n * `{{{{` → `{{` unescape actually materializes into the document.\n *\n * The bound `set()` writes back via the exact key path captured during the\n * walk (the real `Object.entries` keys), so document keys containing `.`,\n * `[`, or `]` (e.g. `env[\"FOO.BAR\"]`) are written correctly rather than being\n * silently dropped by re-parsing a flattened dotted field string.\n */\nexport function walkAndBind<T extends object>(\n  root: T,\n  isTemplatable: FieldPredicate,\n  includeLiteralOnly = false,\n): WalkEntry[] {\n  const entries: WalkEntry[] = [];\n  visitStrings(root, isTemplatable, (field, source, keyPath) => {\n    const tokens = tokenize(source);\n    if (!includeLiteralOnly && !tokens.some(t => t.kind === 'expr')) return;\n    entries.push({\n      field,\n      source,\n      tokens,\n      set: (value: unknown) => writeField(root, keyPath, value),\n    });\n  });\n  return entries;\n}\n\n/**\n * Keys that must never be walked into or written through: assigning to\n * `__proto__` / `constructor` / `prototype` could retarget an object's\n * prototype. `Object.entries` yields own enumerable keys only, but a JSON\n * document parsed with `JSON.parse` can carry a genuine own enumerable\n * `__proto__` (or `constructor`) key, so a captured keyPath could contain one.\n * Refuse the write in that case rather than mutating the prototype.\n */\nconst UNSAFE_WRITE_KEYS = new Set(['__proto__', 'constructor', 'prototype']);\n\nfunction writeField(root: unknown, parts: Array<string | number>, value: unknown): void {\n  if (parts.length === 0) return;\n  for (const p of parts) {\n    if (typeof p === 'string' && UNSAFE_WRITE_KEYS.has(p)) return;\n  }\n  let cur: unknown = root;\n  for (let i = 0; i < parts.length - 1; i++) {\n    if (cur == null || typeof cur !== 'object') return;\n    cur = (cur as Record<string | number, unknown>)[parts[i]!];\n  }\n  if (cur == null || typeof cur !== 'object') return;\n  (cur as Record<string | number, unknown>)[parts[parts.length - 1]!] = value;\n}\n"]}

package/package.json

@@ -29,8 +29,8 @@
     "constructs": "10.7.0",
     "jsonwebtoken": "9.0.3",
     "uuid": "14.0.1",
-    "@pipeline-builder/api-core": "3.4.94",
-    "@pipeline-builder/pipeline-data": "3.4.97"
+    "@pipeline-builder/api-core": "3.4.95",
+    "@pipeline-builder/pipeline-data": "3.4.98"
   },
   "keywords": [
     "ci-cd",
@@ -86,7 +86,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "3.4.111",
+  "version": "3.4.112",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },