@pipeline-builder/pipeline-core 0.0.1

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,88 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * 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 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 { type FieldPredicate } from './walker.js';
+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 on each call.
+ */
+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[];

package/lib/template/validate.js

@@ -0,0 +1,96 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { ErrorCode } from '@pipeline-builder/api-core';
+import { dependencies } from './evaluator.js';
+import { TokenizerError, tokenize } from './tokenizer.js';
+import { topoSort } from './topo-sort.js';
+import { visitStrings, walkAndBind } from './walker.js';
+/**
+ * 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 function allowedScopeRoots(roots) {
+    const allowed = new Set(roots);
+    return (path) => {
+        const root = path[0];
+        return !!root && allowed.has(root);
+    };
+}
+/**
+ * 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 on each call.
+ */
+export function validateTemplates(doc, isTemplatable, isKnownPath) {
+    const errors = [];
+    const entries = [];
+    // Pass 1: parse every templatable field, collecting parse errors instead
+    // of throwing on the first one.
+    visitStrings(doc, isTemplatable, (field, source) => {
+        try {
+            entries.push({ field, tokens: tokenize(source) });
+        }
+        catch (err) {
+            if (err instanceof TokenizerError) {
+                errors.push({ field, line: err.pos.line, col: err.pos.col, code: ErrorCode.TEMPLATE_PARSE_ERROR, message: err.message });
+            }
+            else {
+                errors.push({ field, code: ErrorCode.TEMPLATE_PARSE_ERROR, message: String(err) });
+            }
+        }
+    });
+    // Pass 2: validate each expr's path is shape-allowed and not reserved
+    for (const { field, tokens } of entries) {
+        for (const tok of tokens) {
+            if (tok.kind !== 'expr')
+                continue;
+            if (tok.path[0] === 'secrets') {
+                errors.push(mkErr(field, tok.pos, ErrorCode.TEMPLATE_SECRETS_RESERVED, '\'secrets\' is a reserved scope — use the plugin\'s \'secrets:\' field instead', tok.path.join('.')));
+                continue;
+            }
+            if (!isKnownPath(tok.path)) {
+                errors.push(mkErr(field, tok.pos, ErrorCode.TEMPLATE_UNKNOWN_PATH, `Template references unknown scope root '${tok.path[0]}'`, tok.path.join('.')));
+            }
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * 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 function detectCycles(doc, isTemplatable, fieldToScopePath) {
+    const nodes = [];
+    for (const entry of walkAndBind(doc, isTemplatable)) {
+        const key = fieldToScopePath(entry.field);
+        if (!key)
+            continue;
+        nodes.push({ key, deps: dependencies(entry.tokens) });
+    }
+    const { cycles } = topoSort(nodes);
+    return cycles.map(c => ({
+        field: c[0],
+        code: ErrorCode.TEMPLATE_CYCLE,
+        message: `Template cycle detected: ${c.join(' -> ')}`,
+        cycle: c,
+    }));
+}
+// -- helpers -----------------------------------------------------------------
+function mkErr(field, pos, code, message, path) {
+    return { field, line: pos.line, col: pos.col, code, message, ...(path && { path }) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validate.js","sourceRoot":"","sources":["../../src/template/validate.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 { dependencies } from './evaluator.js';\nimport { type SourcePosition, type Token, TokenizerError, tokenize } from './tokenizer.js';\nimport { topoSort } from './topo-sort.js';\nimport { type FieldPredicate, visitStrings, walkAndBind } from './walker.js';\n\nexport interface TemplateError {\n  field: string;\n  line?: number;\n  col?: number;\n  code: ErrorCode;\n  message: string;\n  path?: string;\n  cycle?: string[];\n}\n\nexport interface ValidationResult {\n  valid: boolean;\n  errors: TemplateError[];\n}\n\n/**\n * Build a predicate that accepts a template path when its root is in the\n * given allow-list. Used by the validator to check that every `{{ path }}`\n * resolves to a known scope root (`pipeline`, `plugin`, `env`, …).\n *\n * Only the root segment is checked — we don't enforce exact nested-key\n * existence here because metadata / vars keys are user-provided per pipeline\n * and not known at plugin upload time.\n */\nexport function allowedScopeRoots(roots: string[]): (path: string[]) => boolean {\n  const allowed = new Set(roots);\n  return (path) => {\n    const root = path[0];\n    return !!root && allowed.has(root);\n  };\n}\n\n/**\n * Validate all template tokens in a document have well-formed paths and\n * point at allowed scope roots. Returns all errors found — does NOT stop\n * on first.\n *\n * Caller supplies `isTemplatable` (the schema allow-list) and\n * `isKnownPath` (the scope-shape predicate). Template text is parsed\n * fresh on each call.\n */\nexport function validateTemplates<T extends object>(\n  doc: T,\n  isTemplatable: FieldPredicate,\n  isKnownPath: (path: string[]) => boolean,\n): ValidationResult {\n  const errors: TemplateError[] = [];\n  const entries: { field: string; tokens: Token[] }[] = [];\n\n  // Pass 1: parse every templatable field, collecting parse errors instead\n  // of throwing on the first one.\n  visitStrings(doc, isTemplatable, (field, source) => {\n    try {\n      entries.push({ field, tokens: tokenize(source) });\n    } catch (err) {\n      if (err instanceof TokenizerError) {\n        errors.push({ field, line: err.pos.line, col: err.pos.col, code: ErrorCode.TEMPLATE_PARSE_ERROR, message: err.message });\n      } else {\n        errors.push({ field, code: ErrorCode.TEMPLATE_PARSE_ERROR, message: String(err) });\n      }\n    }\n  });\n\n  // Pass 2: validate each expr's path is shape-allowed and not reserved\n  for (const { field, tokens } of entries) {\n    for (const tok of tokens) {\n      if (tok.kind !== 'expr') continue;\n      if (tok.path[0] === 'secrets') {\n        errors.push(mkErr(field, tok.pos, ErrorCode.TEMPLATE_SECRETS_RESERVED,\n          '\\'secrets\\' is a reserved scope — use the plugin\\'s \\'secrets:\\' field instead',\n          tok.path.join('.')));\n        continue;\n      }\n      if (!isKnownPath(tok.path)) {\n        errors.push(mkErr(field, tok.pos, ErrorCode.TEMPLATE_UNKNOWN_PATH,\n          `Template references unknown scope root '${tok.path[0]}'`,\n          tok.path.join('.')));\n      }\n    }\n  }\n\n  return { valid: errors.length === 0, errors };\n}\n\n/**\n * Detect cycles in a self-referencing document. Caller supplies the\n * templatable predicate and a function to extract the scope-path that\n * each template field writes to (same value used as a key in deps).\n *\n * Example for pipeline.json: the field `metadata.env` writes to scope\n * path `metadata.env`; a template `{{ metadata.region }}` in that field\n * declares a dependency on `metadata.region`.\n */\nexport function detectCycles<T extends object>(\n  doc: T,\n  isTemplatable: FieldPredicate,\n  fieldToScopePath: (field: string) => string | null,\n): TemplateError[] {\n  const nodes = [];\n  for (const entry of walkAndBind(doc, isTemplatable)) {\n    const key = fieldToScopePath(entry.field);\n    if (!key) continue;\n    nodes.push({ key, deps: dependencies(entry.tokens) });\n  }\n  const { cycles } = topoSort(nodes);\n  return cycles.map(c => ({\n    field: c[0]!,\n    code: ErrorCode.TEMPLATE_CYCLE,\n    message: `Template cycle detected: ${c.join(' -> ')}`,\n    cycle: c,\n  }));\n}\n\n// -- helpers -----------------------------------------------------------------\n\nfunction mkErr(\n  field: string,\n  pos: SourcePosition,\n  code: ErrorCode,\n  message: string,\n  path?: string,\n): TemplateError {\n  return { field, line: pos.line, col: pos.col, code, message, ...(path && { path }) };\n}\n\n"]}

package/lib/template/walker.d.ts

@@ -0,0 +1,34 @@
+import { type Token } from './tokenizer.js';
+export interface WalkEntry {
+    /** Dotted path to the field inside the document, e.g. 'commands[3]' or 'env.STAGE' */
+    field: string;
+    /** Raw source string containing template tokens */
+    source: string;
+    /** Parsed token stream */
+    tokens: Token[];
+    /** Setter to write back a resolved value into the original `root` object */
+    set: (value: unknown) => void;
+}
+export type FieldPredicate = (field: string) => boolean;
+/**
+ * Visit every templatable string leaf under `root`. Calls `handler(field, source)`
+ * for each string whose field path satisfies `isTemplatable` and contains `{{`.
+ * Does NOT tokenize — callers decide whether to throw or collect errors.
+ */
+export declare function visitStrings(root: unknown, isTemplatable: FieldPredicate, handler: (field: string, source: string, keyPath: Array<string | number>) => void): void;
+/**
+ * Walk all templatable string fields under `root`, returning one entry per
+ * templated field with a bound `set()` that mutates `root` in place.
+ * Tokenization happens eagerly here — parse errors throw.
+ *
+ * By default only fields containing at least one `{{ expr }}` are returned.
+ * Pass `includeLiteralOnly` to also return fields whose only template content
+ * is a `{{{{` escape sequence — these still need rewriting so the tokenizer's
+ * `{{{{` → `{{` unescape actually materializes into the document.
+ *
+ * The bound `set()` writes back via the exact key path captured during the
+ * walk (the real `Object.entries` keys), so document keys containing `.`,
+ * `[`, or `]` (e.g. `env["FOO.BAR"]`) are written correctly rather than being
+ * silently dropped by re-parsing a flattened dotted field string.
+ */
+export declare function walkAndBind<T extends object>(root: T, isTemplatable: FieldPredicate, includeLiteralOnly?: boolean): WalkEntry[];

package/lib/template/walker.js

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

package/package.json

@@ -0,0 +1,184 @@
+{
+  "name": "@pipeline-builder/pipeline-core",
+  "description": "AWS CDK construct library for Pipeline Builder: the Builder construct that assembles plugin specs into a CodePipeline stack, PluginLookup custom resource, pipeline/plugin domain types, and shared configuration.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mwashburn160/pipeline-builder.git"
+  },
+  "devDependencies": {
+    "@aws-sdk/client-secrets-manager": "3.1101.0",
+    "@jest/globals": "30.4.1",
+    "@stylistic/eslint-plugin": "^2",
+    "@types/aws-lambda": "8.10.162",
+    "@types/jsonwebtoken": "9.0.10",
+    "@types/node": "26.1.2",
+    "@typescript-eslint/eslint-plugin": "^8",
+    "@typescript-eslint/parser": "^8",
+    "@typescript/native": "npm:typescript@^7.0.2",
+    "aws-cdk-lib": "2.263.0",
+    "constructs": "10.7.0",
+    "copyfiles": "2.4.1",
+    "eslint": "^9",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
+    "jest": "30.4.2",
+    "jest-junit": "^17",
+    "ts-jest": "29.4.12",
+    "typescript": "npm:@typescript/typescript6@^6.0.2"
+  },
+  "peerDependencies": {
+    "aws-cdk-lib": "^2.263.0",
+    "constructs": "^10.5.0"
+  },
+  "dependencies": {
+    "axios": "1.19.0",
+    "jsonwebtoken": "9.0.3",
+    "uuid": "14.0.1",
+    "@pipeline-builder/api-core": "0.0.1",
+    "@pipeline-builder/pipeline-data": "0.0.1"
+  },
+  "keywords": [
+    "ci-cd",
+    "cicd",
+    "continuous-delivery",
+    "devops",
+    "self-service",
+    "platform-engineering",
+    "internal-developer-platform",
+    "developer-platform",
+    "aws",
+    "aws-cdk",
+    "cdk",
+    "codepipeline",
+    "codebuild",
+    "cloudformation",
+    "pipeline",
+    "pipeline-as-code",
+    "infrastructure-as-code",
+    "iac",
+    "compliance",
+    "policy-as-code",
+    "governance",
+    "golden-paths",
+    "multi-tenant",
+    "rbac",
+    "ai",
+    "ai-pipeline-generation",
+    "llm",
+    "bedrock",
+    "plugins",
+    "plugin-marketplace",
+    "containerized",
+    "docker",
+    "kubernetes",
+    "typescript",
+    "cli"
+  ],
+  "engines": {
+    "node": ">= 24.14.0"
+  },
+  "devEngines": {
+    "packageManager": {
+      "name": "pnpm",
+      "version": ">=10",
+      "onFail": "ignore"
+    }
+  },
+  "main": "lib/index.js",
+  "license": "Apache-2.0",
+  "homepage": "https://mwashburn160.github.io/pipeline-builder/",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "version": "0.0.1",
+  "bugs": {
+    "url": "https://github.com/mwashburn160/pipeline-builder/issues"
+  },
+  "jest": {
+    "coverageProvider": "v8",
+    "testMatch": [
+      "<rootDir>/@(src|test)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(src|test)/**/__tests__/**/*.ts?(x)"
+    ],
+    "clearMocks": true,
+    "collectCoverage": true,
+    "coverageReporters": [
+      "json",
+      "lcov",
+      "clover",
+      "cobertura",
+      "text"
+    ],
+    "coverageDirectory": "coverage",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "watchPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "reporters": [
+      "default",
+      [
+        "jest-junit",
+        {
+          "outputDirectory": "test-reports"
+        }
+      ]
+    ],
+    "transform": {
+      "^.+\\.[t]sx?$": [
+        "ts-jest",
+        {
+          "useESM": true,
+          "tsconfig": "tsconfig.dev.json",
+          "diagnostics": {
+            "ignoreCodes": [
+              151002
+            ]
+          }
+        }
+      ]
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts",
+      ".tsx"
+    ],
+    "moduleNameMapper": {
+      "^uuid$": "<rootDir>/../../jest-uuid-stub.js",
+      "^(\\.{1,2}/.*)\\.js$": "$1"
+    },
+    "maxWorkers": 1
+  },
+  "types": "lib/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./cdk": {
+      "types": "./lib/cdk.d.ts",
+      "default": "./lib/cdk.js"
+    },
+    "./lib/*": "./lib/*",
+    "./package.json": "./package.json"
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"pnpm dlx projen\".",
+  "scripts": {
+    "build": "pnpm dlx projen build",
+    "compile": "pnpm dlx projen compile",
+    "default": "pnpm dlx projen default",
+    "eslint": "pnpm dlx projen eslint",
+    "package": "pnpm dlx projen package",
+    "post-compile": "pnpm dlx projen post-compile",
+    "pre-compile": "pnpm dlx projen pre-compile",
+    "test": "pnpm dlx projen test",
+    "test:watch": "pnpm dlx projen test:watch",
+    "watch": "pnpm dlx projen watch",
+    "projen": "pnpm dlx projen"
+  }
+}