@pipeline-builder/pipeline-core 4.1.22 → 4.1.23

package/lib/index.d.ts

@@ -32,7 +32,7 @@ export * from './config/app-config.js';
 export * from './config/config-types.js';
 export * from './config/service-client.js';
 export { parsePlatformBaseUrl } from './config/infrastructure-config.js';
-export { ComputeType, PluginType, type MetaDataType, type Visibility, TriggerType, MetadataKeys, type MetadataKey, CDK_METADATA_PREFIX } from './core/pipeline-types.js';
+export { ComputeType, PluginType, type MetaDataType, type Visibility, TriggerType, MetadataKeys, type MetadataKey } from './core/pipeline-types.js';
 export * from './core/role-types.js';
 export * from './core/security-group-types.js';
 export { replaceNonAlphanumeric, extractMetadataEnv, resolveFailureBehavior, wrapCommandsForFailureBehavior, STEP_BOOTSTRAP_CMD } from './core/metadata-helpers.js';
@@ -40,5 +40,5 @@ export * from './core/step-manifest.js';
 export { type ContractValueType, type PluginContract, type ContractScope, type ContractIssue, type ContractScopeProps, pipelineScopeMetadata, pipelineContractScope, contractScopeFromTemplateScope, isContractValueOfType, checkPluginContract, type PluginStepRef, collectPluginSteps, pluginLookupFilter, pluginArtifactAlias, type PluginRefIdentity, sanitizePublisher, } from './core/plugin-contract.js';
 export { unwrapLookup } from './core/plugin-lookup-envelope.js';
 export * from './pipeline/plugin-spec.js';
-export { tokenize, hasTemplate, MAX_FIELD_SIZE_BYTES, MAX_PATH_DEPTH, type Token, type LiteralToken, type ExprToken, type SourcePosition, resolve, dependencies, type Scope, type EvalError, type WalkEntry, type FieldPredicate, type TopoNode, type TopoResult, validateTemplates, detectCycles, allowedScopeRoots, type TemplateError, type TemplateValidationResult, type ResolveResult, resolveSelfReferencing, } from './template/index.js';
-export { resolvePluginTemplates, isPluginTemplatableField } from './template/plugin-resolver.js';
+export { tokenize, hasTemplate, MAX_FIELD_SIZE_BYTES, MAX_PATH_DEPTH, type Token, type LiteralToken, type ExprToken, type SourcePosition, resolve, dependencies, type Scope, type FieldPredicate, validateTemplates, detectCycles, allowedScopeRoots, type TemplateError, type TemplateValidationResult, type ResolveResult, resolveSelfReferencing, validateTemplateDraft, formatTemplateDraftProblems, type TemplateDraftInput, type TemplateDraftLike, type TemplateDraftProblem, type TemplateDraftProblemKind, type TemplateDraftValidation, } from './template/index.js';
+export { resolvePluginTemplates } from './template/plugin-resolver.js';

package/lib/index.js

@@ -36,7 +36,7 @@ export * from './config/config-types.js';
 export * from './config/service-client.js';
 export { parsePlatformBaseUrl } from './config/infrastructure-config.js';
 // Core types (public surface)
-export { ComputeType, PluginType, TriggerType, MetadataKeys, CDK_METADATA_PREFIX } from './core/pipeline-types.js';
+export { ComputeType, PluginType, TriggerType, MetadataKeys } from './core/pipeline-types.js';
 export * from './core/role-types.js';
 export * from './core/security-group-types.js';
 export { replaceNonAlphanumeric, extractMetadataEnv, resolveFailureBehavior, wrapCommandsForFailureBehavior, STEP_BOOTSTRAP_CMD } from './core/metadata-helpers.js';
@@ -46,7 +46,7 @@ export { unwrapLookup } from './core/plugin-lookup-envelope.js';
 // Plugin domain type (the synth-time authoring types live in the `/cdk` entry)
 export * from './pipeline/plugin-spec.js';
 // Template engine — synth-time scripting for pipeline config + plugin specs
-export { tokenize, hasTemplate, MAX_FIELD_SIZE_BYTES, MAX_PATH_DEPTH, resolve, dependencies, validateTemplates, detectCycles, allowedScopeRoots, resolveSelfReferencing, } from './template/index.js';
+export { tokenize, hasTemplate, MAX_FIELD_SIZE_BYTES, MAX_PATH_DEPTH, resolve, dependencies, validateTemplates, detectCycles, allowedScopeRoots, resolveSelfReferencing, validateTemplateDraft, formatTemplateDraftProblems, } from './template/index.js';
 // A plugin's `{{ … }}` resolution against a pipeline scope (synth, `plugin test`)
-export { resolvePluginTemplates, isPluginTemplatableField } from './template/plugin-resolver.js';
-//# sourceMappingURL=data:application/json;base64,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
+export { resolvePluginTemplates } from './template/plugin-resolver.js';
+//# sourceMappingURL=data:application/json;base64,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

package/lib/template/draft.d.ts

@@ -0,0 +1,47 @@
+/** What went wrong. See the module header for what each kind means. */
+export type TemplateDraftProblemKind = 'invalid-props' | 'parse' | 'reserved-scope' | 'unknown-scope' | 'cycle' | 'undeclared-variable' | 'duplicate-input' | 'invalid-input-name' | 'unused-input';
+/** One problem found in a drafted template. */
+export interface TemplateDraftProblem {
+    readonly kind: TemplateDraftProblemKind;
+    /** `error` blocks the draft; `warning` is worth saying but not fatal. */
+    readonly severity: 'error' | 'warning';
+    readonly message: string;
+    /** Dotted path of the offending field inside `props`, when there is one. */
+    readonly field?: string;
+    readonly line?: number;
+    readonly col?: number;
+    /** The `{{ path }}` that caused it. */
+    readonly path?: string;
+    /** For `cycle`: the scope keys forming the loop. */
+    readonly cycle?: readonly string[];
+    /** For the variable/input kinds: the `vars.<name>` involved. */
+    readonly variable?: string;
+}
+/** One declared input, read defensively — a draft's `inputs` is untrusted. */
+export interface TemplateDraftInput {
+    readonly name?: unknown;
+}
+/** The part of a drafted template this validator reads. */
+export interface TemplateDraftLike {
+    /** The template body: a BuilderProps carrying `{{ vars.* }}` placeholders. */
+    readonly props?: unknown;
+    /** The declared `vars.*` contract. */
+    readonly inputs?: readonly TemplateDraftInput[] | null;
+}
+/** The verdict on a drafted template. */
+export interface TemplateDraftValidation {
+    /** True when no problem has `severity: 'error'`. */
+    readonly valid: boolean;
+    readonly problems: readonly TemplateDraftProblem[];
+    /** Every `vars.<name>` the body references, sorted. */
+    readonly referencedVariables: readonly string[];
+    /** Every well-formed `inputs[].name`, in declaration order. */
+    readonly declaredInputs: readonly string[];
+}
+/**
+ * Validate a drafted pipeline template. Never throws: a malformed draft comes
+ * back as problems, because the caller's job is to report them, not to crash.
+ */
+export declare function validateTemplateDraft(draft: TemplateDraftLike): TemplateDraftValidation;
+/** One readable line per problem, for a tool result or an error body. */
+export declare function formatTemplateDraftProblems(problems: readonly TemplateDraftProblem[]): string[];

package/lib/template/draft.js

@@ -0,0 +1,213 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Service-side validation of a DRAFTED pipeline template — the one entry point
+ * a caller needs to ask "would this template survive being created and then
+ * instantiated?" before it is offered to anyone.
+ *
+ * It exists because a drafted template (the ask agent's `propose_template`, a
+ * CLI-authored file, an import) is otherwise checked only against a shape
+ * schema. A shape schema cannot see that `{{ vars.REGION }}` is referenced but
+ * never declared in `inputs`, or that two metadata values reference each other
+ * in a cycle: both are accepted at create time and only fail later, at synth,
+ * far from whoever wrote them.
+ *
+ * What it reports:
+ *  - `parse`                — malformed `{{ … }}` anywhere in the body, at its line/col.
+ *  - `reserved-scope`       — `{{ secrets.* }}`, which the engine reserves.
+ *  - `unknown-scope`        — a self-referencing field pointing at a root that is
+ *                             neither `metadata` nor `vars`; the pipeline create
+ *                             path rejects exactly these.
+ *  - `cycle`                — self-references that cannot be ordered.
+ *  - `undeclared-variable`  — `{{ vars.X }}` with no matching `inputs[].name` and
+ *                             no default in `props.vars`, so instantiation can
+ *                             never supply it.
+ *  - `duplicate-input` / `invalid-input-name` — an input that cannot be filled:
+ *                             a repeated name, or one the grammar cannot express
+ *                             as `{{ vars.<name> }}`.
+ *  - `unused-input`         — declared but never referenced. A WARNING: the
+ *                             template still works, it just asks for something
+ *                             it ignores.
+ *
+ * Errors mean "do not offer this"; warnings mean "say so and let the author
+ * decide". `valid` reflects errors only.
+ */
+import { TokenizerError, tokenize } from './tokenizer.js';
+import { detectCycles } from './validate.js';
+import { visitStrings } from './walker.js';
+/** The template grammar's identifier rule (tokenizer.ts): `[a-zA-Z_][a-zA-Z0-9_]{0,63}`. */
+const IDENTIFIER = /^[a-zA-Z_][a-zA-Z0-9_]{0,63}$/;
+/** The roots a self-referencing pipeline field may address (same set the pipeline create path allows). */
+const SELF_SCOPE_ROOTS = ['metadata', 'vars'];
+/** The metadata layers synth merges, in the order it merges them. */
+const METADATA_PREFIXES = ['global.', 'defaults.metadata.', 'synth.metadata.'];
+/** The first path segment of `rest` — `A.B` and `A[0]` both yield `A`. */
+function firstSegment(rest) {
+    const match = /^[^.[]+/.exec(rest);
+    return match ? match[0] : rest;
+}
+/**
+ * The scope key a templatable field WRITES, or null when the field is not
+ * self-referencing. `global.env`, `defaults.metadata.env` and
+ * `synth.metadata.env` all write `metadata.env` — that is how synth layers
+ * them — so a cycle through any layer is found.
+ */
+function selfScopeKey(field) {
+    if (field === 'project')
+        return 'project';
+    for (const prefix of METADATA_PREFIXES) {
+        if (field.startsWith(prefix))
+            return `metadata.${firstSegment(field.slice(prefix.length))}`;
+    }
+    if (field.startsWith('vars.'))
+        return `vars.${firstSegment(field.slice('vars.'.length))}`;
+    return null;
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+/**
+ * Validate a drafted pipeline template. Never throws: a malformed draft comes
+ * back as problems, because the caller's job is to report them, not to crash.
+ */
+export function validateTemplateDraft(draft) {
+    const problems = [];
+    const referenced = new Set();
+    if (!isRecord(draft.props)) {
+        return {
+            valid: false,
+            problems: [{ kind: 'invalid-props', severity: 'error', message: 'Template body (props) must be an object' }],
+            referencedVariables: [],
+            declaredInputs: [],
+        };
+    }
+    const props = draft.props;
+    // -- Pass 1: every string in the body, so a malformed `{{` is caught wherever
+    //    it is — not only in the fields the pipeline create path happens to check.
+    let parseFailed = false;
+    visitStrings(props, () => true, (field, source) => {
+        let tokens;
+        try {
+            tokens = tokenize(source);
+        }
+        catch (err) {
+            parseFailed = true;
+            const pos = err instanceof TokenizerError ? err.pos : undefined;
+            problems.push({
+                kind: 'parse',
+                severity: 'error',
+                message: err instanceof Error ? err.message : String(err),
+                field,
+                ...(pos && { line: pos.line, col: pos.col }),
+            });
+            return;
+        }
+        const selfReferencing = selfScopeKey(field) !== null;
+        for (const token of tokens) {
+            if (token.kind !== 'expr')
+                continue;
+            const root = token.path[0];
+            const path = token.path.join('.');
+            if (root === 'secrets') {
+                problems.push({
+                    kind: 'reserved-scope',
+                    severity: 'error',
+                    message: '\'secrets\' is a reserved scope — a template body must not reference it',
+                    field,
+                    path,
+                    line: token.pos.line,
+                    col: token.pos.col,
+                });
+                continue;
+            }
+            if (root === 'vars' && token.path.length > 1)
+                referenced.add(token.path[1]);
+            if (selfReferencing && !SELF_SCOPE_ROOTS.includes(root)) {
+                problems.push({
+                    kind: 'unknown-scope',
+                    severity: 'error',
+                    message: `Template references unknown scope root '${root}' (a pipeline field may reference ${SELF_SCOPE_ROOTS.join(' or ')} only)`,
+                    field,
+                    path,
+                    line: token.pos.line,
+                    col: token.pos.col,
+                });
+            }
+        }
+    });
+    // -- Pass 2: cycles among the self-referencing fields. Skipped when anything
+    //    failed to parse — the cycle walker tokenizes eagerly and would throw on
+    //    the same bad field that pass 1 already reported.
+    if (!parseFailed) {
+        for (const err of detectCycles(props, (field) => selfScopeKey(field) !== null, selfScopeKey)) {
+            problems.push({
+                kind: 'cycle',
+                severity: 'error',
+                message: err.message,
+                field: err.field,
+                ...(err.cycle && { cycle: err.cycle }),
+            });
+        }
+    }
+    // -- Pass 3: the declared inputs. An input the grammar cannot express, or one
+    //    declared twice, can never be filled in — both are errors, not warnings.
+    const declared = [];
+    const seen = new Set();
+    for (const input of draft.inputs ?? []) {
+        const name = input?.name;
+        if (typeof name !== 'string' || !IDENTIFIER.test(name)) {
+            problems.push({
+                kind: 'invalid-input-name',
+                severity: 'error',
+                message: `Declared input ${JSON.stringify(name)} is not a usable variable name (${IDENTIFIER.source})`,
+                ...(typeof name === 'string' && { variable: name }),
+            });
+            continue;
+        }
+        if (seen.has(name)) {
+            problems.push({ kind: 'duplicate-input', severity: 'error', message: `Declared input '${name}' appears more than once`, variable: name });
+            continue;
+        }
+        seen.add(name);
+        declared.push(name);
+    }
+    // -- Pass 4: the contract between body and inputs. A var the body references
+    //    is supplied either by a declared input or by a default already sitting in
+    //    `props.vars`; anything else has no way of ever getting a value.
+    const defaulted = isRecord(props.vars) ? Object.keys(props.vars) : [];
+    const supplied = new Set([...declared, ...defaulted]);
+    for (const variable of [...referenced].sort()) {
+        if (supplied.has(variable))
+            continue;
+        problems.push({
+            kind: 'undeclared-variable',
+            severity: 'error',
+            message: `Template references {{ vars.${variable} }} but declares no input named '${variable}'`,
+            variable,
+        });
+    }
+    for (const name of declared) {
+        if (referenced.has(name))
+            continue;
+        problems.push({
+            kind: 'unused-input',
+            severity: 'warning',
+            message: `Declared input '${name}' is never referenced as {{ vars.${name} }}`,
+            variable: name,
+        });
+    }
+    return {
+        valid: !problems.some((p) => p.severity === 'error'),
+        problems,
+        referencedVariables: [...referenced].sort(),
+        declaredInputs: declared,
+    };
+}
+/** One readable line per problem, for a tool result or an error body. */
+export function formatTemplateDraftProblems(problems) {
+    return problems.map((p) => {
+        const where = p.field ? `${p.field}${p.line !== undefined ? `:${p.line}:${p.col}` : ''}` : p.kind;
+        return `[${where}] ${p.message}`;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"draft.js","sourceRoot":"","sources":["../../src/template/draft.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Service-side validation of a DRAFTED pipeline template — the one entry point\n * a caller needs to ask \"would this template survive being created and then\n * instantiated?\" before it is offered to anyone.\n *\n * It exists because a drafted template (the ask agent's `propose_template`, a\n * CLI-authored file, an import) is otherwise checked only against a shape\n * schema. A shape schema cannot see that `{{ vars.REGION }}` is referenced but\n * never declared in `inputs`, or that two metadata values reference each other\n * in a cycle: both are accepted at create time and only fail later, at synth,\n * far from whoever wrote them.\n *\n * What it reports:\n *  - `parse`                — malformed `{{ … }}` anywhere in the body, at its line/col.\n *  - `reserved-scope`       — `{{ secrets.* }}`, which the engine reserves.\n *  - `unknown-scope`        — a self-referencing field pointing at a root that is\n *                             neither `metadata` nor `vars`; the pipeline create\n *                             path rejects exactly these.\n *  - `cycle`                — self-references that cannot be ordered.\n *  - `undeclared-variable`  — `{{ vars.X }}` with no matching `inputs[].name` and\n *                             no default in `props.vars`, so instantiation can\n *                             never supply it.\n *  - `duplicate-input` / `invalid-input-name` — an input that cannot be filled:\n *                             a repeated name, or one the grammar cannot express\n *                             as `{{ vars.<name> }}`.\n *  - `unused-input`         — declared but never referenced. A WARNING: the\n *                             template still works, it just asks for something\n *                             it ignores.\n *\n * Errors mean \"do not offer this\"; warnings mean \"say so and let the author\n * decide\". `valid` reflects errors only.\n */\n\nimport { TokenizerError, tokenize } from './tokenizer.js';\nimport { detectCycles } from './validate.js';\nimport { visitStrings } from './walker.js';\n\n/** What went wrong. See the module header for what each kind means. */\nexport type TemplateDraftProblemKind =\n  | 'invalid-props'\n  | 'parse'\n  | 'reserved-scope'\n  | 'unknown-scope'\n  | 'cycle'\n  | 'undeclared-variable'\n  | 'duplicate-input'\n  | 'invalid-input-name'\n  | 'unused-input';\n\n/** One problem found in a drafted template. */\nexport interface TemplateDraftProblem {\n  readonly kind: TemplateDraftProblemKind;\n  /** `error` blocks the draft; `warning` is worth saying but not fatal. */\n  readonly severity: 'error' | 'warning';\n  readonly message: string;\n  /** Dotted path of the offending field inside `props`, when there is one. */\n  readonly field?: string;\n  readonly line?: number;\n  readonly col?: number;\n  /** The `{{ path }}` that caused it. */\n  readonly path?: string;\n  /** For `cycle`: the scope keys forming the loop. */\n  readonly cycle?: readonly string[];\n  /** For the variable/input kinds: the `vars.<name>` involved. */\n  readonly variable?: string;\n}\n\n/** One declared input, read defensively — a draft's `inputs` is untrusted. */\nexport interface TemplateDraftInput {\n  readonly name?: unknown;\n}\n\n/** The part of a drafted template this validator reads. */\nexport interface TemplateDraftLike {\n  /** The template body: a BuilderProps carrying `{{ vars.* }}` placeholders. */\n  readonly props?: unknown;\n  /** The declared `vars.*` contract. */\n  readonly inputs?: readonly TemplateDraftInput[] | null;\n}\n\n/** The verdict on a drafted template. */\nexport interface TemplateDraftValidation {\n  /** True when no problem has `severity: 'error'`. */\n  readonly valid: boolean;\n  readonly problems: readonly TemplateDraftProblem[];\n  /** Every `vars.<name>` the body references, sorted. */\n  readonly referencedVariables: readonly string[];\n  /** Every well-formed `inputs[].name`, in declaration order. */\n  readonly declaredInputs: readonly string[];\n}\n\n/** The template grammar's identifier rule (tokenizer.ts): `[a-zA-Z_][a-zA-Z0-9_]{0,63}`. */\nconst IDENTIFIER = /^[a-zA-Z_][a-zA-Z0-9_]{0,63}$/;\n\n/** The roots a self-referencing pipeline field may address (same set the pipeline create path allows). */\nconst SELF_SCOPE_ROOTS = ['metadata', 'vars'];\n\n/** The metadata layers synth merges, in the order it merges them. */\nconst METADATA_PREFIXES = ['global.', 'defaults.metadata.', 'synth.metadata.'];\n\n/** The first path segment of `rest` — `A.B` and `A[0]` both yield `A`. */\nfunction firstSegment(rest: string): string {\n  const match = /^[^.[]+/.exec(rest);\n  return match ? match[0] : rest;\n}\n\n/**\n * The scope key a templatable field WRITES, or null when the field is not\n * self-referencing. `global.env`, `defaults.metadata.env` and\n * `synth.metadata.env` all write `metadata.env` — that is how synth layers\n * them — so a cycle through any layer is found.\n */\nfunction selfScopeKey(field: string): string | null {\n  if (field === 'project') return 'project';\n  for (const prefix of METADATA_PREFIXES) {\n    if (field.startsWith(prefix)) return `metadata.${firstSegment(field.slice(prefix.length))}`;\n  }\n  if (field.startsWith('vars.')) return `vars.${firstSegment(field.slice('vars.'.length))}`;\n  return null;\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return !!value && typeof value === 'object' && !Array.isArray(value);\n}\n\n/**\n * Validate a drafted pipeline template. Never throws: a malformed draft comes\n * back as problems, because the caller's job is to report them, not to crash.\n */\nexport function validateTemplateDraft(draft: TemplateDraftLike): TemplateDraftValidation {\n  const problems: TemplateDraftProblem[] = [];\n  const referenced = new Set<string>();\n\n  if (!isRecord(draft.props)) {\n    return {\n      valid: false,\n      problems: [{ kind: 'invalid-props', severity: 'error', message: 'Template body (props) must be an object' }],\n      referencedVariables: [],\n      declaredInputs: [],\n    };\n  }\n  const props = draft.props;\n\n  // -- Pass 1: every string in the body, so a malformed `{{` is caught wherever\n  //    it is — not only in the fields the pipeline create path happens to check.\n  let parseFailed = false;\n  visitStrings(props, () => true, (field, source) => {\n    let tokens;\n    try {\n      tokens = tokenize(source);\n    } catch (err) {\n      parseFailed = true;\n      const pos = err instanceof TokenizerError ? err.pos : undefined;\n      problems.push({\n        kind: 'parse',\n        severity: 'error',\n        message: err instanceof Error ? err.message : String(err),\n        field,\n        ...(pos && { line: pos.line, col: pos.col }),\n      });\n      return;\n    }\n    const selfReferencing = selfScopeKey(field) !== null;\n    for (const token of tokens) {\n      if (token.kind !== 'expr') continue;\n      const root = token.path[0]!;\n      const path = token.path.join('.');\n      if (root === 'secrets') {\n        problems.push({\n          kind: 'reserved-scope',\n          severity: 'error',\n          message: '\\'secrets\\' is a reserved scope — a template body must not reference it',\n          field,\n          path,\n          line: token.pos.line,\n          col: token.pos.col,\n        });\n        continue;\n      }\n      if (root === 'vars' && token.path.length > 1) referenced.add(token.path[1]!);\n      if (selfReferencing && !SELF_SCOPE_ROOTS.includes(root)) {\n        problems.push({\n          kind: 'unknown-scope',\n          severity: 'error',\n          message: `Template references unknown scope root '${root}' (a pipeline field may reference ${SELF_SCOPE_ROOTS.join(' or ')} only)`,\n          field,\n          path,\n          line: token.pos.line,\n          col: token.pos.col,\n        });\n      }\n    }\n  });\n\n  // -- Pass 2: cycles among the self-referencing fields. Skipped when anything\n  //    failed to parse — the cycle walker tokenizes eagerly and would throw on\n  //    the same bad field that pass 1 already reported.\n  if (!parseFailed) {\n    for (const err of detectCycles(props, (field) => selfScopeKey(field) !== null, selfScopeKey)) {\n      problems.push({\n        kind: 'cycle',\n        severity: 'error',\n        message: err.message,\n        field: err.field,\n        ...(err.cycle && { cycle: err.cycle }),\n      });\n    }\n  }\n\n  // -- Pass 3: the declared inputs. An input the grammar cannot express, or one\n  //    declared twice, can never be filled in — both are errors, not warnings.\n  const declared: string[] = [];\n  const seen = new Set<string>();\n  for (const input of draft.inputs ?? []) {\n    const name = input?.name;\n    if (typeof name !== 'string' || !IDENTIFIER.test(name)) {\n      problems.push({\n        kind: 'invalid-input-name',\n        severity: 'error',\n        message: `Declared input ${JSON.stringify(name)} is not a usable variable name (${IDENTIFIER.source})`,\n        ...(typeof name === 'string' && { variable: name }),\n      });\n      continue;\n    }\n    if (seen.has(name)) {\n      problems.push({ kind: 'duplicate-input', severity: 'error', message: `Declared input '${name}' appears more than once`, variable: name });\n      continue;\n    }\n    seen.add(name);\n    declared.push(name);\n  }\n\n  // -- Pass 4: the contract between body and inputs. A var the body references\n  //    is supplied either by a declared input or by a default already sitting in\n  //    `props.vars`; anything else has no way of ever getting a value.\n  const defaulted = isRecord(props.vars) ? Object.keys(props.vars) : [];\n  const supplied = new Set([...declared, ...defaulted]);\n  for (const variable of [...referenced].sort()) {\n    if (supplied.has(variable)) continue;\n    problems.push({\n      kind: 'undeclared-variable',\n      severity: 'error',\n      message: `Template references {{ vars.${variable} }} but declares no input named '${variable}'`,\n      variable,\n    });\n  }\n  for (const name of declared) {\n    if (referenced.has(name)) continue;\n    problems.push({\n      kind: 'unused-input',\n      severity: 'warning',\n      message: `Declared input '${name}' is never referenced as {{ vars.${name} }}`,\n      variable: name,\n    });\n  }\n\n  return {\n    valid: !problems.some((p) => p.severity === 'error'),\n    problems,\n    referencedVariables: [...referenced].sort(),\n    declaredInputs: declared,\n  };\n}\n\n/** One readable line per problem, for a tool result or an error body. */\nexport function formatTemplateDraftProblems(problems: readonly TemplateDraftProblem[]): string[] {\n  return problems.map((p) => {\n    const where = p.field ? `${p.field}${p.line !== undefined ? `:${p.line}:${p.col}` : ''}` : p.kind;\n    return `[${where}] ${p.message}`;\n  });\n}\n"]}

package/lib/template/index.d.ts

@@ -1,8 +1,8 @@
 export { tokenize, hasTemplate, MAX_FIELD_SIZE_BYTES, MAX_PATH_DEPTH, type Token, type LiteralToken, type ExprToken, type SourcePosition, } from './tokenizer.js';
-export { resolve, dependencies, type Scope, type EvalError, } from './evaluator.js';
-export { type WalkEntry, type FieldPredicate, } from './walker.js';
-export { type TopoNode, type TopoResult, } from './topo-sort.js';
+export { resolve, dependencies, type Scope, } from './evaluator.js';
+export { type FieldPredicate, } from './walker.js';
 export { validateTemplates, detectCycles, allowedScopeRoots, type TemplateError, type TemplateValidationResult, } from './validate.js';
+export { validateTemplateDraft, formatTemplateDraftProblems, type TemplateDraftInput, type TemplateDraftLike, type TemplateDraftProblem, type TemplateDraftProblemKind, type TemplateDraftValidation, } from './draft.js';
 import { ErrorCode } from '@pipeline-builder/api-core';
 import { type Scope } from './evaluator.js';
 import { type FieldPredicate } from './walker.js';

package/lib/template/index.js

@@ -3,8 +3,8 @@
 export { tokenize, hasTemplate, MAX_FIELD_SIZE_BYTES, MAX_PATH_DEPTH, } from './tokenizer.js';
 export { resolve, dependencies, } from './evaluator.js';
 export {} from './walker.js';
-export {} from './topo-sort.js';
 export { validateTemplates, detectCycles, allowedScopeRoots, } from './validate.js';
+export { validateTemplateDraft, formatTemplateDraftProblems, } from './draft.js';
 // -- Convenience: high-level resolve() that walks + resolves + measures
 import { ErrorCode } from '@pipeline-builder/api-core';
 import { resolve as evaluatorResolve } from './evaluator.js';
@@ -102,4 +102,4 @@ export function resolveSelfReferencing(doc, scope, isTemplatable, fieldToScopePa
     }
     return { errors };
 }
-//# 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  MAX_FIELD_SIZE_BYTES,\n  MAX_PATH_DEPTH,\n  type Token,\n  type LiteralToken,\n  type ExprToken,\n  type SourcePosition,\n} from './tokenizer.js';\n\nexport {\n  resolve,\n  dependencies,\n  type Scope,\n  type EvalError,\n} from './evaluator.js';\n\nexport {\n  type WalkEntry,\n  type FieldPredicate,\n} from './walker.js';\n\nexport {\n  type TopoNode,\n  type TopoResult,\n} from './topo-sort.js';\n\nexport {\n  validateTemplates,\n  detectCycles,\n  allowedScopeRoots,\n  type TemplateError,\n  type TemplateValidationResult,\n} from './validate.js';\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.js';\nimport { topoSort } from './topo-sort.js';\nimport { walkAndBind, type FieldPredicate } from './walker.js';\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 */\nexport function resolveTemplates<T extends object>(\n  doc: T,\n  scope: Scope,\n  isTemplatable: FieldPredicate,\n): ResolveResult {\n  const errors: ResolveResult['errors'] = [];\n  // includeLiteralOnly: literal-only fields (a bare `{{{{` escape) still need\n  // rewriting so the tokenizer's `{{{{` → `{{` unescape lands in the document.\n  const entries = walkAndBind(doc, isTemplatable, 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      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  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): ResolveResult {\n  // includeLiteralOnly: a self-referencing field that is only a `{{{{` escape\n  // still needs its unescape written back (same rationale as resolveTemplates).\n  const entries = walkAndBind(doc, isTemplatable, true);\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    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  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        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  return { errors };\n}\n\n"]}
+//# 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  MAX_FIELD_SIZE_BYTES,\n  MAX_PATH_DEPTH,\n  type Token,\n  type LiteralToken,\n  type ExprToken,\n  type SourcePosition,\n} from './tokenizer.js';\n\nexport {\n  resolve,\n  dependencies,\n  type Scope,\n} from './evaluator.js';\n\nexport {\n  type FieldPredicate,\n} from './walker.js';\n\nexport {\n  validateTemplates,\n  detectCycles,\n  allowedScopeRoots,\n  type TemplateError,\n  type TemplateValidationResult,\n} from './validate.js';\n\nexport {\n  validateTemplateDraft,\n  formatTemplateDraftProblems,\n  type TemplateDraftInput,\n  type TemplateDraftLike,\n  type TemplateDraftProblem,\n  type TemplateDraftProblemKind,\n  type TemplateDraftValidation,\n} from './draft.js';\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.js';\nimport { topoSort } from './topo-sort.js';\nimport { walkAndBind, type FieldPredicate } from './walker.js';\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 */\nexport function resolveTemplates<T extends object>(\n  doc: T,\n  scope: Scope,\n  isTemplatable: FieldPredicate,\n): ResolveResult {\n  const errors: ResolveResult['errors'] = [];\n  // includeLiteralOnly: literal-only fields (a bare `{{{{` escape) still need\n  // rewriting so the tokenizer's `{{{{` → `{{` unescape lands in the document.\n  const entries = walkAndBind(doc, isTemplatable, 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      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  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): ResolveResult {\n  // includeLiteralOnly: a self-referencing field that is only a `{{{{` escape\n  // still needs its unescape written back (same rationale as resolveTemplates).\n  const entries = walkAndBind(doc, isTemplatable, true);\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    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  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        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  return { errors };\n}\n\n"]}

package/lib/template/plugin-resolver.d.ts

@@ -1,5 +1,4 @@
 import type { Plugin } from '@pipeline-builder/pipeline-data';
-export declare function isPluginTemplatableField(field: string): boolean;
 /**
  * Return a shallow clone of `plugin` with all `{{ ... }}` templates
  * resolved against the given pipeline scope. Caller must pre-populate

package/lib/template/plugin-resolver.js

@@ -1,26 +1,10 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
+// Which plugin fields accept `{{ ... }}` is the plugin spec's TEMPLATE
+// CONTRACT, owned by api-core so the upload check, the CLI and this resolver
+// can't disagree about it. Do not re-declare the field list here.
+import { isPluginTemplatableField } from '@pipeline-builder/api-core';
 import { resolveSelfReferencing, resolveTemplates } from './index.js';
-/**
- * Fields inside a Plugin record that accept `{{ ... }}` templates.
- *
- * Pure-string leaves only. `name`, `version`, `pluginType`, `computeType`,
- * `timeout`, `secrets`, `failureBehavior`, `requiredMetadata`, `requiredVars`
- * stay literal. `metadata.*` is excluded because CDK-metadata values are
- * structural, not user-interpolated.
- */
-const TEMPLATABLE_FIELDS = [
-    'description',
-    'commands', // string[]
-    'installCommands', // string[]
-    'env', // Record<string, string>
-    'buildArgs', // Record<string, string>
-];
-export function isPluginTemplatableField(field) {
-    // `commands` / `installCommands` are arrays of strings → entries like 'commands[0]'
-    // `env` / `buildArgs` are objects → entries like 'env.STAGE'
-    return TEMPLATABLE_FIELDS.some(f => field === f || field.startsWith(`${f}[`) || field.startsWith(`${f}.`));
-}
 /**
  * Return a shallow clone of `plugin` with all `{{ ... }}` templates
  * resolved against the given pipeline scope. Caller must pre-populate
@@ -59,4 +43,4 @@ export function resolvePluginTemplates(plugin, pipelineScope) {
     }
     return clone;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/testing/exports.json

@@ -3,7 +3,6 @@
   "entries": {
     ".": {
       "allowedScopeRoots": "function",
-      "CDK_METADATA_PREFIX": "value",
       "checkPluginContract": "function",
       "collectPluginSteps": "function",
       "ComputeType": "value",
@@ -14,9 +13,9 @@
       "dependencies": "function",
       "detectCycles": "function",
       "extractMetadataEnv": "function",
+      "formatTemplateDraftProblems": "function",
       "hasTemplate": "function",
       "isContractValueOfType": "function",
-      "isPluginTemplatableField": "function",
       "MAX_FIELD_SIZE_BYTES": "value",
       "MAX_PATH_DEPTH": "value",
       "MetadataKeys": "value",
@@ -40,6 +39,7 @@
       "tokenize": "function",
       "TriggerType": "value",
       "unwrapLookup": "function",
+      "validateTemplateDraft": "function",
       "validateTemplates": "function",
       "wrapCommandsForFailureBehavior": "function"
     },

package/package.json

@@ -33,8 +33,8 @@
   "dependencies": {
     "axios": "1.20.0",
     "jsonwebtoken": "9.0.3",
-    "@pipeline-builder/api-core": "4.1.20",
-    "@pipeline-builder/pipeline-data": "4.1.22"
+    "@pipeline-builder/api-core": "4.1.21",
+    "@pipeline-builder/pipeline-data": "4.1.23"
   },
   "keywords": [
     "ci-cd",
@@ -97,7 +97,7 @@
       ]
     }
   },
-  "version": "4.1.22",
+  "version": "4.1.23",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },