@pipeline-builder/pipeline-core 0.0.1

package/lib/template/index.d.ts

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

package/lib/template/index.js

@@ -0,0 +1,118 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+export { tokenize, hasTemplate, TokenizerError, MAX_FIELD_SIZE_BYTES, MAX_PATH_DEPTH, MAX_IDENTIFIER_LENGTH, } from './tokenizer.js';
+export { resolve, lookupPath, dependencies, } from './evaluator.js';
+export { walkAndBind, } from './walker.js';
+export { topoSort, } from './topo-sort.js';
+export { validateTemplates, detectCycles, allowedScopeRoots, } from './validate.js';
+export { recordResolution, templateResolutionsTotal, templateResolutionDurationMs, } from './metrics.js';
+// -- Convenience: high-level resolve() that walks + resolves + measures
+import { ErrorCode } from '@pipeline-builder/api-core';
+import { resolve as evaluatorResolve } from './evaluator.js';
+import { recordResolution } from './metrics.js';
+import { topoSort } from './topo-sort.js';
+import { walkAndBind } from './walker.js';
+/**
+ * Resolve all templates inside `doc` by mutating string fields in place.
+ * `doc` is treated as opaque — only string fields that match `isTemplatable`
+ * are rewritten. Returns collected errors (empty array on success).
+ *
+ * `docType` is used for metrics; pass 'pipeline' or 'plugin'.
+ */
+export function resolveTemplates(doc, scope, isTemplatable, docType = 'plugin') {
+    const start = Date.now();
+    const errors = [];
+    // includeLiteralOnly: literal-only fields (a bare `{{{{` escape) still need
+    // rewriting so the tokenizer's `{{{{` → `{{` unescape lands in the document.
+    const entries = walkAndBind(doc, isTemplatable, true);
+    let success = true;
+    for (const entry of entries) {
+        try {
+            const value = evaluatorResolve(entry.tokens, scope, entry.field);
+            entry.set(value);
+        }
+        catch (err) {
+            success = false;
+            const e = err;
+            errors.push({
+                code: e.code ?? ErrorCode.TEMPLATE_PARSE_ERROR,
+                message: e.message,
+                field: entry.field,
+                path: e.path,
+            });
+        }
+    }
+    recordResolution(docType, Date.now() - start, success);
+    return { errors };
+}
+/**
+ * Resolve a self-referencing document (e.g. pipeline.json where
+ * metadata fields reference each other). Topologically orders the
+ * resolution so dependencies come first. Mutates `doc` in place.
+ *
+ * `fieldToScopePath` maps each field (e.g. `metadata.env`) to the scope
+ * path it populates (typically the same, sans any array indices).
+ */
+export function resolveSelfReferencing(doc, scope, isTemplatable, fieldToScopePath, docType = 'pipeline') {
+    const start = Date.now();
+    // includeLiteralOnly: a self-referencing field that is only a `{{{{` escape
+    // still needs its unescape written back (same rationale as resolveTemplates).
+    const entries = walkAndBind(doc, isTemplatable, true);
+    // Build topo nodes keyed by target scope path
+    const nodes = entries
+        .map(e => {
+        const key = fieldToScopePath(e.field);
+        if (!key)
+            return null;
+        const deps = [];
+        for (const t of e.tokens)
+            if (t.kind === 'expr')
+                deps.push(t.path.join('.'));
+        return { key, deps, entry: e };
+    })
+        .filter((n) => n !== null);
+    const { ordered, cycles } = topoSort(nodes.map(n => ({ key: n.key, deps: n.deps })));
+    const errors = [];
+    if (cycles.length) {
+        for (const c of cycles) {
+            errors.push({
+                code: ErrorCode.TEMPLATE_CYCLE,
+                message: `Template cycle detected: ${c.join(' -> ')}`,
+                path: c.join(' -> '),
+            });
+        }
+        recordResolution(docType, Date.now() - start, false);
+        return { errors };
+    }
+    // Resolve in topo order; multiple entries may share a scope key (e.g. one
+    // pipeline field could map to the same scope path — unlikely here), so
+    // iterate all entries whose key == ordered[i].
+    const byKey = new Map();
+    for (const n of nodes) {
+        const list = byKey.get(n.key) ?? [];
+        list.push(n);
+        byKey.set(n.key, list);
+    }
+    let success = true;
+    for (const key of ordered) {
+        for (const n of byKey.get(key) ?? []) {
+            try {
+                const value = evaluatorResolve(n.entry.tokens, scope, n.entry.field);
+                n.entry.set(value);
+            }
+            catch (err) {
+                success = false;
+                const e = err;
+                errors.push({
+                    code: e.code ?? ErrorCode.TEMPLATE_PARSE_ERROR,
+                    message: e.message,
+                    field: n.entry.field,
+                    path: e.path,
+                });
+            }
+        }
+    }
+    recordResolution(docType, Date.now() - start, success);
+    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  TokenizerError,\n  MAX_FIELD_SIZE_BYTES,\n  MAX_PATH_DEPTH,\n  MAX_IDENTIFIER_LENGTH,\n  type Token,\n  type LiteralToken,\n  type ExprToken,\n  type SourcePosition,\n} from './tokenizer.js';\n\nexport {\n  resolve,\n  lookupPath,\n  dependencies,\n  type Scope,\n  type EvalError,\n} from './evaluator.js';\n\nexport {\n  walkAndBind,\n  type WalkEntry,\n  type FieldPredicate,\n} from './walker.js';\n\nexport {\n  topoSort,\n  type TopoNode,\n  type TopoResult,\n} from './topo-sort.js';\n\nexport {\n  validateTemplates,\n  detectCycles,\n  allowedScopeRoots,\n  type TemplateError,\n  type ValidationResult,\n} from './validate.js';\n\nexport {\n  recordResolution,\n  templateResolutionsTotal,\n  templateResolutionDurationMs,\n} from './metrics.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 { recordResolution } from './metrics.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 *\n * `docType` is used for metrics; pass 'pipeline' or 'plugin'.\n */\nexport function resolveTemplates<T extends object>(\n  doc: T,\n  scope: Scope,\n  isTemplatable: FieldPredicate,\n  docType: 'pipeline' | 'plugin' = 'plugin',\n): ResolveResult {\n  const start = Date.now();\n  const errors: ResolveResult['errors'] = [];\n  // 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  let success = true;\n  for (const entry of entries) {\n    try {\n      const value = evaluatorResolve(entry.tokens, scope, entry.field);\n      entry.set(value);\n    } catch (err) {\n      success = false;\n      const e = err as Error & { code?: ErrorCode; path?: string };\n      errors.push({\n        code: e.code ?? ErrorCode.TEMPLATE_PARSE_ERROR,\n        message: e.message,\n        field: entry.field,\n        path: e.path,\n      });\n    }\n  }\n  recordResolution(docType, Date.now() - start, success);\n  return { errors };\n}\n\n/**\n * Resolve a self-referencing document (e.g. pipeline.json where\n * metadata fields reference each other). Topologically orders the\n * resolution so dependencies come first. Mutates `doc` in place.\n *\n * `fieldToScopePath` maps each field (e.g. `metadata.env`) to the scope\n * path it populates (typically the same, sans any array indices).\n */\nexport function resolveSelfReferencing<T extends object>(\n  doc: T,\n  scope: Scope,\n  isTemplatable: FieldPredicate,\n  fieldToScopePath: (field: string) => string | null,\n  docType: 'pipeline' | 'plugin' = 'pipeline',\n): ResolveResult {\n  const start = Date.now();\n  // 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    recordResolution(docType, Date.now() - start, false);\n    return { errors };\n  }\n\n  // Resolve in topo order; multiple entries may share a scope key (e.g. one\n  // pipeline field could map to the same scope path — unlikely here), so\n  // iterate all entries whose key == ordered[i].\n  const byKey = new Map<string, typeof nodes>();\n  for (const n of nodes) {\n    const list = byKey.get(n.key) ?? [];\n    list.push(n);\n    byKey.set(n.key, list);\n  }\n\n  let success = true;\n  for (const key of ordered) {\n    for (const n of byKey.get(key) ?? []) {\n      try {\n        const value = evaluatorResolve(n.entry.tokens, scope, n.entry.field);\n        n.entry.set(value);\n      } catch (err) {\n        success = false;\n        const e = err as Error & { code?: ErrorCode; path?: string };\n        errors.push({\n          code: e.code ?? ErrorCode.TEMPLATE_PARSE_ERROR,\n          message: e.message,\n          field: n.entry.field,\n          path: e.path,\n        });\n      }\n    }\n  }\n  recordResolution(docType, Date.now() - start, success);\n  return { errors };\n}\n\n"]}

package/lib/template/metrics.d.ts

@@ -0,0 +1,10 @@
+interface Counter {
+    inc(labels?: Record<string, string>, value?: number): void;
+}
+interface Histogram {
+    observe(labels: Record<string, string>, value: number): void;
+}
+export declare const templateResolutionsTotal: Counter;
+export declare const templateResolutionDurationMs: Histogram;
+export declare function recordResolution(doc: 'pipeline' | 'plugin', durationMs: number, success: boolean): void;
+export {};

package/lib/template/metrics.js

@@ -0,0 +1,43 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Prometheus metrics for template resolution. Optional — the module is
+ * only wired up when `prom-client` is already present in the host
+ * process (as is the case for api-server based services). Falls back to
+ * no-op stubs when unavailable so pipeline-core stays usable outside
+ * server contexts.
+ */
+import { safeCreateRequire } from '@pipeline-builder/api-core';
+// ESM has no global `require`; safeCreateRequire enables the synchronous,
+// OPTIONAL lazy-load of prom-client below (no-op stubs when it isn't installed).
+// (CJS-bundle safe — see api-core's safe-require.ts.)
+const require = safeCreateRequire(import.meta.url);
+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 });
+}
+export const templateResolutionsTotal = makeCounter('pipeline_builder_template_resolutions_total', 'Total number of template resolution operations', ['outcome', 'doc']);
+export const templateResolutionDurationMs = makeHistogram('pipeline_builder_template_resolution_duration_ms', 'Template resolution duration in milliseconds', ['doc'], [1, 5, 10, 50, 100, 500, 1000]);
+export function recordResolution(doc, durationMs, success) {
+    templateResolutionsTotal.inc({ outcome: success ? 'success' : 'error', doc });
+    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,48 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { 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
+ * `pipelineScope` with `{ pipeline, plugin, env }` keys.
+ */
+export 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 },
+        env: plugin.env ?? {},
+    };
+    const { errors } = 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2luLXJlc29sdmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3RlbXBsYXRlL3BsdWdpbi1yZXNvbHZlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBR3RDLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUU5Qzs7Ozs7OztHQU9HO0FBQ0gsTUFBTSxrQkFBa0IsR0FBRztJQUN6QixhQUFhO0lBQ2IsVUFBVSxFQUFFLFdBQVc7SUFDdkIsaUJBQWlCLEVBQUUsV0FBVztJQUM5QixLQUFLLEVBQUUseUJBQXlCO0lBQ2hDLFdBQVcsRUFBRSx5QkFBeUI7Q0FDOUIsQ0FBQztBQUVYLE1BQU0sVUFBVSx3QkFBd0IsQ0FBQyxLQUFhO0lBQ3BELG9GQUFvRjtJQUNwRiw2REFBNkQ7SUFDN0QsT0FBTyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxLQUFLLEtBQUssQ0FBQyxJQUFJLEtBQUssQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxJQUFJLEtBQUssQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7QUFDN0csQ0FBQztBQUVEOzs7O0dBSUc7QUFDSCxNQUFNLFVBQVUsc0JBQXNCLENBQ3BDLE1BQWMsRUFDZCxhQUFzQztJQUV0QyxrRUFBa0U7SUFDbEUsMkVBQTJFO0lBQzNFLE1BQU0sS0FBSyxHQUFHLGVBQWUsQ0FBQyxNQUFNLENBQXFDLENBQUM7SUFFMUUsTUFBTSxLQUFLLEdBQUc7UUFDWixHQUFHLGFBQWE7UUFDaEIsTUFBTSxFQUFFLEVBQUUsSUFBSSxFQUFFLE1BQU0sQ0FBQyxJQUFJLEVBQUUsT0FBTyxFQUFFLE1BQU0sQ0FBQyxPQUFPLEVBQUU7UUFDdEQsR0FBRyxFQUFFLE1BQU0sQ0FBQyxHQUFHLElBQUksRUFBRTtLQUN0QixDQUFDO0lBRUYsTUFBTSxFQUFFLE1BQU0sRUFBRSxHQUFHLGdCQUFnQixDQUFDLEtBQUssRUFBRSxLQUFLLEVBQUUsd0JBQXdCLEVBQUUsUUFBUSxDQUFDLENBQUM7SUFDdEYsSUFBSSxNQUFNLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRSxDQUFDO1FBQ3RCLDJFQUEyRTtRQUMzRSwwRUFBMEU7UUFDMUUsTUFBTSxDQUFDLEdBQUcsTUFBTSxDQUFDLENBQUMsQ0FBRSxDQUFDO1FBQ3JCLE1BQU0sR0FBRyxHQUFHLHlDQUF5QyxNQUFNLENBQUMsSUFBSSxlQUFlLENBQUMsQ0FBQyxLQUFLLE1BQU0sQ0FBQyxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQ3hHLE1BQU0sSUFBSSxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDdkIsQ0FBQztJQUNELE9BQU8sS0FBSyxDQUFDO0FBQ2YsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG5pbXBvcnQgdHlwZSB7IFBsdWdpbiB9IGZyb20gJ0BwaXBlbGluZS1idWlsZGVyL3BpcGVsaW5lLWRhdGEnO1xuaW1wb3J0IHsgcmVzb2x2ZVRlbXBsYXRlcyB9IGZyb20gJy4vaW5kZXguanMnO1xuXG4vKipcbiAqIEZpZWxkcyBpbnNpZGUgYSBQbHVnaW4gcmVjb3JkIHRoYXQgYWNjZXB0IGB7eyAuLi4gfX1gIHRlbXBsYXRlcy5cbiAqXG4gKiBQdXJlLXN0cmluZyBsZWF2ZXMgb25seS4gYG5hbWVgLCBgdmVyc2lvbmAsIGBwbHVnaW5UeXBlYCwgYGNvbXB1dGVUeXBlYCxcbiAqIGB0aW1lb3V0YCwgYHNlY3JldHNgLCBgZmFpbHVyZUJlaGF2aW9yYCwgYHJlcXVpcmVkTWV0YWRhdGFgLCBgcmVxdWlyZWRWYXJzYFxuICogc3RheSBsaXRlcmFsLiBgbWV0YWRhdGEuKmAgaXMgZXhjbHVkZWQgYmVjYXVzZSBDREstbWV0YWRhdGEgdmFsdWVzIGFyZVxuICogc3RydWN0dXJhbCwgbm90IHVzZXItaW50ZXJwb2xhdGVkLlxuICovXG5jb25zdCBURU1QTEFUQUJMRV9GSUVMRFMgPSBbXG4gICdkZXNjcmlwdGlvbicsXG4gICdjb21tYW5kcycsIC8vIHN0cmluZ1tdXG4gICdpbnN0YWxsQ29tbWFuZHMnLCAvLyBzdHJpbmdbXVxuICAnZW52JywgLy8gUmVjb3JkPHN0cmluZywgc3RyaW5nPlxuICAnYnVpbGRBcmdzJywgLy8gUmVjb3JkPHN0cmluZywgc3RyaW5nPlxuXSBhcyBjb25zdDtcblxuZXhwb3J0IGZ1bmN0aW9uIGlzUGx1Z2luVGVtcGxhdGFibGVGaWVsZChmaWVsZDogc3RyaW5nKTogYm9vbGVhbiB7XG4gIC8vIGBjb21tYW5kc2AgLyBgaW5zdGFsbENvbW1hbmRzYCBhcmUgYXJyYXlzIG9mIHN0cmluZ3Mg4oaSIGVudHJpZXMgbGlrZSAnY29tbWFuZHNbMF0nXG4gIC8vIGBlbnZgIC8gYGJ1aWxkQXJnc2AgYXJlIG9iamVjdHMg4oaSIGVudHJpZXMgbGlrZSAnZW52LlNUQUdFJ1xuICByZXR1cm4gVEVNUExBVEFCTEVfRklFTERTLnNvbWUoZiA9PiBmaWVsZCA9PT0gZiB8fCBmaWVsZC5zdGFydHNXaXRoKGAke2Z9W2ApIHx8IGZpZWxkLnN0YXJ0c1dpdGgoYCR7Zn0uYCkpO1xufVxuXG4vKipcbiAqIFJldHVybiBhIHNoYWxsb3cgY2xvbmUgb2YgYHBsdWdpbmAgd2l0aCBhbGwgYHt7IC4uLiB9fWAgdGVtcGxhdGVzXG4gKiByZXNvbHZlZCBhZ2FpbnN0IHRoZSBnaXZlbiBwaXBlbGluZSBzY29wZS4gQ2FsbGVyIG11c3QgcHJlLXBvcHVsYXRlXG4gKiBgcGlwZWxpbmVTY29wZWAgd2l0aCBgeyBwaXBlbGluZSwgcGx1Z2luLCBlbnYgfWAga2V5cy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHJlc29sdmVQbHVnaW5UZW1wbGF0ZXMoXG4gIHBsdWdpbjogUGx1Z2luLFxuICBwaXBlbGluZVNjb3BlOiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPixcbik6IFBsdWdpbiB7XG4gIC8vIERlZXAgY2xvbmUgc28gbXV0YXRpb25zIGRvbid0IGxlYWsgYmFjayB0byB0aGUgY2FsbGVyJ3MgUGx1Z2luLlxuICAvLyBTdHJ1Y3R1cmFsIGZpZWxkcyB3ZSBjYXJlIGFib3V0IGFyZSBwbGFpbiBKU09OOyBzdHJ1Y3R1cmVkQ2xvbmUgaXMgc2FmZS5cbiAgY29uc3QgY2xvbmUgPSBzdHJ1Y3R1cmVkQ2xvbmUocGx1Z2luKSBhcyBQbHVnaW4gJiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPjtcblxuICBjb25zdCBzY29wZSA9IHtcbiAgICAuLi5waXBlbGluZVNjb3BlLFxuICAgIHBsdWdpbjogeyBuYW1lOiBwbHVnaW4ubmFtZSwgdmVyc2lvbjogcGx1Z2luLnZlcnNpb24gfSxcbiAgICBlbnY6IHBsdWdpbi5lbnYgPz8ge30sXG4gIH07XG5cbiAgY29uc3QgeyBlcnJvcnMgfSA9IHJlc29sdmVUZW1wbGF0ZXMoY2xvbmUsIHNjb3BlLCBpc1BsdWdpblRlbXBsYXRhYmxlRmllbGQsICdwbHVnaW4nKTtcbiAgaWYgKGVycm9ycy5sZW5ndGggPiAwKSB7XG4gICAgLy8gRmlyc3QgZXJyb3Igd2lucyDigJQgcmVzb2x2ZXIgZXJyb3JzIHNob3VsZCBuZXZlciBiZSBiYXRjaGVkIGF0IHN5bnRoIHRpbWVcbiAgICAvLyBiZWNhdXNlIGEgYnJva2VuIHRlbXBsYXRlIGlzIGEgcHJvZ3JhbW1lciBlcnJvciwgbm90IGEgdmFsaWRhdGlvbiBzdGVwLlxuICAgIGNvbnN0IGUgPSBlcnJvcnNbMF0hO1xuICAgIGNvbnN0IG1zZyA9IGBUZW1wbGF0ZSByZXNvbHV0aW9uIGZhaWxlZCBpbiBwbHVnaW4gXCIke3BsdWdpbi5uYW1lfVwiIGF0IGZpZWxkICcke2UuZmllbGR9JzogJHtlLm1lc3NhZ2V9YDtcbiAgICB0aHJvdyBuZXcgRXJyb3IobXNnKTtcbiAgfVxuICByZXR1cm4gY2xvbmU7XG59XG4iXX0=

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,233 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * 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 const MAX_FIELD_SIZE_BYTES = 4 * 1024;
+export const MAX_PATH_DEPTH = 5;
+export const MAX_IDENTIFIER_LENGTH = 64;
+export class TokenizerError extends Error {
+    pos;
+    constructor(message, pos) {
+        super(`${message} at line ${pos.line}, col ${pos.col}`);
+        this.pos = pos;
+        this.name = 'TokenizerError';
+    }
+}
+/**
+ * Tokenize a template source string. Never throws on valid input;
+ * throws `TokenizerError` with source position on malformed templates.
+ */
+export function tokenize(source) {
+    // Byte count, not `.length` (UTF-16 code units): the cap is stated in bytes,
+    // and multi-byte characters (emoji, non-ASCII) would otherwise be undercounted.
+    if (Buffer.byteLength(source, 'utf8') > MAX_FIELD_SIZE_BYTES) {
+        throw new TokenizerError(`Field exceeds max size of ${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(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 > MAX_IDENTIFIER_LENGTH) {
+            throw new TokenizerError(`Identifier exceeds max length of ${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 > MAX_PATH_DEPTH) {
+            throw new TokenizerError(`Path depth exceeds max of ${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.
+ */
+export 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  // Byte count, not `.length` (UTF-16 code units): the cap is stated in bytes,\n  // and multi-byte characters (emoji, non-ASCII) would otherwise be undercounted.\n  if (Buffer.byteLength(source, 'utf8') > 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(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"]}