@pipeline-builder/pipeline-core 0.0.1

package/lib/pipeline/pipeline-configuration.d.ts

@@ -0,0 +1,81 @@
+import type { BuilderProps } from './pipeline-builder.js';
+import type { CodeCommitOptions, CodeStarOptions, GitHubOptions, S3Options, SourceType } from './source-types.js';
+import type { PluginOptions, StageOptions, StepCustomization } from './step-types.js';
+import type { CodeBuildDefaults, NetworkConfig } from '../core/network-types.js';
+import type { MetaDataType } from '../core/pipeline-types.js';
+/**
+ * Validated and processed pipeline configuration (business logic layer).
+ * This class handles all non-CDK logic: validation, sanitization, and metadata merging.
+ * It can be tested independently without CDK dependencies.
+ *
+ * ## Metadata merge chain (last wins)
+ *
+ * 1. `BuilderProps.global` — base metadata inherited by all steps
+ * 2. `BuilderProps.defaults.metadata` — pipeline-level CodeBuild defaults metadata
+ * 3. `BuilderProps.synth.metadata` or `StageStepOptions.metadata` — per-step metadata
+ * 4. `plugin.metadata` — plugin's own metadata (merged in `createCodeBuildStep`)
+ * 5. `metadataForXxx()` — extracted CDK props spread last into construct calls
+ *
+ * Steps 1–3 are merged here into `this.metadata.merged`.
+ * Step 4 happens in `createCodeBuildStep` via `merge(metadata, plugin.metadata)`.
+ * Step 5 is spread last in the CDK constructor call, giving metadata full override authority.
+ */
+export declare class PipelineConfiguration {
+    readonly project: string;
+    readonly organization: string;
+    readonly pipelineName: string;
+    readonly metadata: {
+        readonly global: MetaDataType;
+        readonly synth: MetaDataType;
+        readonly merged: MetaDataType;
+    };
+    readonly source: SourceType;
+    readonly plugin: PluginOptions;
+    readonly network: NetworkConfig | undefined;
+    readonly defaults: CodeBuildDefaults | undefined;
+    readonly synthCustomization: StepCustomization;
+    readonly stages: StageOptions[] | undefined;
+    /** Pipeline-level template variables, exposed to `{{ pipeline.vars.* }}`. */
+    readonly vars: Record<string, unknown>;
+    constructor(props: BuilderProps);
+    /**
+     * Template scope exposed as `pipeline.*` to pipeline configs, plugin specs, and
+     * the source builder. Built once here so every consumer — the synth step, each
+     * stage step, and the source token — resolves `{{ pipeline.* }}` against the
+     * identical snapshot (no drift between call sites).
+     */
+    getPipelineScope(): Record<string, unknown>;
+    /**
+     * Validates BuilderProps to ensure all required fields are present.
+     * Throws an error with detailed messages if validation fails.
+     */
+    private validateProps;
+    /**
+     * Extracts S3 source options with defaults applied.
+     *
+     * @returns S3 options with `objectKey` defaulting to `'source.zip'` and `trigger` defaulting to `NONE`
+     * @throws {Error} If the configured source type is not `s3`
+     */
+    getS3Options(): Required<Pick<S3Options, 'bucketName' | 'objectKey' | 'trigger'>> & Omit<S3Options, 'bucketName' | 'objectKey' | 'trigger'>;
+    /**
+     * Extracts GitHub source options with defaults applied.
+     *
+     * @returns GitHub options with `branch` defaulting to `'main'` and `trigger` defaulting to `NONE`
+     * @throws {Error} If the configured source type is not `github`
+     */
+    getGitHubOptions(): Required<Pick<GitHubOptions, 'repo' | 'branch' | 'trigger'>> & Omit<GitHubOptions, 'repo' | 'branch' | 'trigger'>;
+    /**
+     * Extracts CodeStar source options with defaults applied.
+     *
+     * @returns CodeStar options with `branch` defaulting to `'main'`, `trigger` defaulting to `NONE`, and `codeBuildCloneOutput` defaulting to `false`
+     * @throws {Error} If the configured source type is not `codestar`
+     */
+    getCodeStarOptions(): Required<Pick<CodeStarOptions, 'repo' | 'branch' | 'trigger' | 'codeBuildCloneOutput' | 'connectionArn'>>;
+    /**
+     * Extracts CodeCommit source options with defaults applied.
+     *
+     * @returns CodeCommit options with `branch` defaulting to `'main'` and `trigger` defaulting to `NONE`
+     * @throws {Error} If the configured source type is not `codecommit`
+     */
+    getCodeCommitOptions(): Required<Pick<CodeCommitOptions, 'repositoryName' | 'branch' | 'trigger'>>;
+}

package/lib/pipeline/pipeline-configuration.js

@@ -0,0 +1,214 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { CoreConstants } from '../config/app-config.js';
+import { merge, replaceNonAlphanumeric } from '../core/metadata-helpers.js';
+import { TriggerType } from '../core/pipeline-types.js';
+/**
+ * Validated and processed pipeline configuration (business logic layer).
+ * This class handles all non-CDK logic: validation, sanitization, and metadata merging.
+ * It can be tested independently without CDK dependencies.
+ *
+ * ## Metadata merge chain (last wins)
+ *
+ * 1. `BuilderProps.global` — base metadata inherited by all steps
+ * 2. `BuilderProps.defaults.metadata` — pipeline-level CodeBuild defaults metadata
+ * 3. `BuilderProps.synth.metadata` or `StageStepOptions.metadata` — per-step metadata
+ * 4. `plugin.metadata` — plugin's own metadata (merged in `createCodeBuildStep`)
+ * 5. `metadataForXxx()` — extracted CDK props spread last into construct calls
+ *
+ * Steps 1–3 are merged here into `this.metadata.merged`.
+ * Step 4 happens in `createCodeBuildStep` via `merge(metadata, plugin.metadata)`.
+ * Step 5 is spread last in the CDK constructor call, giving metadata full override authority.
+ */
+export class PipelineConfiguration {
+    project;
+    organization;
+    pipelineName;
+    metadata;
+    source;
+    plugin;
+    network;
+    defaults;
+    synthCustomization;
+    stages;
+    /** Pipeline-level template variables, exposed to `{{ pipeline.vars.* }}`. */
+    vars;
+    constructor(props) {
+        this.validateProps(props);
+        // Sanitize project and organization names
+        this.project = replaceNonAlphanumeric(props.project, '_').toLowerCase();
+        this.organization = replaceNonAlphanumeric(props.organization, '_').toLowerCase();
+        // Calculate pipeline name
+        this.pipelineName = props.pipelineName ?? `${this.organization}-${this.project}-pipeline`;
+        // Metadata merging: global → defaults → synth-specific
+        const global = { ...(props.global ?? {}) };
+        const withDefaults = merge(global, props.defaults?.metadata ?? {});
+        this.metadata = {
+            global,
+            synth: props.synth.metadata ?? {},
+            merged: merge(withDefaults, props.synth.metadata ?? {}),
+        };
+        // Expose synth/builder properties directly
+        this.source = props.synth.source;
+        this.plugin = props.synth.plugin;
+        this.network = props.synth.network;
+        this.defaults = props.defaults;
+        this.synthCustomization = {
+            preInstallCommands: props.synth.preInstallCommands,
+            postInstallCommands: props.synth.postInstallCommands,
+            preCommands: props.synth.preCommands,
+            postCommands: props.synth.postCommands,
+            env: props.synth.env,
+        };
+        this.stages = props.stages;
+        this.vars = props.vars ?? {};
+    }
+    /**
+     * Template scope exposed as `pipeline.*` to pipeline configs, plugin specs, and
+     * the source builder. Built once here so every consumer — the synth step, each
+     * stage step, and the source token — resolves `{{ pipeline.* }}` against the
+     * identical snapshot (no drift between call sites).
+     */
+    getPipelineScope() {
+        return {
+            pipeline: {
+                projectName: this.project,
+                project: this.project,
+                orgId: this.organization,
+                organization: this.organization,
+                pipelineName: this.pipelineName,
+                metadata: this.metadata.merged,
+                vars: this.vars,
+            },
+        };
+    }
+    /**
+     * Validates BuilderProps to ensure all required fields are present.
+     * Throws an error with detailed messages if validation fails.
+     */
+    validateProps(props) {
+        const errors = [];
+        if (!props.project) {
+            errors.push('BuilderProps.project is required');
+        }
+        if (!props.organization) {
+            errors.push('BuilderProps.organization is required');
+        }
+        if (!props.synth?.source) {
+            errors.push('BuilderProps.synth.source is required');
+        }
+        if (!props.synth?.plugin) {
+            errors.push('BuilderProps.synth.plugin is required');
+        }
+        else if (!props.synth.plugin.name?.trim()) {
+            errors.push('BuilderProps.synth.plugin.name must be a non-empty string');
+        }
+        // Validate repo format for GitHub and CodeStar sources (both use "owner/repo")
+        const sourceType = props.synth?.source?.type;
+        if (sourceType === 'github' || sourceType === 'codestar') {
+            const repo = props.synth?.source?.options?.repo;
+            if (repo && !repo.includes('/')) {
+                errors.push(`Invalid ${sourceType} repository format: "${repo}". Expected format: "owner/repo"`);
+            }
+        }
+        // Validate pipeline name length (AWS max 100 characters)
+        const MAX_PIPELINE_NAME_LENGTH = CoreConstants.PIPELINE_NAME_MAX_LENGTH;
+        const pipelineName = props.pipelineName
+            ?? `${replaceNonAlphanumeric(props.organization ?? '', '_').toLowerCase()}-${replaceNonAlphanumeric(props.project ?? '', '_').toLowerCase()}-pipeline`;
+        if (pipelineName.length > MAX_PIPELINE_NAME_LENGTH) {
+            errors.push(`Pipeline name "${pipelineName}" exceeds AWS maximum of ${MAX_PIPELINE_NAME_LENGTH} characters (${pipelineName.length})`);
+        }
+        // Validate stages
+        if (props.stages) {
+            const stageNames = new Set();
+            for (const stage of props.stages) {
+                if (!stage.stageName?.trim()) {
+                    errors.push('Each stage must have a non-empty stageName');
+                }
+                else if (stageNames.has(stage.stageName)) {
+                    errors.push(`Duplicate stage name: "${stage.stageName}"`);
+                }
+                else {
+                    stageNames.add(stage.stageName);
+                }
+                if (!stage.steps?.length) {
+                    errors.push(`Stage "${stage.stageName ?? '(unnamed)'}" must have at least one step`);
+                }
+            }
+        }
+        if (errors.length > 0) {
+            throw new Error('Pipeline configuration validation failed:\n' +
+                errors.map(e => `  - ${e}`).join('\n'));
+        }
+    }
+    /**
+     * Extracts S3 source options with defaults applied.
+     *
+     * @returns S3 options with `objectKey` defaulting to `'source.zip'` and `trigger` defaulting to `NONE`
+     * @throws {Error} If the configured source type is not `s3`
+     */
+    getS3Options() {
+        const source = this.source;
+        if (source.type !== 's3') {
+            throw new Error('Source type is not S3');
+        }
+        return {
+            ...source.options,
+            objectKey: source.options.objectKey ?? 'source.zip',
+            trigger: source.options.trigger ?? TriggerType.NONE,
+        };
+    }
+    /**
+     * Extracts GitHub source options with defaults applied.
+     *
+     * @returns GitHub options with `branch` defaulting to `'main'` and `trigger` defaulting to `NONE`
+     * @throws {Error} If the configured source type is not `github`
+     */
+    getGitHubOptions() {
+        const source = this.source;
+        if (source.type !== 'github') {
+            throw new Error('Source type is not GitHub');
+        }
+        return {
+            ...source.options,
+            branch: source.options.branch ?? 'main',
+            trigger: source.options.trigger ?? TriggerType.NONE,
+        };
+    }
+    /**
+     * Extracts CodeStar source options with defaults applied.
+     *
+     * @returns CodeStar options with `branch` defaulting to `'main'`, `trigger` defaulting to `NONE`, and `codeBuildCloneOutput` defaulting to `false`
+     * @throws {Error} If the configured source type is not `codestar`
+     */
+    getCodeStarOptions() {
+        const source = this.source;
+        if (source.type !== 'codestar') {
+            throw new Error('Source type is not CodeStar');
+        }
+        return {
+            ...source.options,
+            branch: source.options.branch ?? 'main',
+            trigger: source.options.trigger ?? TriggerType.NONE,
+            codeBuildCloneOutput: source.options.codeBuildCloneOutput ?? false,
+        };
+    }
+    /**
+     * Extracts CodeCommit source options with defaults applied.
+     *
+     * @returns CodeCommit options with `branch` defaulting to `'main'` and `trigger` defaulting to `NONE`
+     * @throws {Error} If the configured source type is not `codecommit`
+     */
+    getCodeCommitOptions() {
+        const source = this.source;
+        if (source.type !== 'codecommit') {
+            throw new Error('Source type is not CodeCommit');
+        }
+        return {
+            ...source.options,
+            branch: source.options.branch ?? 'main',
+            trigger: source.options.trigger ?? TriggerType.NONE,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipeline-configuration.js","sourceRoot":"","sources":["../../src/pipeline/pipeline-configuration.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { BuilderProps } from './pipeline-builder.js';\nimport type { CodeCommitOptions, CodeStarOptions, GitHubOptions, S3Options, SourceType } from './source-types.js';\nimport type { PluginOptions, StageOptions, StepCustomization } from './step-types.js';\nimport { CoreConstants } from '../config/app-config.js';\nimport { merge, replaceNonAlphanumeric } from '../core/metadata-helpers.js';\nimport type { CodeBuildDefaults, NetworkConfig } from '../core/network-types.js';\nimport type { MetaDataType } from '../core/pipeline-types.js';\nimport { TriggerType } from '../core/pipeline-types.js';\n\n/**\n * Validated and processed pipeline configuration (business logic layer).\n * This class handles all non-CDK logic: validation, sanitization, and metadata merging.\n * It can be tested independently without CDK dependencies.\n *\n * ## Metadata merge chain (last wins)\n *\n * 1. `BuilderProps.global` — base metadata inherited by all steps\n * 2. `BuilderProps.defaults.metadata` — pipeline-level CodeBuild defaults metadata\n * 3. `BuilderProps.synth.metadata` or `StageStepOptions.metadata` — per-step metadata\n * 4. `plugin.metadata` — plugin's own metadata (merged in `createCodeBuildStep`)\n * 5. `metadataForXxx()` — extracted CDK props spread last into construct calls\n *\n * Steps 1–3 are merged here into `this.metadata.merged`.\n * Step 4 happens in `createCodeBuildStep` via `merge(metadata, plugin.metadata)`.\n * Step 5 is spread last in the CDK constructor call, giving metadata full override authority.\n */\nexport class PipelineConfiguration {\n  public readonly project: string;\n  public readonly organization: string;\n  public readonly pipelineName: string;\n  public readonly metadata: {\n    readonly global: MetaDataType;\n    readonly synth: MetaDataType;\n    readonly merged: MetaDataType;\n  };\n  public readonly source: SourceType;\n  public readonly plugin: PluginOptions;\n  public readonly network: NetworkConfig | undefined;\n  public readonly defaults: CodeBuildDefaults | undefined;\n  public readonly synthCustomization: StepCustomization;\n  public readonly stages: StageOptions[] | undefined;\n  /** Pipeline-level template variables, exposed to `{{ pipeline.vars.* }}`. */\n  public readonly vars: Record<string, unknown>;\n\n  constructor(props: BuilderProps) {\n    this.validateProps(props);\n\n    // Sanitize project and organization names\n    this.project = replaceNonAlphanumeric(props.project, '_').toLowerCase();\n    this.organization = replaceNonAlphanumeric(props.organization, '_').toLowerCase();\n\n    // Calculate pipeline name\n    this.pipelineName = props.pipelineName ?? `${this.organization}-${this.project}-pipeline`;\n\n    // Metadata merging: global → defaults → synth-specific\n    const global = { ...(props.global ?? {}) };\n    const withDefaults = merge(global, props.defaults?.metadata ?? {});\n    this.metadata = {\n      global,\n      synth: props.synth.metadata ?? {},\n      merged: merge(withDefaults, props.synth.metadata ?? {}),\n    };\n\n    // Expose synth/builder properties directly\n    this.source = props.synth.source;\n    this.plugin = props.synth.plugin;\n    this.network = props.synth.network;\n    this.defaults = props.defaults;\n    this.synthCustomization = {\n      preInstallCommands: props.synth.preInstallCommands,\n      postInstallCommands: props.synth.postInstallCommands,\n      preCommands: props.synth.preCommands,\n      postCommands: props.synth.postCommands,\n      env: props.synth.env,\n    };\n    this.stages = props.stages;\n    this.vars = props.vars ?? {};\n  }\n\n  /**\n   * Template scope exposed as `pipeline.*` to pipeline configs, plugin specs, and\n   * the source builder. Built once here so every consumer — the synth step, each\n   * stage step, and the source token — resolves `{{ pipeline.* }}` against the\n   * identical snapshot (no drift between call sites).\n   */\n  getPipelineScope(): Record<string, unknown> {\n    return {\n      pipeline: {\n        projectName: this.project,\n        project: this.project,\n        orgId: this.organization,\n        organization: this.organization,\n        pipelineName: this.pipelineName,\n        metadata: this.metadata.merged,\n        vars: this.vars,\n      },\n    };\n  }\n\n  /**\n   * Validates BuilderProps to ensure all required fields are present.\n   * Throws an error with detailed messages if validation fails.\n   */\n  private validateProps(props: BuilderProps): void {\n    const errors: string[] = [];\n\n    if (!props.project) {\n      errors.push('BuilderProps.project is required');\n    }\n\n    if (!props.organization) {\n      errors.push('BuilderProps.organization is required');\n    }\n\n    if (!props.synth?.source) {\n      errors.push('BuilderProps.synth.source is required');\n    }\n\n    if (!props.synth?.plugin) {\n      errors.push('BuilderProps.synth.plugin is required');\n    } else if (!props.synth.plugin.name?.trim()) {\n      errors.push('BuilderProps.synth.plugin.name must be a non-empty string');\n    }\n\n    // Validate repo format for GitHub and CodeStar sources (both use \"owner/repo\")\n    const sourceType = props.synth?.source?.type;\n    if (sourceType === 'github' || sourceType === 'codestar') {\n      const repo = props.synth?.source?.options?.repo;\n      if (repo && !repo.includes('/')) {\n        errors.push(`Invalid ${sourceType} repository format: \"${repo}\". Expected format: \"owner/repo\"`);\n      }\n    }\n\n    // Validate pipeline name length (AWS max 100 characters)\n    const MAX_PIPELINE_NAME_LENGTH = CoreConstants.PIPELINE_NAME_MAX_LENGTH;\n    const pipelineName = props.pipelineName\n      ?? `${replaceNonAlphanumeric(props.organization ?? '', '_').toLowerCase()}-${replaceNonAlphanumeric(props.project ?? '', '_').toLowerCase()}-pipeline`;\n    if (pipelineName.length > MAX_PIPELINE_NAME_LENGTH) {\n      errors.push(`Pipeline name \"${pipelineName}\" exceeds AWS maximum of ${MAX_PIPELINE_NAME_LENGTH} characters (${pipelineName.length})`);\n    }\n\n    // Validate stages\n    if (props.stages) {\n      const stageNames = new Set<string>();\n      for (const stage of props.stages) {\n        if (!stage.stageName?.trim()) {\n          errors.push('Each stage must have a non-empty stageName');\n        } else if (stageNames.has(stage.stageName)) {\n          errors.push(`Duplicate stage name: \"${stage.stageName}\"`);\n        } else {\n          stageNames.add(stage.stageName);\n        }\n        if (!stage.steps?.length) {\n          errors.push(`Stage \"${stage.stageName ?? '(unnamed)'}\" must have at least one step`);\n        }\n      }\n    }\n\n    if (errors.length > 0) {\n      throw new Error(\n        'Pipeline configuration validation failed:\\n' +\n        errors.map(e => `  - ${e}`).join('\\n'),\n      );\n    }\n  }\n\n  /**\n   * Extracts S3 source options with defaults applied.\n   *\n   * @returns S3 options with `objectKey` defaulting to `'source.zip'` and `trigger` defaulting to `NONE`\n   * @throws {Error} If the configured source type is not `s3`\n   */\n  getS3Options(): Required<Pick<S3Options, 'bucketName' | 'objectKey' | 'trigger'>> & Omit<S3Options, 'bucketName' | 'objectKey' | 'trigger'> {\n    const source = this.source;\n    if (source.type !== 's3') {\n      throw new Error('Source type is not S3');\n    }\n\n    return {\n      ...source.options,\n      objectKey: source.options.objectKey ?? 'source.zip',\n      trigger: source.options.trigger ?? TriggerType.NONE,\n    };\n  }\n\n  /**\n   * Extracts GitHub source options with defaults applied.\n   *\n   * @returns GitHub options with `branch` defaulting to `'main'` and `trigger` defaulting to `NONE`\n   * @throws {Error} If the configured source type is not `github`\n   */\n  getGitHubOptions(): Required<Pick<GitHubOptions, 'repo' | 'branch' | 'trigger'>> & Omit<GitHubOptions, 'repo' | 'branch' | 'trigger'> {\n    const source = this.source;\n    if (source.type !== 'github') {\n      throw new Error('Source type is not GitHub');\n    }\n\n    return {\n      ...source.options,\n      branch: source.options.branch ?? 'main',\n      trigger: source.options.trigger ?? TriggerType.NONE,\n    };\n  }\n\n  /**\n   * Extracts CodeStar source options with defaults applied.\n   *\n   * @returns CodeStar options with `branch` defaulting to `'main'`, `trigger` defaulting to `NONE`, and `codeBuildCloneOutput` defaulting to `false`\n   * @throws {Error} If the configured source type is not `codestar`\n   */\n  getCodeStarOptions(): Required<Pick<CodeStarOptions, 'repo' | 'branch' | 'trigger' | 'codeBuildCloneOutput' | 'connectionArn'>> {\n    const source = this.source;\n    if (source.type !== 'codestar') {\n      throw new Error('Source type is not CodeStar');\n    }\n\n    return {\n      ...source.options,\n      branch: source.options.branch ?? 'main',\n      trigger: source.options.trigger ?? TriggerType.NONE,\n      codeBuildCloneOutput: source.options.codeBuildCloneOutput ?? false,\n    };\n  }\n\n  /**\n   * Extracts CodeCommit source options with defaults applied.\n   *\n   * @returns CodeCommit options with `branch` defaulting to `'main'` and `trigger` defaulting to `NONE`\n   * @throws {Error} If the configured source type is not `codecommit`\n   */\n  getCodeCommitOptions(): Required<Pick<CodeCommitOptions, 'repositoryName' | 'branch' | 'trigger'>> {\n    const source = this.source;\n    if (source.type !== 'codecommit') {\n      throw new Error('Source type is not CodeCommit');\n    }\n\n    return {\n      ...source.options,\n      branch: source.options.branch ?? 'main',\n      trigger: source.options.trigger ?? TriggerType.NONE,\n    };\n  }\n}\n"]}

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

@@ -0,0 +1,131 @@
+import type { Plugin } from '@pipeline-builder/pipeline-data';
+import { Duration } from 'aws-cdk-lib';
+import { Runtime } from 'aws-cdk-lib/aws-lambda';
+import { RetentionDays } from 'aws-cdk-lib/aws-logs';
+import { Construct } from 'constructs';
+import type { PluginOptions } from './step-types.js';
+import { UniqueId } from '../core/id-generator.js';
+/**
+ * Configuration for PluginLookup construct
+ */
+export interface PluginLookupProps {
+    readonly organization: string;
+    readonly project: string;
+    readonly platformUrl: string;
+    readonly uniqueId: UniqueId;
+    /** Organization ID for resolving per-org secrets from Secrets Manager */
+    readonly orgId?: string;
+    readonly runtime?: Runtime;
+    /** Lambda timeout (default: 30s) */
+    readonly timeout?: Duration;
+    /** Lambda memory in MB (default: 512) */
+    readonly memorySize?: number;
+    /** Log retention (default: ONE_WEEK) */
+    readonly logRetention?: RetentionDays;
+    /** Reserved concurrent executions for the lookup Lambda (default: 30) */
+    readonly reservedConcurrentExecutions?: number;
+    /**
+     * Plugins pre-resolved by `pipeline-manager pipeline synth` from the platform API.
+     * Keyed by `alias || name` (matches the construct's normalize() output).
+     * When a lookup hits this map, `plugin()` returns the resolved Plugin
+     * directly — no custom resource is created. This is what makes the
+     * name, version, commands, env, etc. available at synth time so the resulting
+     * CFN template ships with the real values baked in.
+     */
+    readonly resolvedPlugins?: Record<string, Plugin>;
+}
+/**
+ * CDK Construct responsible for looking up plugin configurations from an external platform
+ * using AWS CloudFormation Custom Resources backed by a Lambda function.
+ *
+ * This construct creates:
+ * - A Lambda function (plugin-lookup-handler) that fetches plugin configs
+ * - A CloudWatch Log Group for the Lambda
+ * - A Custom Resource Provider that invokes the Lambda
+ * - An IAM policy granting the Lambda access to the credentials secret
+ *
+ * ## Prerequisites
+ *
+ * Before deploying, store a JWT token in Secrets Manager:
+ * ```sh
+ * pipeline-manager infra store-token --days 30 --region <region>
+ * ```
+ *
+ * The Lambda resolves the secret by name at runtime:
+ * `{SECRETS_PATH_PREFIX}/{orgId}/platform`
+ *
+ * @see handlers/plugin-lookup-handler.ts for the Lambda implementation
+ */
+export declare class PluginLookup extends Construct {
+    private readonly _uniqueId;
+    private readonly _provider;
+    private readonly _platformUrl;
+    private readonly _runtime;
+    private readonly _timeout;
+    private readonly _memorySize;
+    private readonly _reservedConcurrentExecutions?;
+    private readonly _orgId?;
+    private readonly _resolvedPlugins?;
+    constructor(scope: Construct, id: string, props: PluginLookupProps);
+    /**
+     * Looks up and resolves plugin configuration using either a simple name or full PluginOptions object
+     * During synthesis, if the value is unresolved (token), returns fallback plugin
+     * During deployment, attempts to parse the actual value returned by the custom resource
+     * @param plugin - Plugin name (string) or complete PluginOptions configuration
+     * @returns Resolved Plugin object or fallback default configuration
+     */
+    plugin(plugin: string | PluginOptions): Plugin;
+    /**
+     * Creates the Lambda function that serves as the event handler for the custom resource provider.
+     *
+     * JWT token is stored in a pre-existing Secrets Manager secret at
+     * `{SECRETS_PATH_PREFIX}/{orgId}/platform`. The Lambda resolves the
+     * secret by name at runtime using `CoreConstants.SECRETS_PATH_PREFIX`.
+     *
+     * Create the secret before deploying with:
+     *   pipeline-manager infra store-token --days 30 --region <region>
+     */
+    private createLambdaFunction;
+    /**
+     * Build the default plugin filter.
+     * Access control (orgId scoping, public/private visibility) is handled by
+     * the platform's access control query builder based on the JWT's organizationId.
+     */
+    private defaultFilter;
+    private normalize;
+    /**
+     * Creates a CustomResource instance that triggers plugin lookup during deployment
+     */
+    private createCustomResource;
+    /** Base plugin shape with no-op defaults for fields CDK doesn't use. */
+    private static basePlugin;
+    /**
+     * Fallback for a plugin whose lookup returned no record (not in the platform
+     * catalog for this org) and so could not be pre-resolved at synth.
+     *
+     * This step FAILS the build (exit 1) on purpose. The previous behaviour —
+     * `echo "…" && exit 0` — was a false positive: an unresolved security/quality
+     * step (dependency-check, semgrep, spotbugs, …) reported the stage green while
+     * running nothing, giving false assurance that scans/builds had passed. A
+     * plugin step that can't run its plugin must go red, consistent with
+     * `basePlugin().failureBehavior === 'fail'`. The message is actionable so the
+     * operator knows the catalog is empty/incomplete, not that the tool crashed.
+     */
+    private fallback;
+    /**
+     * Synth plugin with pipeline-manager commands. Cold-start bootstrap for
+     * the synth step when pre-resolution by `pipeline-manager pipeline synth/deploy`
+     * didn't populate `resolvedPlugins` for the synth plugin. Runs on the
+     * configured `CODEBUILD_DEFAULT_IMAGE` (default `pipeline-bootstrap:1.0`)
+     * and self-bootstraps the real synth via
+     * `pipeline-manager pipeline synth --id ${PIPELINE_ID}`.
+     *
+     * No `installCommands`: the default image already has `pipeline-manager`
+     * baked in (that's the whole point of `pipeline-bootstrap:1.0`). If the
+     * operator points CODEBUILD_DEFAULT_IMAGE at an image lacking it (e.g.
+     * vanilla aws/codebuild/standard:7.0), this step exits 127 — fix that
+     * by using an image with pipeline-manager rather than papering over it
+     * with a per-build `npm install -g`.
+     */
+    bootstrap(): Plugin;
+}