@pipeline-builder/pipeline-core 3.1.5 → 3.2.0

package/lib/template/metrics.js

@@ -0,0 +1,35 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templateResolutionDurationMs = exports.templateResolutionsTotal = void 0;
+exports.recordResolution = recordResolution;
+function resolvePromClient() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        return require('prom-client');
+    }
+    catch {
+        return null;
+    }
+}
+const promClient = resolvePromClient();
+function makeCounter(name, help, labelNames) {
+    if (!promClient)
+        return { inc: () => { } };
+    const existing = promClient.register.getSingleMetric(name);
+    return existing ?? new promClient.Counter({ name, help, labelNames });
+}
+function makeHistogram(name, help, labelNames, buckets) {
+    if (!promClient)
+        return { observe: () => { } };
+    const existing = promClient.register.getSingleMetric(name);
+    return existing ?? new promClient.Histogram({ name, help, labelNames, buckets });
+}
+exports.templateResolutionsTotal = makeCounter('pipeline_builder_template_resolutions_total', 'Total number of template resolution operations', ['outcome', 'doc']);
+exports.templateResolutionDurationMs = makeHistogram('pipeline_builder_template_resolution_duration_ms', 'Template resolution duration in milliseconds', ['doc'], [1, 5, 10, 50, 100, 500, 1000]);
+function recordResolution(doc, durationMs, success) {
+    exports.templateResolutionsTotal.inc({ outcome: success ? 'success' : 'error', doc });
+    exports.templateResolutionDurationMs.observe({ doc }, durationMs);
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,8 @@
+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
+ * `pipelineScope` with `{ pipeline, plugin, env }` keys.
+ */
+export declare function resolvePluginTemplates(plugin: Plugin, pipelineScope: Record<string, unknown>): Plugin;

package/lib/template/plugin-resolver.js

@@ -0,0 +1,52 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPluginTemplatableField = isPluginTemplatableField;
+exports.resolvePluginTemplates = resolvePluginTemplates;
+const index_1 = require("./index");
+/**
+ * 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>
+];
+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
+ * `pipelineScope` with `{ pipeline, plugin, env }` keys.
+ */
+function resolvePluginTemplates(plugin, pipelineScope) {
+    // Deep clone so mutations don't leak back to the caller's Plugin.
+    // Structural fields we care about are plain JSON; structuredClone is safe.
+    const clone = structuredClone(plugin);
+    const scope = {
+        ...pipelineScope,
+        plugin: { name: plugin.name, version: plugin.version, imageTag: plugin.imageTag },
+        env: plugin.env ?? {},
+    };
+    const { errors } = (0, index_1.resolveTemplates)(clone, scope, isPluginTemplatableField, 'plugin');
+    if (errors.length > 0) {
+        // First error wins — resolver errors should never be batched at synth time
+        // because a broken template is a programmer error, not a validation step.
+        const e = errors[0];
+        const msg = `Template resolution failed in plugin "${plugin.name}" at field '${e.field}': ${e.message}`;
+        throw new Error(msg);
+    }
+    return clone;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/template/tokenizer.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Tokenizer for the pipeline-builder template grammar.
+ *
+ * Grammar:
+ *   Template   := (Literal | Expr)*
+ *   Expr       := "{{" ws Path (ws Filter)? ws "}}"
+ *   Path       := Identifier ("." Identifier)*
+ *   Identifier := [a-zA-Z_][a-zA-Z0-9_]{0,63}
+ *   Filter     := "|" ws "default" ws ":" ws Quoted
+ *   Quoted     := "'" ... "'" | "\"" ... "\""
+ *
+ * `{{{{` is the escape sequence for a literal `{{`.
+ */
+export declare const MAX_FIELD_SIZE_BYTES: number;
+export declare const MAX_PATH_DEPTH = 5;
+export declare const MAX_IDENTIFIER_LENGTH = 64;
+export interface SourcePosition {
+    line: number;
+    col: number;
+}
+export interface LiteralToken {
+    kind: 'literal';
+    value: string;
+    pos: SourcePosition;
+}
+export type CoerceKind = 'number' | 'bool' | 'json';
+export interface ExprToken {
+    kind: 'expr';
+    path: string[];
+    defaultValue?: string;
+    coerce?: CoerceKind;
+    source: string;
+    pos: SourcePosition;
+}
+export type Token = LiteralToken | ExprToken;
+export declare class TokenizerError extends Error {
+    readonly pos: SourcePosition;
+    constructor(message: string, pos: SourcePosition);
+}
+/**
+ * Tokenize a template source string. Never throws on valid input;
+ * throws `TokenizerError` with source position on malformed templates.
+ */
+export declare function tokenize(source: string): Token[];
+/**
+ * Convenience: returns true if the source contains any templates.
+ * Used as a fast-path to skip tokenization for strings that are obviously literal.
+ */
+export declare function hasTemplate(source: string): boolean;

package/lib/template/tokenizer.js

@@ -0,0 +1,237 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenizerError = exports.MAX_IDENTIFIER_LENGTH = exports.MAX_PATH_DEPTH = exports.MAX_FIELD_SIZE_BYTES = void 0;
+exports.tokenize = tokenize;
+exports.hasTemplate = hasTemplate;
+/**
+ * Tokenizer for the pipeline-builder template grammar.
+ *
+ * Grammar:
+ *   Template   := (Literal | Expr)*
+ *   Expr       := "{{" ws Path (ws Filter)? ws "}}"
+ *   Path       := Identifier ("." Identifier)*
+ *   Identifier := [a-zA-Z_][a-zA-Z0-9_]{0,63}
+ *   Filter     := "|" ws "default" ws ":" ws Quoted
+ *   Quoted     := "'" ... "'" | "\"" ... "\""
+ *
+ * `{{{{` is the escape sequence for a literal `{{`.
+ */
+exports.MAX_FIELD_SIZE_BYTES = 4 * 1024;
+exports.MAX_PATH_DEPTH = 5;
+exports.MAX_IDENTIFIER_LENGTH = 64;
+class TokenizerError extends Error {
+    pos;
+    constructor(message, pos) {
+        super(`${message} at line ${pos.line}, col ${pos.col}`);
+        this.pos = pos;
+        this.name = 'TokenizerError';
+    }
+}
+exports.TokenizerError = TokenizerError;
+/**
+ * Tokenize a template source string. Never throws on valid input;
+ * throws `TokenizerError` with source position on malformed templates.
+ */
+function tokenize(source) {
+    if (source.length > exports.MAX_FIELD_SIZE_BYTES) {
+        throw new TokenizerError(`Field exceeds max size of ${exports.MAX_FIELD_SIZE_BYTES} bytes`, { line: 1, col: 1 });
+    }
+    const tokens = [];
+    let i = 0;
+    let line = 1;
+    let col = 1;
+    let literalStart = 0;
+    let literalStartPos = { line: 1, col: 1 };
+    const advance = (n) => {
+        for (let k = 0; k < n; k++) {
+            if (source[i + k] === '\n') {
+                line++;
+                col = 1;
+            }
+            else {
+                col++;
+            }
+        }
+        i += n;
+    };
+    const flushLiteral = (endIdx) => {
+        if (endIdx > literalStart) {
+            // Unescape `{{{{` → `{{`
+            const raw = source.slice(literalStart, endIdx);
+            const value = raw.replace(/\{\{\{\{/g, '{{');
+            tokens.push({ kind: 'literal', value, pos: literalStartPos });
+        }
+    };
+    const startLiteral = () => {
+        literalStart = i;
+        literalStartPos = { line, col };
+    };
+    startLiteral();
+    while (i < source.length) {
+        // Escape: `{{{{` → literal `{{`
+        if (source.startsWith('{{{{', i)) {
+            advance(4);
+            continue;
+        }
+        // Expression start
+        if (source.startsWith('{{', i)) {
+            flushLiteral(i);
+            const exprPos = { line, col };
+            advance(2);
+            const expr = readExpression(source, i, line, col);
+            tokens.push({
+                kind: 'expr',
+                path: expr.path,
+                defaultValue: expr.defaultValue,
+                coerce: expr.coerce,
+                source: source.slice(exprPos.col - 1 === 0 ? i - 2 : (() => { return i - 2; })(), expr.endIdx),
+                pos: exprPos,
+            });
+            advance(expr.endIdx - i);
+            startLiteral();
+            continue;
+        }
+        // Stray `}}` outside an expression
+        if (source.startsWith('}}', i)) {
+            throw new TokenizerError("Unexpected '}}' outside expression", { line, col });
+        }
+        advance(1);
+    }
+    flushLiteral(i);
+    return tokens;
+}
+function readExpression(source, startIdx, startLine, startCol) {
+    let i = startIdx;
+    let line = startLine;
+    let col = startCol;
+    const skipWs = () => {
+        while (i < source.length && (source[i] === ' ' || source[i] === '\t')) {
+            i++;
+            col++;
+        }
+    };
+    const readIdentifier = () => {
+        const startI = i;
+        if (i >= source.length || !/[a-zA-Z_]/.test(source[i])) {
+            throw new TokenizerError('Expected identifier inside template expression', { line, col });
+        }
+        while (i < source.length && /[a-zA-Z0-9_]/.test(source[i])) {
+            i++;
+            col++;
+        }
+        const ident = source.slice(startI, i);
+        if (ident.length > exports.MAX_IDENTIFIER_LENGTH) {
+            throw new TokenizerError(`Identifier exceeds max length of ${exports.MAX_IDENTIFIER_LENGTH}`, { line, col: col - ident.length });
+        }
+        return ident;
+    };
+    const readQuoted = () => {
+        const quote = source[i];
+        if (quote !== '"' && quote !== "'") {
+            throw new TokenizerError('Expected quoted string', { line, col });
+        }
+        i++;
+        col++;
+        const parts = [];
+        while (i < source.length && source[i] !== quote) {
+            if (source[i] === '\\') {
+                const next = source[i + 1];
+                if (next === '\\' || next === quote) {
+                    parts.push(next);
+                    i += 2;
+                    col += 2;
+                    continue;
+                }
+                throw new TokenizerError(`Invalid escape '\\${next ?? ''}' in quoted string`, { line, col });
+            }
+            if (source[i] === '\n') {
+                throw new TokenizerError('Unterminated quoted string', { line, col });
+            }
+            parts.push(source[i]);
+            i++;
+            col++;
+        }
+        if (i >= source.length) {
+            throw new TokenizerError('Unterminated quoted string', { line, col });
+        }
+        i++;
+        col++; // consume closing quote
+        return parts.join('');
+    };
+    skipWs();
+    const path = [readIdentifier()];
+    while (i < source.length && source[i] === '.') {
+        i++;
+        col++;
+        path.push(readIdentifier());
+        if (path.length > exports.MAX_PATH_DEPTH) {
+            throw new TokenizerError(`Path depth exceeds max of ${exports.MAX_PATH_DEPTH}`, { line, col });
+        }
+    }
+    skipWs();
+    let defaultValue;
+    let coerce;
+    // Filters chain: `| default: 'x' | number`, `| bool`, `| json`, etc.
+    // - `default` takes a quoted argument — applied first (before coercion)
+    // - `number`, `bool`, `json` are argument-less coercion filters — applied last
+    while (source[i] === '|') {
+        i++;
+        col++;
+        skipWs();
+        if (source.startsWith('default', i)) {
+            if (defaultValue !== undefined) {
+                throw new TokenizerError("'default' filter may only appear once", { line, col });
+            }
+            i += 'default'.length;
+            col += 'default'.length;
+            skipWs();
+            if (source[i] !== ':') {
+                throw new TokenizerError("Expected ':' after 'default'", { line, col });
+            }
+            i++;
+            col++;
+            skipWs();
+            defaultValue = readQuoted();
+            skipWs();
+            continue;
+        }
+        let matchedCoerce = null;
+        for (const kind of ['number', 'bool', 'json']) {
+            if (source.startsWith(kind, i)) {
+                // Ensure identifier boundary — `numberish` must not match `number`
+                const next = source[i + kind.length];
+                if (!next || !/[a-zA-Z0-9_]/.test(next)) {
+                    matchedCoerce = kind;
+                    i += kind.length;
+                    col += kind.length;
+                    break;
+                }
+            }
+        }
+        if (!matchedCoerce) {
+            throw new TokenizerError("Unknown filter — supported: 'default', 'number', 'bool', 'json'", { line, col });
+        }
+        if (coerce) {
+            throw new TokenizerError('Only one coercion filter is allowed per expression', { line, col });
+        }
+        coerce = matchedCoerce;
+        skipWs();
+    }
+    if (!source.startsWith('}}', i)) {
+        throw new TokenizerError("Expected '}}'", { line, col });
+    }
+    i += 2;
+    return { path, defaultValue, coerce, endIdx: i };
+}
+/**
+ * Convenience: returns true if the source contains any templates.
+ * Used as a fast-path to skip tokenization for strings that are obviously literal.
+ */
+function hasTemplate(source) {
+    // Not completely accurate (a lone `{{{{` would return true) but that's fine —
+    // tokenize() will produce a literal-only token list and round-trip correctly.
+    return source.includes('{{');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tokenizer.js","sourceRoot":"","sources":["../../src/template/tokenizer.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Tokenizer for the pipeline-builder template grammar.\n *\n * Grammar:\n *   Template   := (Literal | Expr)*\n *   Expr       := \"{{\" ws Path (ws Filter)? ws \"}}\"\n *   Path       := Identifier (\".\" Identifier)*\n *   Identifier := [a-zA-Z_][a-zA-Z0-9_]{0,63}\n *   Filter     := \"|\" ws \"default\" ws \":\" ws Quoted\n *   Quoted     := \"'\" ... \"'\" | \"\\\"\" ... \"\\\"\"\n *\n * `{{{{` is the escape sequence for a literal `{{`.\n */\n\nexport const MAX_FIELD_SIZE_BYTES = 4 * 1024;\nexport const MAX_PATH_DEPTH = 5;\nexport const MAX_IDENTIFIER_LENGTH = 64;\n\nexport interface SourcePosition {\n  line: number;\n  col: number;\n}\n\nexport interface LiteralToken {\n  kind: 'literal';\n  value: string;\n  pos: SourcePosition;\n}\n\nexport type CoerceKind = 'number' | 'bool' | 'json';\n\nexport interface ExprToken {\n  kind: 'expr';\n  path: string[]; // e.g. ['pipeline', 'metadata', 'env']\n  defaultValue?: string; // value for `| default: '...'` filter\n  coerce?: CoerceKind; // `| number`, `| bool`, `| json`\n  source: string; // original \"{{ ... }}\" text (for error messages)\n  pos: SourcePosition;\n}\n\nexport type Token = LiteralToken | ExprToken;\n\nexport class TokenizerError extends Error {\n  constructor(\n    message: string,\n    public readonly pos: SourcePosition,\n  ) {\n    super(`${message} at line ${pos.line}, col ${pos.col}`);\n    this.name = 'TokenizerError';\n  }\n}\n\n/**\n * Tokenize a template source string. Never throws on valid input;\n * throws `TokenizerError` with source position on malformed templates.\n */\nexport function tokenize(source: string): Token[] {\n  if (source.length > MAX_FIELD_SIZE_BYTES) {\n    throw new TokenizerError(\n      `Field exceeds max size of ${MAX_FIELD_SIZE_BYTES} bytes`,\n      { line: 1, col: 1 },\n    );\n  }\n\n  const tokens: Token[] = [];\n  let i = 0;\n  let line = 1;\n  let col = 1;\n  let literalStart = 0;\n  let literalStartPos: SourcePosition = { line: 1, col: 1 };\n\n  const advance = (n: number): void => {\n    for (let k = 0; k < n; k++) {\n      if (source[i + k] === '\\n') {\n        line++;\n        col = 1;\n      } else {\n        col++;\n      }\n    }\n    i += n;\n  };\n\n  const flushLiteral = (endIdx: number): void => {\n    if (endIdx > literalStart) {\n      // Unescape `{{{{` → `{{`\n      const raw = source.slice(literalStart, endIdx);\n      const value = raw.replace(/\\{\\{\\{\\{/g, '{{');\n      tokens.push({ kind: 'literal', value, pos: literalStartPos });\n    }\n  };\n\n  const startLiteral = (): void => {\n    literalStart = i;\n    literalStartPos = { line, col };\n  };\n\n  startLiteral();\n\n  while (i < source.length) {\n    // Escape: `{{{{` → literal `{{`\n    if (source.startsWith('{{{{', i)) {\n      advance(4);\n      continue;\n    }\n    // Expression start\n    if (source.startsWith('{{', i)) {\n      flushLiteral(i);\n      const exprPos: SourcePosition = { line, col };\n      advance(2);\n      const expr = readExpression(source, i, line, col);\n      tokens.push({\n        kind: 'expr',\n        path: expr.path,\n        defaultValue: expr.defaultValue,\n        coerce: expr.coerce,\n        source: source.slice(exprPos.col - 1 === 0 ? i - 2 : (() => { return i - 2; })(), expr.endIdx),\n        pos: exprPos,\n      });\n      advance(expr.endIdx - i);\n      startLiteral();\n      continue;\n    }\n    // Stray `}}` outside an expression\n    if (source.startsWith('}}', i)) {\n      throw new TokenizerError(\"Unexpected '}}' outside expression\", { line, col });\n    }\n    advance(1);\n  }\n\n  flushLiteral(i);\n  return tokens;\n}\n\ninterface ParsedExpr {\n  path: string[];\n  defaultValue?: string;\n  coerce?: CoerceKind;\n  endIdx: number;\n}\n\nfunction readExpression(\n  source: string,\n  startIdx: number,\n  startLine: number,\n  startCol: number,\n): ParsedExpr {\n  let i = startIdx;\n  let line = startLine;\n  let col = startCol;\n\n  const skipWs = (): void => {\n    while (i < source.length && (source[i] === ' ' || source[i] === '\\t')) {\n      i++;\n      col++;\n    }\n  };\n\n  const readIdentifier = (): string => {\n    const startI = i;\n    if (i >= source.length || !/[a-zA-Z_]/.test(source[i]!)) {\n      throw new TokenizerError(\n        'Expected identifier inside template expression',\n        { line, col },\n      );\n    }\n    while (i < source.length && /[a-zA-Z0-9_]/.test(source[i]!)) {\n      i++;\n      col++;\n    }\n    const ident = source.slice(startI, i);\n    if (ident.length > MAX_IDENTIFIER_LENGTH) {\n      throw new TokenizerError(\n        `Identifier exceeds max length of ${MAX_IDENTIFIER_LENGTH}`,\n        { line, col: col - ident.length },\n      );\n    }\n    return ident;\n  };\n\n  const readQuoted = (): string => {\n    const quote = source[i];\n    if (quote !== '\"' && quote !== \"'\") {\n      throw new TokenizerError('Expected quoted string', { line, col });\n    }\n    i++; col++;\n    const parts: string[] = [];\n    while (i < source.length && source[i] !== quote) {\n      if (source[i] === '\\\\') {\n        const next = source[i + 1];\n        if (next === '\\\\' || next === quote) {\n          parts.push(next);\n          i += 2;\n          col += 2;\n          continue;\n        }\n        throw new TokenizerError(\n          `Invalid escape '\\\\${next ?? ''}' in quoted string`,\n          { line, col },\n        );\n      }\n      if (source[i] === '\\n') {\n        throw new TokenizerError('Unterminated quoted string', { line, col });\n      }\n      parts.push(source[i]!);\n      i++; col++;\n    }\n    if (i >= source.length) {\n      throw new TokenizerError('Unterminated quoted string', { line, col });\n    }\n    i++; col++; // consume closing quote\n    return parts.join('');\n  };\n\n  skipWs();\n  const path: string[] = [readIdentifier()];\n  while (i < source.length && source[i] === '.') {\n    i++; col++;\n    path.push(readIdentifier());\n    if (path.length > MAX_PATH_DEPTH) {\n      throw new TokenizerError(\n        `Path depth exceeds max of ${MAX_PATH_DEPTH}`,\n        { line, col },\n      );\n    }\n  }\n  skipWs();\n\n  let defaultValue: string | undefined;\n  let coerce: CoerceKind | undefined;\n\n  // Filters chain: `| default: 'x' | number`, `| bool`, `| json`, etc.\n  // - `default` takes a quoted argument — applied first (before coercion)\n  // - `number`, `bool`, `json` are argument-less coercion filters — applied last\n  while (source[i] === '|') {\n    i++; col++;\n    skipWs();\n\n    if (source.startsWith('default', i)) {\n      if (defaultValue !== undefined) {\n        throw new TokenizerError(\"'default' filter may only appear once\", { line, col });\n      }\n      i += 'default'.length;\n      col += 'default'.length;\n      skipWs();\n      if (source[i] !== ':') {\n        throw new TokenizerError(\"Expected ':' after 'default'\", { line, col });\n      }\n      i++; col++;\n      skipWs();\n      defaultValue = readQuoted();\n      skipWs();\n      continue;\n    }\n\n    let matchedCoerce: CoerceKind | null = null;\n    for (const kind of ['number', 'bool', 'json'] as const) {\n      if (source.startsWith(kind, i)) {\n        // Ensure identifier boundary — `numberish` must not match `number`\n        const next = source[i + kind.length];\n        if (!next || !/[a-zA-Z0-9_]/.test(next)) {\n          matchedCoerce = kind;\n          i += kind.length;\n          col += kind.length;\n          break;\n        }\n      }\n    }\n\n    if (!matchedCoerce) {\n      throw new TokenizerError(\n        \"Unknown filter — supported: 'default', 'number', 'bool', 'json'\",\n        { line, col },\n      );\n    }\n    if (coerce) {\n      throw new TokenizerError('Only one coercion filter is allowed per expression', { line, col });\n    }\n    coerce = matchedCoerce;\n    skipWs();\n  }\n\n  if (!source.startsWith('}}', i)) {\n    throw new TokenizerError(\"Expected '}}'\", { line, col });\n  }\n  i += 2;\n  return { path, defaultValue, coerce, endIdx: i };\n}\n\n/**\n * Convenience: returns true if the source contains any templates.\n * Used as a fast-path to skip tokenization for strings that are obviously literal.\n */\nexport function hasTemplate(source: string): boolean {\n  // Not completely accurate (a lone `{{{{` would return true) but that's fine —\n  // tokenize() will produce a literal-only token list and round-trip correctly.\n  return source.includes('{{');\n}\n"]}

package/lib/template/topo-sort.d.ts

@@ -0,0 +1,17 @@
+export interface TopoNode {
+    /** Unique key identifying this node (e.g. source field path) */
+    key: string;
+    /** Dependency keys that must resolve before this node */
+    deps: string[];
+}
+export interface TopoResult {
+    ordered: string[];
+    cycles: string[][];
+}
+/**
+ * Topologically sort a set of nodes by their declared dependency keys.
+ * Returns `ordered` in resolution order, plus any detected cycles.
+ * Nodes whose deps reference keys not in the node set are treated as
+ * depending on "external" values and ordered first (no cycle risk).
+ */
+export declare function topoSort(nodes: TopoNode[]): TopoResult;

package/lib/template/topo-sort.js

@@ -0,0 +1,91 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.topoSort = topoSort;
+/**
+ * Topologically sort a set of nodes by their declared dependency keys.
+ * Returns `ordered` in resolution order, plus any detected cycles.
+ * Nodes whose deps reference keys not in the node set are treated as
+ * depending on "external" values and ordered first (no cycle risk).
+ */
+function topoSort(nodes) {
+    const keys = new Set(nodes.map(n => n.key));
+    const graph = new Map();
+    const inDegree = new Map();
+    // Init
+    for (const n of nodes) {
+        graph.set(n.key, new Set());
+        inDegree.set(n.key, 0);
+    }
+    // Self-loops short-circuit — detected before topo-sort so single-node
+    // cycles are reported even when Kahn's would otherwise accept them.
+    const selfLoops = [];
+    for (const n of nodes) {
+        if (n.deps.includes(n.key))
+            selfLoops.push([n.key, n.key]);
+    }
+    // Edges only between internal nodes (external deps resolve before pass starts)
+    for (const n of nodes) {
+        for (const dep of n.deps) {
+            if (!keys.has(dep))
+                continue;
+            if (dep === n.key)
+                continue; // self-dep → already captured above
+            // Edge: dep -> n.key (dep must come first)
+            if (!graph.get(dep).has(n.key)) {
+                graph.get(dep).add(n.key);
+                inDegree.set(n.key, (inDegree.get(n.key) ?? 0) + 1);
+            }
+        }
+    }
+    // Kahn's algorithm
+    const ordered = [];
+    const queue = [];
+    for (const [k, d] of inDegree)
+        if (d === 0)
+            queue.push(k);
+    while (queue.length) {
+        const k = queue.shift();
+        ordered.push(k);
+        for (const next of graph.get(k) ?? []) {
+            const d = (inDegree.get(next) ?? 0) - 1;
+            inDegree.set(next, d);
+            if (d === 0)
+                queue.push(next);
+        }
+    }
+    // Detect cycles: any node not in `ordered` is part of a cycle
+    const cycles = [...selfLoops];
+    if (ordered.length < nodes.length) {
+        const remaining = new Set(nodes.map(n => n.key).filter(k => !ordered.includes(k)));
+        const visited = new Set();
+        for (const start of remaining) {
+            if (visited.has(start))
+                continue;
+            const path = [];
+            const cycle = findCycle(start, graph, visited, path, remaining);
+            if (cycle)
+                cycles.push(cycle);
+        }
+    }
+    return { ordered, cycles };
+}
+function findCycle(start, graph, visited, path, remaining) {
+    if (path.includes(start)) {
+        const idx = path.indexOf(start);
+        return [...path.slice(idx), start];
+    }
+    if (visited.has(start) || !remaining.has(start))
+        return null;
+    visited.add(start);
+    path.push(start);
+    for (const next of graph.get(start) ?? []) {
+        const cycle = findCycle(next, graph, visited, path, remaining);
+        if (cycle)
+            return cycle;
+    }
+    path.pop();
+    return null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"topo-sort.js","sourceRoot":"","sources":["../../src/template/topo-sort.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nexport interface TopoNode {\n  /** Unique key identifying this node (e.g. source field path) */\n  key: string;\n  /** Dependency keys that must resolve before this node */\n  deps: string[];\n}\n\nexport interface TopoResult {\n  ordered: string[];\n  cycles: string[][];\n}\n\n/**\n * Topologically sort a set of nodes by their declared dependency keys.\n * Returns `ordered` in resolution order, plus any detected cycles.\n * Nodes whose deps reference keys not in the node set are treated as\n * depending on \"external\" values and ordered first (no cycle risk).\n */\nexport function topoSort(nodes: TopoNode[]): TopoResult {\n  const keys = new Set(nodes.map(n => n.key));\n  const graph = new Map<string, Set<string>>();\n  const inDegree = new Map<string, number>();\n\n  // Init\n  for (const n of nodes) {\n    graph.set(n.key, new Set());\n    inDegree.set(n.key, 0);\n  }\n\n  // Self-loops short-circuit — detected before topo-sort so single-node\n  // cycles are reported even when Kahn's would otherwise accept them.\n  const selfLoops: string[][] = [];\n  for (const n of nodes) {\n    if (n.deps.includes(n.key)) selfLoops.push([n.key, n.key]);\n  }\n\n  // Edges only between internal nodes (external deps resolve before pass starts)\n  for (const n of nodes) {\n    for (const dep of n.deps) {\n      if (!keys.has(dep)) continue;\n      if (dep === n.key) continue; // self-dep → already captured above\n      // Edge: dep -> n.key (dep must come first)\n      if (!graph.get(dep)!.has(n.key)) {\n        graph.get(dep)!.add(n.key);\n        inDegree.set(n.key, (inDegree.get(n.key) ?? 0) + 1);\n      }\n    }\n  }\n\n  // Kahn's algorithm\n  const ordered: string[] = [];\n  const queue: string[] = [];\n  for (const [k, d] of inDegree) if (d === 0) queue.push(k);\n  while (queue.length) {\n    const k = queue.shift()!;\n    ordered.push(k);\n    for (const next of graph.get(k) ?? []) {\n      const d = (inDegree.get(next) ?? 0) - 1;\n      inDegree.set(next, d);\n      if (d === 0) queue.push(next);\n    }\n  }\n\n  // Detect cycles: any node not in `ordered` is part of a cycle\n  const cycles: string[][] = [...selfLoops];\n  if (ordered.length < nodes.length) {\n    const remaining = new Set(nodes.map(n => n.key).filter(k => !ordered.includes(k)));\n    const visited = new Set<string>();\n    for (const start of remaining) {\n      if (visited.has(start)) continue;\n      const path: string[] = [];\n      const cycle = findCycle(start, graph, visited, path, remaining);\n      if (cycle) cycles.push(cycle);\n    }\n  }\n\n  return { ordered, cycles };\n}\n\nfunction findCycle(\n  start: string,\n  graph: Map<string, Set<string>>,\n  visited: Set<string>,\n  path: string[],\n  remaining: Set<string>,\n): string[] | null {\n  if (path.includes(start)) {\n    const idx = path.indexOf(start);\n    return [...path.slice(idx), start];\n  }\n  if (visited.has(start) || !remaining.has(start)) return null;\n  visited.add(start);\n  path.push(start);\n  for (const next of graph.get(start) ?? []) {\n    const cycle = findCycle(next, graph, visited, path, remaining);\n    if (cycle) return cycle;\n  }\n  path.pop();\n  return null;\n}\n"]}

package/lib/template/validate.d.ts

@@ -0,0 +1,45 @@
+import { ErrorCode } from '@pipeline-builder/api-core';
+import { FieldPredicate } from './walker';
+export interface TemplateError {
+    field: string;
+    line?: number;
+    col?: number;
+    code: ErrorCode;
+    message: string;
+    path?: string;
+    cycle?: string[];
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: TemplateError[];
+}
+/**
+ * Build a predicate that accepts a template path when its root is in the
+ * given allow-list. Used by the validator to check that every `{{ path }}`
+ * resolves to a known scope root (`pipeline`, `plugin`, `env`, …).
+ *
+ * Only the root segment is checked — we don't enforce exact nested-key
+ * existence here because metadata / vars keys are user-provided per pipeline
+ * and not known at plugin upload time.
+ */
+export declare function allowedScopeRoots(roots: string[]): (path: string[]) => boolean;
+/**
+ * Validate all template tokens in a document have well-formed paths and
+ * point at allowed scope roots. Returns all errors found — does NOT stop
+ * on first.
+ *
+ * Caller supplies `isTemplatable` (the schema allow-list) and
+ * `isKnownPath` (the scope-shape predicate). Template text is parsed
+ * fresh; use a TokenCache externally if repeated parsing is a concern.
+ */
+export declare function validateTemplates<T extends object>(doc: T, isTemplatable: FieldPredicate, isKnownPath: (path: string[]) => boolean): ValidationResult;
+/**
+ * Detect cycles in a self-referencing document. Caller supplies the
+ * templatable predicate and a function to extract the scope-path that
+ * each template field writes to (same value used as a key in deps).
+ *
+ * Example for pipeline.json: the field `metadata.env` writes to scope
+ * path `metadata.env`; a template `{{ metadata.region }}` in that field
+ * declares a dependency on `metadata.region`.
+ */
+export declare function detectCycles<T extends object>(doc: T, isTemplatable: FieldPredicate, fieldToScopePath: (field: string) => string | null): TemplateError[];