@pipeline-builder/pipeline-core 3.1.5 → 3.2.1

package/lib/pipeline/step-types.js

@@ -2,4 +2,4 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 Object.defineProperty(exports, "__esModule", { value: true });
-//# 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';\nimport type { UniqueId } from '../core/id-generator';\nimport type { NetworkConfig } from '../core/network-types';\nimport type { ComputeType, PluginType, MetaDataType, SourceType } from '../core/pipeline-types';\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/**\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"]}
+//# 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';\nimport type { UniqueId } from '../core/id-generator';\nimport type { NetworkConfig } from '../core/network-types';\nimport type { ComputeType, PluginType, MetaDataType, SourceType } from '../core/pipeline-types';\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"]}

package/lib/template/cache.d.ts

@@ -0,0 +1,19 @@
+import { Token } from './tokenizer';
+/**
+ * Small LRU cache for parsed token streams. Keys are caller-chosen
+ * (typically `${pluginId}:${version}:${fieldPath}`). Capacity is bounded
+ * so synth-time resolution in long-running services doesn't leak.
+ */
+export declare class TokenCache {
+    private readonly max;
+    private readonly map;
+    constructor(max?: number);
+    get(key: string): Token[] | undefined;
+    set(key: string, tokens: Token[]): void;
+    invalidate(key: string): void;
+    invalidatePrefix(prefix: string): void;
+    parse(key: string, source: string): Token[];
+    clear(): void;
+    get size(): number;
+}
+export declare const defaultTokenCache: TokenCache;

package/lib/template/cache.js

@@ -0,0 +1,63 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultTokenCache = exports.TokenCache = void 0;
+const tokenizer_1 = require("./tokenizer");
+/**
+ * Small LRU cache for parsed token streams. Keys are caller-chosen
+ * (typically `${pluginId}:${version}:${fieldPath}`). Capacity is bounded
+ * so synth-time resolution in long-running services doesn't leak.
+ */
+class TokenCache {
+    max;
+    map = new Map();
+    constructor(max = 100) {
+        this.max = max;
+    }
+    get(key) {
+        const hit = this.map.get(key);
+        if (!hit)
+            return undefined;
+        // Refresh recency by re-inserting
+        this.map.delete(key);
+        this.map.set(key, hit);
+        return hit;
+    }
+    set(key, tokens) {
+        if (this.map.has(key))
+            this.map.delete(key);
+        this.map.set(key, tokens);
+        if (this.map.size > this.max) {
+            const oldest = this.map.keys().next().value;
+            this.map.delete(oldest);
+        }
+    }
+    invalidate(key) {
+        this.map.delete(key);
+    }
+    invalidatePrefix(prefix) {
+        for (const k of Array.from(this.map.keys())) {
+            if (k.startsWith(prefix))
+                this.map.delete(k);
+        }
+    }
+    parse(key, source) {
+        const hit = this.get(key);
+        if (hit)
+            return hit;
+        const tokens = (0, tokenizer_1.tokenize)(source);
+        this.set(key, tokens);
+        return tokens;
+    }
+    clear() {
+        this.map.clear();
+    }
+    get size() {
+        return this.map.size;
+    }
+}
+exports.TokenCache = TokenCache;
+// Shared default cache for callers that don't want to own one.
+exports.defaultTokenCache = new TokenCache();
+//# sourceMappingURL=data:application/json;base64,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

package/lib/template/evaluator.d.ts

@@ -0,0 +1,32 @@
+import { ErrorCode } from '@pipeline-builder/api-core';
+import { SourcePosition, Token } from './tokenizer';
+export type Scope = Record<string, unknown>;
+export interface EvalError {
+    code: ErrorCode;
+    message: string;
+    field?: string;
+    path?: string;
+    pos?: SourcePosition;
+}
+/**
+ * Look up a dot-separated path inside a scope object. Returns `undefined`
+ * if any intermediate segment is missing or not an object.
+ */
+export declare function lookupPath(scope: Scope, path: string[]): unknown;
+/**
+ * Resolve a token stream against a scope. Returns the resolved string.
+ * Throws `EvalError` when an unresolved path has no default filter.
+ *
+ * Coercion filters (`| number`, `| bool`, `| json`) only take effect
+ * when the template expression is the entire field — e.g.
+ * `replicas: "{{ vars.count | number }}"` yields `3` (number) while
+ * `replicas: "count={{ vars.count | number }}"` yields `"count=3"`
+ * (string, because the template is embedded in surrounding literals).
+ * Mixed-literal fields always return a string.
+ */
+export declare function resolve(tokens: Token[], scope: Scope, field?: string): string | number | boolean | null | unknown[] | Record<string, unknown>;
+/**
+ * Extract dependency paths from a token stream. Used by the topological
+ * sort pass to order resolution of self-referencing documents.
+ */
+export declare function dependencies(tokens: Token[]): string[];

package/lib/template/evaluator.js

@@ -0,0 +1,155 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lookupPath = lookupPath;
+exports.resolve = resolve;
+exports.dependencies = dependencies;
+const api_core_1 = require("@pipeline-builder/api-core");
+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.
+ */
+function lookupPath(scope, path) {
+    let cur = scope;
+    for (const segment of path) {
+        if (cur == null || typeof cur !== 'object')
+            return undefined;
+        cur = cur[segment];
+    }
+    return cur;
+}
+/**
+ * Resolve a token stream against a scope. Returns the resolved string.
+ * Throws `EvalError` when an unresolved path has no default filter.
+ *
+ * Coercion filters (`| number`, `| bool`, `| json`) only take effect
+ * when the template expression is the entire field — e.g.
+ * `replicas: "{{ vars.count | number }}"` yields `3` (number) while
+ * `replicas: "count={{ vars.count | number }}"` yields `"count=3"`
+ * (string, because the template is embedded in surrounding literals).
+ * Mixed-literal fields always return a string.
+ */
+function resolve(tokens, scope, field) {
+    // Whole-field coercion shortcut: only apply coercion when the entire field
+    // is a single expression (no surrounding literal text).
+    if (tokens.length === 1 && tokens[0].kind === 'expr' && tokens[0].coerce) {
+        const tok = tokens[0];
+        const raw = resolveOne(tok, scope, field);
+        return applyCoercion(raw, tok.coerce, tok, field);
+    }
+    const parts = [];
+    for (const tok of tokens) {
+        if (tok.kind === 'literal') {
+            parts.push(tok.value);
+            continue;
+        }
+        const raw = resolveOne(tok, scope, field);
+        parts.push(typeof raw === 'string' ? raw : String(raw));
+    }
+    return parts.join('');
+}
+/** Resolve a single expression token to its string form (no coercion). */
+function resolveOne(tok, scope, field) {
+    const root = tok.path[0];
+    if (RESERVED_ROOT_PATHS.has(root)) {
+        throw makeEvalError({
+            code: api_core_1.ErrorCode.TEMPLATE_SECRETS_RESERVED,
+            message: `'${root}' is a reserved scope — use the plugin's 'secrets:' field instead`,
+            field,
+            path: tok.path.join('.'),
+            pos: tok.pos,
+        });
+    }
+    const value = lookupPath(scope, tok.path);
+    if (value == null || value === '') {
+        if (tok.defaultValue !== undefined)
+            return tok.defaultValue;
+        throw makeEvalError({
+            code: api_core_1.ErrorCode.TEMPLATE_UNKNOWN_PATH,
+            message: `Template references unknown path '${tok.path.join('.')}' and no default provided`,
+            field,
+            path: tok.path.join('.'),
+            pos: tok.pos,
+        });
+    }
+    if (typeof value === 'object') {
+        throw makeEvalError({
+            code: api_core_1.ErrorCode.TEMPLATE_TYPE_MISMATCH,
+            message: `Template path '${tok.path.join('.')}' resolved to an object; only strings/numbers/booleans are interpolatable`,
+            field,
+            path: tok.path.join('.'),
+            pos: tok.pos,
+        });
+    }
+    return String(value);
+}
+/** Apply a whole-field coercion filter to a resolved string value. */
+function applyCoercion(raw, kind, tok, field) {
+    switch (kind) {
+        case 'number': {
+            const n = Number(raw);
+            if (!Number.isFinite(n)) {
+                throw makeEvalError({
+                    code: api_core_1.ErrorCode.TEMPLATE_TYPE_MISMATCH,
+                    message: `'${raw}' cannot be coerced to number at path '${tok.path.join('.')}'`,
+                    field,
+                    path: tok.path.join('.'),
+                    pos: tok.pos,
+                });
+            }
+            return n;
+        }
+        case 'bool': {
+            const v = raw.trim().toLowerCase();
+            if (v === 'true' || v === '1' || v === 'yes')
+                return true;
+            if (v === 'false' || v === '0' || v === 'no' || v === '')
+                return false;
+            throw makeEvalError({
+                code: api_core_1.ErrorCode.TEMPLATE_TYPE_MISMATCH,
+                message: `'${raw}' cannot be coerced to bool at path '${tok.path.join('.')}'`,
+                field,
+                path: tok.path.join('.'),
+                pos: tok.pos,
+            });
+        }
+        case 'json': {
+            try {
+                return JSON.parse(raw);
+            }
+            catch (err) {
+                throw makeEvalError({
+                    code: api_core_1.ErrorCode.TEMPLATE_TYPE_MISMATCH,
+                    message: `'${raw}' is not valid JSON at path '${tok.path.join('.')}': ${err.message}`,
+                    field,
+                    path: tok.path.join('.'),
+                    pos: tok.pos,
+                });
+            }
+        }
+    }
+}
+/**
+ * Extract dependency paths from a token stream. Used by the topological
+ * sort pass to order resolution of self-referencing documents.
+ */
+function dependencies(tokens) {
+    const out = [];
+    for (const tok of tokens) {
+        if (tok.kind === 'expr')
+            out.push(tok.path.join('.'));
+    }
+    return out;
+}
+function makeEvalError(e) {
+    const err = new Error(e.message);
+    err.name = 'TemplateEvalError';
+    err.code = e.code;
+    err.field = e.field;
+    err.path = e.path;
+    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 { CoerceKind, SourcePosition, Token } from './tokenizer';\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"]}

package/lib/template/index.d.ts

@@ -0,0 +1,42 @@
+export { tokenize, hasTemplate, TokenizerError, MAX_FIELD_SIZE_BYTES, MAX_PATH_DEPTH, MAX_IDENTIFIER_LENGTH, type Token, type LiteralToken, type ExprToken, type SourcePosition, } from './tokenizer';
+export { resolve, lookupPath, dependencies, type Scope, type EvalError, } from './evaluator';
+export { walkAndBind, type WalkEntry, type FieldPredicate, } from './walker';
+export { topoSort, type TopoNode, type TopoResult, } from './topo-sort';
+export { TokenCache, defaultTokenCache, } from './cache';
+export { validateTemplates, detectCycles, allowedScopeRoots, type TemplateError, type ValidationResult, } from './validate';
+export { recordResolution, templateResolutionsTotal, templateResolutionDurationMs, } from './metrics';
+import { ErrorCode } from '@pipeline-builder/api-core';
+import { type Scope } from './evaluator';
+import { type FieldPredicate } from './walker';
+export interface ResolveResult {
+    errors: Array<{
+        code: ErrorCode;
+        message: string;
+        field?: string;
+        path?: string;
+    }>;
+}
+/**
+ * Resolve all templates inside `doc` by mutating string fields in place.
+ * `doc` is treated as opaque — only string fields that match `isTemplatable`
+ * are rewritten. Returns collected errors (empty array on success).
+ *
+ * `docType` is used for metrics; pass 'pipeline' or 'plugin'.
+ */
+export declare function resolveTemplates<T extends object>(doc: T, scope: Scope, isTemplatable: FieldPredicate, docType?: 'pipeline' | 'plugin'): ResolveResult;
+/**
+ * Resolve a self-referencing document (e.g. pipeline.json where
+ * metadata fields reference each other). Topologically orders the
+ * resolution so dependencies come first. Mutates `doc` in place.
+ *
+ * `fieldToScopePath` maps each field (e.g. `metadata.env`) to the scope
+ * path it populates (typically the same, sans any array indices).
+ */
+export declare function resolveSelfReferencing<T extends object>(doc: T, scope: Scope, isTemplatable: FieldPredicate, fieldToScopePath: (field: string) => string | null, docType?: 'pipeline' | 'plugin'): ResolveResult;
+/**
+ * Inline round-trip helper — parses and resolves a single string against
+ * a scope. Returns a string unless a whole-field coercion filter was
+ * used (in which case the native type from `| number`, `| bool`, or
+ * `| json` is returned).
+ */
+export declare function resolveString(source: string, scope: Scope): string | number | boolean | null | unknown[] | Record<string, unknown>;

package/lib/template/index.js

@@ -0,0 +1,153 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templateResolutionDurationMs = exports.templateResolutionsTotal = exports.recordResolution = exports.allowedScopeRoots = exports.detectCycles = exports.validateTemplates = exports.defaultTokenCache = exports.TokenCache = exports.topoSort = exports.walkAndBind = exports.dependencies = exports.lookupPath = exports.resolve = exports.MAX_IDENTIFIER_LENGTH = exports.MAX_PATH_DEPTH = exports.MAX_FIELD_SIZE_BYTES = exports.TokenizerError = exports.hasTemplate = exports.tokenize = void 0;
+exports.resolveTemplates = resolveTemplates;
+exports.resolveSelfReferencing = resolveSelfReferencing;
+exports.resolveString = resolveString;
+var tokenizer_1 = require("./tokenizer");
+Object.defineProperty(exports, "tokenize", { enumerable: true, get: function () { return tokenizer_1.tokenize; } });
+Object.defineProperty(exports, "hasTemplate", { enumerable: true, get: function () { return tokenizer_1.hasTemplate; } });
+Object.defineProperty(exports, "TokenizerError", { enumerable: true, get: function () { return tokenizer_1.TokenizerError; } });
+Object.defineProperty(exports, "MAX_FIELD_SIZE_BYTES", { enumerable: true, get: function () { return tokenizer_1.MAX_FIELD_SIZE_BYTES; } });
+Object.defineProperty(exports, "MAX_PATH_DEPTH", { enumerable: true, get: function () { return tokenizer_1.MAX_PATH_DEPTH; } });
+Object.defineProperty(exports, "MAX_IDENTIFIER_LENGTH", { enumerable: true, get: function () { return tokenizer_1.MAX_IDENTIFIER_LENGTH; } });
+var evaluator_1 = require("./evaluator");
+Object.defineProperty(exports, "resolve", { enumerable: true, get: function () { return evaluator_1.resolve; } });
+Object.defineProperty(exports, "lookupPath", { enumerable: true, get: function () { return evaluator_1.lookupPath; } });
+Object.defineProperty(exports, "dependencies", { enumerable: true, get: function () { return evaluator_1.dependencies; } });
+var walker_1 = require("./walker");
+Object.defineProperty(exports, "walkAndBind", { enumerable: true, get: function () { return walker_1.walkAndBind; } });
+var topo_sort_1 = require("./topo-sort");
+Object.defineProperty(exports, "topoSort", { enumerable: true, get: function () { return topo_sort_1.topoSort; } });
+var cache_1 = require("./cache");
+Object.defineProperty(exports, "TokenCache", { enumerable: true, get: function () { return cache_1.TokenCache; } });
+Object.defineProperty(exports, "defaultTokenCache", { enumerable: true, get: function () { return cache_1.defaultTokenCache; } });
+var validate_1 = require("./validate");
+Object.defineProperty(exports, "validateTemplates", { enumerable: true, get: function () { return validate_1.validateTemplates; } });
+Object.defineProperty(exports, "detectCycles", { enumerable: true, get: function () { return validate_1.detectCycles; } });
+Object.defineProperty(exports, "allowedScopeRoots", { enumerable: true, get: function () { return validate_1.allowedScopeRoots; } });
+var metrics_1 = require("./metrics");
+Object.defineProperty(exports, "recordResolution", { enumerable: true, get: function () { return metrics_1.recordResolution; } });
+Object.defineProperty(exports, "templateResolutionsTotal", { enumerable: true, get: function () { return metrics_1.templateResolutionsTotal; } });
+Object.defineProperty(exports, "templateResolutionDurationMs", { enumerable: true, get: function () { return metrics_1.templateResolutionDurationMs; } });
+// -- Convenience: high-level resolve() that walks + resolves + measures
+const api_core_1 = require("@pipeline-builder/api-core");
+const evaluator_2 = require("./evaluator");
+const metrics_2 = require("./metrics");
+const tokenizer_2 = require("./tokenizer");
+const topo_sort_2 = require("./topo-sort");
+const walker_2 = require("./walker");
+/**
+ * Resolve all templates inside `doc` by mutating string fields in place.
+ * `doc` is treated as opaque — only string fields that match `isTemplatable`
+ * are rewritten. Returns collected errors (empty array on success).
+ *
+ * `docType` is used for metrics; pass 'pipeline' or 'plugin'.
+ */
+function resolveTemplates(doc, scope, isTemplatable, docType = 'plugin') {
+    const start = Date.now();
+    const errors = [];
+    const entries = (0, walker_2.walkAndBind)(doc, isTemplatable);
+    let success = true;
+    for (const entry of entries) {
+        try {
+            const value = (0, evaluator_2.resolve)(entry.tokens, scope, entry.field);
+            entry.set(value);
+        }
+        catch (err) {
+            success = false;
+            const e = err;
+            errors.push({
+                code: e.code ?? api_core_1.ErrorCode.TEMPLATE_PARSE_ERROR,
+                message: e.message,
+                field: entry.field,
+                path: e.path,
+            });
+        }
+    }
+    (0, metrics_2.recordResolution)(docType, Date.now() - start, success);
+    return { errors };
+}
+/**
+ * Resolve a self-referencing document (e.g. pipeline.json where
+ * metadata fields reference each other). Topologically orders the
+ * resolution so dependencies come first. Mutates `doc` in place.
+ *
+ * `fieldToScopePath` maps each field (e.g. `metadata.env`) to the scope
+ * path it populates (typically the same, sans any array indices).
+ */
+function resolveSelfReferencing(doc, scope, isTemplatable, fieldToScopePath, docType = 'pipeline') {
+    const start = Date.now();
+    const entries = (0, walker_2.walkAndBind)(doc, isTemplatable);
+    // Build topo nodes keyed by target scope path
+    const nodes = entries
+        .map(e => {
+        const key = fieldToScopePath(e.field);
+        if (!key)
+            return null;
+        const deps = [];
+        for (const t of e.tokens)
+            if (t.kind === 'expr')
+                deps.push(t.path.join('.'));
+        return { key, deps, entry: e };
+    })
+        .filter((n) => n !== null);
+    const { ordered, cycles } = (0, topo_sort_2.topoSort)(nodes.map(n => ({ key: n.key, deps: n.deps })));
+    const errors = [];
+    if (cycles.length) {
+        for (const c of cycles) {
+            errors.push({
+                code: api_core_1.ErrorCode.TEMPLATE_CYCLE,
+                message: `Template cycle detected: ${c.join(' -> ')}`,
+                path: c.join(' -> '),
+            });
+        }
+        (0, metrics_2.recordResolution)(docType, Date.now() - start, false);
+        return { errors };
+    }
+    // Resolve in topo order; multiple entries may share a scope key (e.g. one
+    // pipeline field could map to the same scope path — unlikely here), so
+    // iterate all entries whose key == ordered[i].
+    const byKey = new Map();
+    for (const n of nodes) {
+        const list = byKey.get(n.key) ?? [];
+        list.push(n);
+        byKey.set(n.key, list);
+    }
+    let success = true;
+    for (const key of ordered) {
+        for (const n of byKey.get(key) ?? []) {
+            try {
+                const value = (0, evaluator_2.resolve)(n.entry.tokens, scope, n.entry.field);
+                n.entry.set(value);
+            }
+            catch (err) {
+                success = false;
+                const e = err;
+                errors.push({
+                    code: e.code ?? api_core_1.ErrorCode.TEMPLATE_PARSE_ERROR,
+                    message: e.message,
+                    field: n.entry.field,
+                    path: e.path,
+                });
+            }
+        }
+    }
+    (0, metrics_2.recordResolution)(docType, Date.now() - start, success);
+    return { errors };
+}
+/**
+ * Inline round-trip helper — parses and resolves a single string against
+ * a scope. Returns a string unless a whole-field coercion filter was
+ * used (in which case the native type from `| number`, `| bool`, or
+ * `| json` is returned).
+ */
+function resolveString(source, scope) {
+    if (!(0, tokenizer_2.hasTemplate)(source))
+        return source;
+    const tokens = (0, tokenizer_2.tokenize)(source);
+    return (0, evaluator_2.resolve)(tokens, scope);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/template/index.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nexport {\n  tokenize,\n  hasTemplate,\n  TokenizerError,\n  MAX_FIELD_SIZE_BYTES,\n  MAX_PATH_DEPTH,\n  MAX_IDENTIFIER_LENGTH,\n  type Token,\n  type LiteralToken,\n  type ExprToken,\n  type SourcePosition,\n} from './tokenizer';\n\nexport {\n  resolve,\n  lookupPath,\n  dependencies,\n  type Scope,\n  type EvalError,\n} from './evaluator';\n\nexport {\n  walkAndBind,\n  type WalkEntry,\n  type FieldPredicate,\n} from './walker';\n\nexport {\n  topoSort,\n  type TopoNode,\n  type TopoResult,\n} from './topo-sort';\n\nexport {\n  TokenCache,\n  defaultTokenCache,\n} from './cache';\n\nexport {\n  validateTemplates,\n  detectCycles,\n  allowedScopeRoots,\n  type TemplateError,\n  type ValidationResult,\n} from './validate';\n\nexport {\n  recordResolution,\n  templateResolutionsTotal,\n  templateResolutionDurationMs,\n} from './metrics';\n\n// -- Convenience: high-level resolve() that walks + resolves + measures\n\nimport { ErrorCode } from '@pipeline-builder/api-core';\nimport { resolve as evaluatorResolve, type Scope } from './evaluator';\nimport { recordResolution } from './metrics';\nimport { hasTemplate, tokenize, Token } from './tokenizer';\nimport { topoSort } from './topo-sort';\nimport { walkAndBind, type FieldPredicate } from './walker';\n\nexport interface ResolveResult {\n  errors: Array<{ code: ErrorCode; message: string; field?: string; path?: string }>;\n}\n\n/**\n * Resolve all templates inside `doc` by mutating string fields in place.\n * `doc` is treated as opaque — only string fields that match `isTemplatable`\n * are rewritten. Returns collected errors (empty array on success).\n *\n * `docType` is used for metrics; pass 'pipeline' or 'plugin'.\n */\nexport function resolveTemplates<T extends object>(\n  doc: T,\n  scope: Scope,\n  isTemplatable: FieldPredicate,\n  docType: 'pipeline' | 'plugin' = 'plugin',\n): ResolveResult {\n  const start = Date.now();\n  const errors: ResolveResult['errors'] = [];\n  const entries = walkAndBind(doc, isTemplatable);\n  let success = true;\n  for (const entry of entries) {\n    try {\n      const value = evaluatorResolve(entry.tokens, scope, entry.field);\n      entry.set(value);\n    } catch (err) {\n      success = false;\n      const e = err as Error & { code?: ErrorCode; path?: string };\n      errors.push({\n        code: e.code ?? ErrorCode.TEMPLATE_PARSE_ERROR,\n        message: e.message,\n        field: entry.field,\n        path: e.path,\n      });\n    }\n  }\n  recordResolution(docType, Date.now() - start, success);\n  return { errors };\n}\n\n/**\n * Resolve a self-referencing document (e.g. pipeline.json where\n * metadata fields reference each other). Topologically orders the\n * resolution so dependencies come first. Mutates `doc` in place.\n *\n * `fieldToScopePath` maps each field (e.g. `metadata.env`) to the scope\n * path it populates (typically the same, sans any array indices).\n */\nexport function resolveSelfReferencing<T extends object>(\n  doc: T,\n  scope: Scope,\n  isTemplatable: FieldPredicate,\n  fieldToScopePath: (field: string) => string | null,\n  docType: 'pipeline' | 'plugin' = 'pipeline',\n): ResolveResult {\n  const start = Date.now();\n  const entries = walkAndBind(doc, isTemplatable);\n  // Build topo nodes keyed by target scope path\n  const nodes = entries\n    .map(e => {\n      const key = fieldToScopePath(e.field);\n      if (!key) return null;\n      const deps: string[] = [];\n      for (const t of e.tokens) if (t.kind === 'expr') deps.push(t.path.join('.'));\n      return { key, deps, entry: e };\n    })\n    .filter((n): n is NonNullable<typeof n> => n !== null);\n\n  const { ordered, cycles } = topoSort(nodes.map(n => ({ key: n.key, deps: n.deps })));\n  const errors: ResolveResult['errors'] = [];\n  if (cycles.length) {\n    for (const c of cycles) {\n      errors.push({\n        code: ErrorCode.TEMPLATE_CYCLE,\n        message: `Template cycle detected: ${c.join(' -> ')}`,\n        path: c.join(' -> '),\n      });\n    }\n    recordResolution(docType, Date.now() - start, false);\n    return { errors };\n  }\n\n  // Resolve in topo order; multiple entries may share a scope key (e.g. one\n  // pipeline field could map to the same scope path — unlikely here), so\n  // iterate all entries whose key == ordered[i].\n  const byKey = new Map<string, typeof nodes>();\n  for (const n of nodes) {\n    const list = byKey.get(n.key) ?? [];\n    list.push(n);\n    byKey.set(n.key, list);\n  }\n\n  let success = true;\n  for (const key of ordered) {\n    for (const n of byKey.get(key) ?? []) {\n      try {\n        const value = evaluatorResolve(n.entry.tokens, scope, n.entry.field);\n        n.entry.set(value);\n      } catch (err) {\n        success = false;\n        const e = err as Error & { code?: ErrorCode; path?: string };\n        errors.push({\n          code: e.code ?? ErrorCode.TEMPLATE_PARSE_ERROR,\n          message: e.message,\n          field: n.entry.field,\n          path: e.path,\n        });\n      }\n    }\n  }\n  recordResolution(docType, Date.now() - start, success);\n  return { errors };\n}\n\n/**\n * Inline round-trip helper — parses and resolves a single string against\n * a scope. Returns a string unless a whole-field coercion filter was\n * used (in which case the native type from `| number`, `| bool`, or\n * `| json` is returned).\n */\nexport function resolveString(\n  source: string,\n  scope: Scope,\n): string | number | boolean | null | unknown[] | Record<string, unknown> {\n  if (!hasTemplate(source)) return source;\n  const tokens: Token[] = tokenize(source);\n  return evaluatorResolve(tokens, scope);\n}\n"]}

package/lib/template/metrics.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Prometheus metrics for template resolution. Optional — the module is
+ * only wired up when `prom-client` is already present in the host
+ * process (as is the case for api-server based services). Falls back to
+ * no-op stubs when unavailable so pipeline-core stays usable outside
+ * server contexts.
+ */
+interface Counter {
+    inc(labels?: Record<string, string>, value?: number): void;
+}
+interface Histogram {
+    observe(labels: Record<string, string>, value: number): void;
+}
+export declare const templateResolutionsTotal: Counter;
+export declare const templateResolutionDurationMs: Histogram;
+export declare function recordResolution(doc: 'pipeline' | 'plugin', durationMs: number, success: boolean): void;
+export {};