minimal-agent 0.13.0 → 0.14.0

package/plugins/workflow-runner/src/expressions.ts

@@ -1,640 +0,0 @@
-/**
- * ============================================================
- *  plugins/workflow-runner/src/expressions.ts —— workflow 表达式引擎（mini）
- * ------------------------------------------------------------
- *  WHY 不直接 eval / Function？
- *    Workflow 来源不可信（用户编辑器生成 / 别人贡献的 yaml），允许任意
- *    JS 执行 = 任意远程代码执行。所以我们手写一个**只支持必要语法**的
- *    递归下降解析器：常量、变量引用、点路径、字符串/数字字面量、数组、
- *    比较、布尔运算、白名单内置函数。
- *
- *  支持的语法：
- *    expr    := or
- *    or      := and ( '||' and )*
- *    and     := not ( '&&' not )*
- *    not     := '!' not | comparison
- *    comparison := additive ( ('==' | '!=' | '>=' | '<=' | '>' | '<') additive )?
- *    additive := primary ( '+' primary )*        // number 相加 / 否则 stringify 后拼接
- *    primary := number | string | array | call | path | interp | '(' expr ')'
- *    array   := '[' expr (',' expr)* ']'
- *    call    := IDENT '(' expr (',' expr)* ')'   // 白名单
- *    path    := IDENT ('.' IDENT)*               // 变量 + 点路径
- *    interp  := '${' EXPR '}'                     // 取 EXPR 的"值"（任意类型，不字符串化）
- *    string  := "…" | '…'                         // 内嵌 ${EXPR} 走 template-literal 插值
- *
- *  白名单函数：fileExists / readJson / parseJson / asArray / length / lower / upper / includes /
- *              startsWith / endsWith / match / split / extract / join / json
- *
- *  ★ P2 根治：表达式上下文（when/condition/over/assert/vote.input）直接 evalExpr，
- *    不再"先 interpolate 再 eval"（旧双求值的 footgun 源头）。四种写法都 OK：
- *      裸 ${x} == 'y'   → ${x} 取值后比较（修掉旧 footgun：旧实现把 ${x} 替成裸字面量被当变量名）
- *      "a/${x}/b"       → 字符串字面量内插值拼路径（向后兼容旧 fileExists("…${x}…") 写法）
- *      "a/" + x + "/b"  → + 拼接（新增）
- *      x == 'y'         → 裸变量名（向后兼容）
- *    安全性也更好：变量的字符串内容不再被当作表达式二次执行（旧实现若插值结果落在引号外会被 eval）。
- *
- *  插值函数 interpolate(${EXPR}) 仍用于**模板上下文**（prompt / args / file_path）——
- *  把 EXPR 求值后 toString 替换；对象/数组用 JSON.stringify。interpolateDeep 递归处理对象/数组/字符串。
- * ============================================================
- */
-
-import { existsSync, readFileSync } from 'node:fs';
-import { join, isAbsolute } from 'node:path';
-
-import { getWorkingDir } from '../../../src/plugin-sdk.js';
-import { DANGEROUS_KEYS, isAbsWithinCwd, type VarStack } from './types.js';
-
-// ---------------- Tokenizer ----------------
-
-type Token =
-  | { kind: 'num'; value: number }
-  | { kind: 'str'; value: string }
-  | { kind: 'ident'; value: string }
-  | { kind: 'interp'; value: string }
-  | { kind: 'punct'; value: string };
-
-const PUNCT2 = new Set(['==', '!=', '>=', '<=', '&&', '||']);
-const PUNCT1 = new Set(['(', ')', '[', ']', ',', '.', '!', '>', '<', '+', '?', ':']);
-
-function tokenize(src: string): Token[] {
-  const out: Token[] = [];
-  let i = 0;
-  while (i < src.length) {
-    const c = src[i];
-    if (c === ' ' || c === '\t' || c === '\n' || c === '\r') {
-      i++;
-      continue;
-    }
-    // 独立 ${...} 取值 token。注意：字符串字面量内部的 ${} 不会到这里——
-    // 会被下面的字符串分支整体读进 str token，由 parsePrimary 在 eval 时插值。
-    if (c === '$' && src[i + 1] === '{') {
-      let depth = 1;
-      let j = i + 2;
-      while (j < src.length && depth > 0) {
-        if (src[j] === '{') depth++;
-        else if (src[j] === '}') depth--;
-        if (depth > 0) j++;
-      }
-      if (depth !== 0) throw new Error(`未闭合的 \${ 在表达式 "${src}"`);
-      out.push({ kind: 'interp', value: src.slice(i + 2, j) });
-      i = j + 1;
-      continue;
-    }
-    // 字符串
-    if (c === '"' || c === "'") {
-      const quote = c;
-      let s = '';
-      i++;
-      while (i < src.length && src[i] !== quote) {
-        if (src[i] === '\\' && i + 1 < src.length) {
-          const nx = src[i + 1];
-          s += nx === 'n' ? '\n' : nx === 't' ? '\t' : nx;
-          i += 2;
-        } else {
-          s += src[i++];
-        }
-      }
-      if (src[i] !== quote) throw new Error(`未闭合的字符串：${src}`);
-      i++;
-      out.push({ kind: 'str', value: s });
-      continue;
-    }
-    // 数字
-    if ((c >= '0' && c <= '9') || (c === '-' && src[i + 1] >= '0' && src[i + 1] <= '9')) {
-      let j = i;
-      if (src[j] === '-') j++;
-      while (j < src.length && ((src[j] >= '0' && src[j] <= '9') || src[j] === '.')) j++;
-      out.push({ kind: 'num', value: parseFloat(src.slice(i, j)) });
-      i = j;
-      continue;
-    }
-    // 双字符标点
-    const two = src.slice(i, i + 2);
-    if (PUNCT2.has(two)) {
-      out.push({ kind: 'punct', value: two });
-      i += 2;
-      continue;
-    }
-    // 单字符标点
-    if (PUNCT1.has(c)) {
-      out.push({ kind: 'punct', value: c });
-      i++;
-      continue;
-    }
-    // 标识符
-    if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c === '_') {
-      let j = i;
-      while (
-        j < src.length &&
-        ((src[j] >= 'a' && src[j] <= 'z') ||
-          (src[j] >= 'A' && src[j] <= 'Z') ||
-          (src[j] >= '0' && src[j] <= '9') ||
-          src[j] === '_')
-      ) {
-        j++;
-      }
-      out.push({ kind: 'ident', value: src.slice(i, j) });
-      i = j;
-      continue;
-    }
-    throw new Error(`非法字符 '${c}' 在表达式 "${src}"`);
-  }
-  return out;
-}
-
-// ---------------- Parser → AST → eval（一次性递归下降，零 AST 对象） ----------------
-
-interface Cursor {
-  toks: Token[];
-  pos: number;
-}
-
-function peek(c: Cursor): Token | null {
-  return c.pos < c.toks.length ? c.toks[c.pos] : null;
-}
-function eat(c: Cursor): Token {
-  return c.toks[c.pos++];
-}
-function isPunct(c: Cursor, v: string): boolean {
-  const t = peek(c);
-  return !!t && t.kind === 'punct' && t.value === v;
-}
-
-/**
- * 读磁盘的内置函数（fileExists / readJson）的锚点。
- * 必须和写入侧同源：进了 session worktree 后产物落在 worktree 里，
- * 这里若仍锚原 workspace，done_when 会在空目录里找文件而恒判 false。
- */
-function cwdOf(vars: VarStack): string {
-  return vars.resolveCwd?.() ?? getWorkingDir();
-}
-
-const BUILTINS: Record<string, (args: unknown[], cwd: string) => unknown> = {
-  fileExists(args, cwd) {
-    const p = String(args[0] ?? '');
-    if (!p) return false;
-    const abs = isAbsolute(p) ? p : join(cwd, p);
-    // 安全守卫：越出 cwd 的路径视为"不存在"（fail-closed，与 readJson 同策略）。
-    // 不可信 YAML（模板库/他人分享）可能带 fileExists('/etc/passwd') 做信息刺探，
-    // 这里与 cleanupDeclaredArtifacts 保持一致：只允许操作 cwd 下的文件。
-    if (!isAbsWithinCwd(cwd, abs)) return false;
-    return existsSync(abs);
-  },
-  length(args) {
-    const v = args[0];
-    if (typeof v === 'string' || Array.isArray(v)) return v.length;
-    if (v && typeof v === 'object') return Object.keys(v).length;
-    return 0;
-  },
-  // 把可选 JSON 数组标准化为 for-each loop 可消费的数组。用于
-  // over: "${asArray(readJson('manifest.json', 'images'))}" 这类场景：
-  // 缺文件/缺字段/null 表示 0 轮；但对象/字符串等结构错误要响亮失败，
-  // 避免把坏 manifest 静默吞掉。
-  asArray(args) {
-    const v = args[0];
-    if (Array.isArray(v)) return v;
-    if (v === null || v === undefined) return [];
-    throw new Error(`asArray 期望数组/null/undefined，得到 ${Array.isArray(v) ? 'array' : typeof v}`);
-  },
-  lower(args) {
-    return String(args[0] ?? '').toLowerCase();
-  },
-  upper(args) {
-    return String(args[0] ?? '').toUpperCase();
-  },
-  includes(args) {
-    const haystack = String(args[0] ?? '');
-    const needle = String(args[1] ?? '');
-    return haystack.includes(needle);
-  },
-  startsWith(args) {
-    const s = String(args[0] ?? '');
-    const prefix = String(args[1] ?? '');
-    return s.startsWith(prefix);
-  },
-  endsWith(args) {
-    const s = String(args[0] ?? '');
-    const suffix = String(args[1] ?? '');
-    return s.endsWith(suffix);
-  },
-  match(args) {
-    const s = String(args[0] ?? '');
-    const pattern = String(args[1] ?? '');
-    try {
-      const re = new RegExp(pattern);
-      return re.test(s);
-    } catch {
-      return false; // 非法正则 → 不匹配
-    }
-  },
-  split(args) {
-    const s = String(args[0] ?? '');
-    const delim = args[1] !== undefined ? String(args[1]) : ',';
-    return s.split(delim);
-  },
-  // 全局正则提取：返回匹配数组。有捕获组取 group 1（典型：提取 <tag>(.*?)</tag> 内容），
-  // 否则取全匹配。flags 固定 gs（跨行 . 匹配）；非法正则返回 []（与 match 同哲学：不抛）。
-  // 动机：从 agent/llm 输出里确定性抽取协议标签（如 <learning>…</learning>），
-  // 替代「再开一个 LLM 步去提取」的幻觉/改写风险。
-  extract(args) {
-    const s = String(args[0] ?? '');
-    const pattern = String(args[1] ?? '');
-    if (!pattern) return [];
-    try {
-      const re = new RegExp(pattern, 'gs');
-      const out: string[] = [];
-      for (const m of s.matchAll(re)) {
-        out.push(m[1] !== undefined ? m[1] : m[0]);
-      }
-      return out;
-    } catch {
-      return [];
-    }
-  },
-  // 数组拼接成字符串；非数组按 stringify 兜底。与 extract 配对使用。
-  join(args) {
-    const v = args[0];
-    const sep = args[1] !== undefined ? String(args[1]) : ',';
-    if (Array.isArray(v)) return v.map((x) => stringify(x)).join(sep);
-    return stringify(v);
-  },
-  // JSON.stringify 安全嵌入：值含引号/换行时拼 JSON 文件不产坏文档
-  // （模板里写 "k": ${json(v)}，外层引号由 json() 自己生成）。
-  json(args) {
-    try {
-      return JSON.stringify(args[0] ?? null);
-    } catch {
-      return 'null';
-    }
-  },
-  // 读磁盘 JSON 文件并取值：path 相对当前有效 cwd（绝对路径先经 cwd 安全校验，
-  // 越界直接 null，与 fileExists 同 fail-closed 策略）；给了 key 则返回顶层
-  // obj[key]，否则返回整值。缺文件 / 坏 JSON / 键不存在 / 越界 → null
-  //（与 match/extract 同「不抛」哲学）。动机：让确定性脚本产出的 manifest
-  //（如 source_assets.json）直接驱动工作流 for-each / branch —— 填补「磁盘
-  // 结构化数据 → 控制流」的空白（与 fileExists 平级的基础能力）。
-  readJson(args, cwd) {
-    const p = String(args[0] ?? '');
-    if (!p) return null;
-    const abs = isAbsolute(p) ? p : join(cwd, p);
-    if (!isAbsWithinCwd(cwd, abs)) return null; // 越界 → null（不抛，fail-closed）
-    try {
-      // 剥前导 BOM：某些工具/重定向写出的 JSON 带 BOM，JSON.parse 会因此抛错。
-      let raw = readFileSync(abs, 'utf8');
-      if (raw.charCodeAt(0) === 0xfeff) raw = raw.slice(1);
-      const val = JSON.parse(raw);
-      if (args.length >= 2) {
-        const key = String(args[1] ?? '');
-        return val != null && typeof val === 'object' ? (val[key] ?? null) : null;
-      }
-      return val;
-    } catch {
-      return null;
-    }
-  },
-  // 解析 JSON 字符串成值（与 readJson 平级，但源是**字符串**而非文件）：剥前导 BOM、
-  // trim、JSON.parse；非字符串 / 空 / 坏 JSON → null（同 match/extract/readJson「不抛」哲学）。
-  // 动机：把 WebBrowser eval / agent / 工具 capture 到的 JSON 文本变成数组/对象，
-  // 直接驱动 loop over / branch —— 填补「字符串结构化数据 → 控制流」的空白
-  //（配 asArray 用：over: "${asArray(parseJson(urls_json))}"）。
-  parseJson(args) {
-    const v = args[0];
-    if (typeof v !== 'string') return null;
-    let raw = v.charCodeAt(0) === 0xfeff ? v.slice(1) : v;
-    raw = raw.trim();
-    if (!raw) return null;
-    try {
-      return JSON.parse(raw);
-    } catch {
-      return null;
-    }
-  },
-};
-
-function parseOr(c: Cursor, vars: VarStack): unknown {
-  let left = parseAnd(c, vars);
-  while (isPunct(c, '||')) {
-    eat(c);
-    const right = parseAnd(c, vars);
-    left = truthy(left) || truthy(right);
-  }
-  return left;
-}
-
-// 三元表达式：cond ? true_expr : false_expr
-// 优先级低于 ||（即先算完 || 再判断 ? :）
-// 右结合：a ? b ? c : d : e 等价于 a ? (b ? c : d) : e
-function parseTernary(c: Cursor, vars: VarStack): unknown {
-  const cond = parseOr(c, vars);
-  if (!isPunct(c, '?')) return cond;
-  eat(c); // 吃掉 '?'
-  const consequent = parseTernary(c, vars); // 右结合：true 分支可以是嵌套三元
-  if (!isPunct(c, ':')) throw new Error("三元表达式缺少 ':'");
-  eat(c); // 吃掉 ':'
-  const alternate = parseTernary(c, vars); // 右结合：false 分支也可以是嵌套三元
-  return truthy(cond) ? consequent : alternate;
-}
-function parseAnd(c: Cursor, vars: VarStack): unknown {
-  let left = parseNot(c, vars);
-  while (isPunct(c, '&&')) {
-    eat(c);
-    const right = parseNot(c, vars);
-    left = truthy(left) && truthy(right);
-  }
-  return left;
-}
-function parseNot(c: Cursor, vars: VarStack): unknown {
-  if (isPunct(c, '!')) {
-    eat(c);
-    return !truthy(parseNot(c, vars));
-  }
-  return parseComparison(c, vars);
-}
-function parseComparison(c: Cursor, vars: VarStack): unknown {
-  const left = parseAdditive(c, vars);
-  const t = peek(c);
-  if (t && t.kind === 'punct' && ['==', '!=', '>=', '<=', '>', '<'].includes(t.value)) {
-    eat(c);
-    const right = parseAdditive(c, vars);
-    switch (t.value) {
-      case '==':
-        // eslint-disable-next-line eqeqeq
-        return left == right;
-      case '!=':
-        // eslint-disable-next-line eqeqeq
-        return left != right;
-      case '>':
-        return (left as number) > (right as number);
-      case '<':
-        return (left as number) < (right as number);
-      case '>=':
-        return (left as number) >= (right as number);
-      case '<=':
-        return (left as number) <= (right as number);
-    }
-  }
-  return left;
-}
-// 加法/拼接层：number + number → 相加；否则两边 stringify 后字符串拼接。
-// 表达式语言原本无拼接符，导致拼路径只能"先插值再 eval"（footgun 源头）；
-// 有了 + 之后可写 fileExists("videos/" + inputs.book + "/x") 这种纯表达式。
-function parseAdditive(c: Cursor, vars: VarStack): unknown {
-  let left = parsePrimary(c, vars);
-  while (isPunct(c, '+')) {
-    eat(c);
-    const right = parsePrimary(c, vars);
-    left = addValues(left, right);
-  }
-  return left;
-}
-
-function addValues(l: unknown, r: unknown): unknown {
-  if (typeof l === 'number' && typeof r === 'number') return l + r;
-  return stringify(l) + stringify(r);
-}
-function parsePrimary(c: Cursor, vars: VarStack): unknown {
-  const t = peek(c);
-  if (!t) throw new Error('表达式意外结束');
-
-  if (t.kind === 'punct' && t.value === '(') {
-    eat(c);
-    // 括号内是完整表达式（含三元）——曾只递归 parseOr，(a ? b : c) 报「缺少 ')'」
-    const v = parseTernary(c, vars);
-    if (!isPunct(c, ')')) throw new Error("缺少 ')'");
-    eat(c);
-    return v;
-  }
-  if (t.kind === 'punct' && t.value === '[') {
-    eat(c);
-    const arr: unknown[] = [];
-    if (!isPunct(c, ']')) {
-      arr.push(parseTernary(c, vars));
-      while (isPunct(c, ',')) {
-        eat(c);
-        arr.push(parseTernary(c, vars));
-      }
-    }
-    if (!isPunct(c, ']')) throw new Error("缺少 ']'");
-    eat(c);
-    return arr;
-  }
-  if (t.kind === 'num') {
-    eat(c);
-    return t.value;
-  }
-  if (t.kind === 'str') {
-    eat(c);
-    // 字符串字面量支持内嵌 ${...} 插值（template-literal 语义）：
-    // fileExists("videos/${inputs.book}/x") 不必预插值也能工作。无 ${} 时原样返回。
-    return interpolate(t.value, vars);
-  }
-  if (t.kind === 'interp') {
-    eat(c);
-    // 独立 ${EXPR}：求值为 EXPR 的"值"（任意类型，不字符串化）。
-    // 修掉"裸 ${x} == 'y' 被当成变量名 x"的 footgun。
-    return evalExpr(t.value, vars);
-  }
-  if (t.kind === 'ident') {
-    eat(c);
-    // 函数调用？
-    if (isPunct(c, '(')) {
-      eat(c);
-      const argv: unknown[] = [];
-      if (!isPunct(c, ')')) {
-        argv.push(parseTernary(c, vars));
-        while (isPunct(c, ',')) {
-          eat(c);
-          argv.push(parseTernary(c, vars));
-        }
-      }
-      if (!isPunct(c, ')')) throw new Error("缺少 ')'");
-      eat(c);
-      const fn = BUILTINS[t.value];
-      if (!fn) throw new Error(`未知函数 "${t.value}"。白名单：${Object.keys(BUILTINS).join(', ')}`);
-      return fn(argv, cwdOf(vars));
-    }
-    // 字面常量
-    if (t.value === 'true') return true;
-    if (t.value === 'false') return false;
-    if (t.value === 'null') return null;
-    // 变量 + 点路径
-    let cur: unknown = vars.get(t.value);
-    while (isPunct(c, '.')) {
-      eat(c);
-      const next = eat(c);
-      if (next.kind !== 'ident') throw new Error('点号后必须是标识符');
-      // S1：禁止经点路径访问原型链（__proto__ / constructor / prototype），防原型污染 / 函数对象逃逸。
-      if (
-        next.value === '__proto__' ||
-        next.value === 'constructor' ||
-        next.value === 'prototype'
-      ) {
-        cur = undefined;
-      } else {
-        cur =
-          cur != null && typeof cur === 'object'
-            ? (cur as Record<string, unknown>)[next.value]
-            : undefined;
-      }
-    }
-    return cur;
-  }
-  throw new Error(`无法解析 token: ${JSON.stringify(t)}`);
-}
-
-function truthy(v: unknown): boolean {
-  if (v === null || v === undefined) return false;
-  if (typeof v === 'boolean') return v;
-  if (typeof v === 'number') return v !== 0 && !Number.isNaN(v);
-  if (typeof v === 'string') return v.length > 0;
-  if (Array.isArray(v)) return v.length > 0;
-  if (typeof v === 'object') return Object.keys(v).length > 0;
-  return true;
-}
-
-// ---------------- 对外 API ----------------
-
-/** 计算表达式（裸的，不带 ${} 包裹）。失败抛错。 */
-export function evalExpr(expr: string, vars: VarStack): unknown {
-  const toks = tokenize(expr);
-  if (toks.length === 0) return undefined;
-  const cursor: Cursor = { toks, pos: 0 };
-  const v = parseTernary(cursor, vars);
-  if (cursor.pos !== toks.length) {
-    throw new Error(`表达式多余 token: "${expr}"`);
-  }
-  return v;
-}
-
-/**
- * interpolate / interpolateDeep 的可选项。
- * onMissing：某个 ${EXPR} 求值为 undefined（变量不存在/点路径落空）时回调。
- * 设计动机：未定义变量静默插成空串是 ralph-loop 裸 ${goal} 渲染为空的病根——
- * 引擎不能猜作者意图（undefined 可能是合法的可选值），但**必须可见化**；
- * 执行器收集后 yield 一条 warning（含表达式原文），作者一眼定位拼写/命名空间错误。
- */
-export interface InterpolateOptions {
-  onMissing?: (expr: string) => void;
-}
-
-/**
- * 字符串插值：把 "${EXPR}" 替换成 EXPR 求值结果。
- * 多个 ${} 串联也支持。括号配对识别 —— "${ ${nested} }" 会被当成一个外层
- * EXPR（内部 ${nested} 文本原样，但表达式里不允许 ${} 语法，所以会报错）。
- *
- * 转义：`\$` → 字面 $，跳过插值。
- */
-export function interpolate(
-  template: string,
-  vars: VarStack,
-  opts?: InterpolateOptions,
-): string {
-  let out = '';
-  let i = 0;
-  while (i < template.length) {
-    const c = template[i];
-    if (c === '\\' && template[i + 1] === '$') {
-      out += '$';
-      i += 2;
-      continue;
-    }
-    if (c === '$' && template[i + 1] === '{') {
-      // 找匹配的 '}'
-      let depth = 1;
-      let j = i + 2;
-      while (j < template.length && depth > 0) {
-        if (template[j] === '{') depth++;
-        else if (template[j] === '}') depth--;
-        if (depth > 0) j++;
-      }
-      if (depth !== 0) {
-        // 不匹配；原样输出
-        out += template.slice(i);
-        return out;
-      }
-      const expr = template.slice(i + 2, j);
-      const v = evalExpr(expr, vars);
-      if (v === undefined) opts?.onMissing?.(expr);
-      out += stringify(v);
-      i = j + 1;
-      continue;
-    }
-    out += c;
-    i++;
-  }
-  return out;
-}
-
-/**
- * 类型保留插值：模板整串恰好是单一 "${EXPR}" 时直接返回 EXPR 的值
- * （布尔/数字/数组原样，不字符串化）；多片段模板退回普通 interpolate。
- * 非字符串值原样透传（与 interpolateDeep 对非字符串的行为一致）。
- *
- * 动机：set 步写 `flag: "${qualified}"` 曾被字符串化成 "true"，逼出下游
- * 满篇 `== true || == 'true'` 防御——单表达式赋值就该保住类型。
- */
-export function interpolateTyped(
-  value: unknown,
-  vars: VarStack,
-  opts?: InterpolateOptions,
-): unknown {
-  if (typeof value !== 'string') return value;
-  const expr = singleExprOf(value);
-  if (expr === null) return interpolate(value, vars, opts);
-  const v = evalExpr(expr, vars);
-  if (v === undefined) opts?.onMissing?.(expr);
-  return v;
-}
-
-/** 整串恰好是一个 "${EXPR}"（括号配对到串尾）时返回内层 EXPR，否则 null。 */
-function singleExprOf(template: string): string | null {
-  if (!template.startsWith('${') || !template.endsWith('}')) return null;
-  let depth = 1;
-  for (let j = 2; j < template.length; j++) {
-    if (template[j] === '{') depth++;
-    else if (template[j] === '}') {
-      depth--;
-      // 提前归零 = 中途闭合（如 "${a}-${b}"），不是单一表达式
-      if (depth === 0) return j === template.length - 1 ? template.slice(2, j) : null;
-    }
-  }
-  return null;
-}
-
-function stringify(v: unknown): string {
-  if (v === null || v === undefined) return '';
-  if (typeof v === 'string') return v;
-  if (typeof v === 'number' || typeof v === 'boolean') return String(v);
-  try {
-    return JSON.stringify(v);
-  } catch {
-    return String(v);
-  }
-}
-
-/** 递归对对象/数组/字符串做插值；其它原样返回。 */
-export function interpolateDeep<T>(
-  value: T,
-  vars: VarStack,
-  opts?: InterpolateOptions,
-): T {
-  if (typeof value === 'string') {
-    return interpolate(value, vars, opts) as unknown as T;
-  }
-  if (Array.isArray(value)) {
-    return value.map((v) => interpolateDeep(v, vars, opts)) as unknown as T;
-  }
-  if (value && typeof value === 'object') {
-    const out: Record<string, unknown> = {};
-    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
-      // 注意：key 也插值（loop 里 `hook_${idx}` 这种），但只对字符串 key 有意义；
-      // 插值后的 key 若命中危险键（__proto__/constructor/prototype）→ 直接跳过不写，
-      // 防止经动态 key 注入原型链属性（与 VarStack 防线保持一致）。
-      const newKey = interpolate(k, vars, opts);
-      if (DANGEROUS_KEYS.has(newKey)) continue;
-      out[newKey] = interpolateDeep(v, vars, opts);
-    }
-    return out as unknown as T;
-  }
-  return value;
-}