weifuwu 0.90.0 → 0.91.0

package/dist/server/workflow/index.js

@@ -0,0 +1,2476 @@
+// src/server/workflow/std.ts
+function requireArgs(name, args, n) {
+  if (args.length !== n) throw new Error(`std.${name}: \u671F\u671B ${n} \u4E2A\u53C2\u6570\uFF0C\u6536\u5230 ${args.length}`);
+}
+function toNum(name, v, pos) {
+  const n = Number(v);
+  if (!Number.isFinite(n)) throw new Error(`std.${name}: \u53C2\u6570 ${pos + 1} \u4E0D\u662F\u6709\u9650\u6570\u5B57\uFF08${String(v)}\uFF09`);
+  return n;
+}
+var math = {
+  sum: (a) => {
+    requireArgs("sum", a, 1);
+    const xs = a[0];
+    if (!Array.isArray(xs)) throw new Error("std.sum: \u671F\u671B\u6570\u7EC4");
+    return xs.reduce((acc, v) => acc + toNum("sum", v, 0), 0);
+  },
+  avg: (a) => {
+    requireArgs("avg", a, 1);
+    const xs = a[0];
+    if (!Array.isArray(xs)) throw new Error("std.avg: \u671F\u671B\u6570\u7EC4");
+    if (xs.length === 0) throw new Error("std.avg: \u7A7A\u6570\u7EC4");
+    return xs.reduce((acc, v) => acc + toNum("avg", v, 0), 0) / xs.length;
+  },
+  clamp: (a) => {
+    requireArgs("clamp", a, 3);
+    const v = toNum("clamp", a[0], 0);
+    const lo = toNum("clamp", a[1], 1);
+    const hi = toNum("clamp", a[2], 2);
+    if (lo > hi) throw new Error("std.clamp: lo > hi");
+    return Math.min(hi, Math.max(lo, v));
+  }
+};
+var strings = {
+  upper: (a) => {
+    requireArgs("upper", a, 1);
+    if (typeof a[0] !== "string") throw new Error(`std.upper: \u671F\u671B\u5B57\u7B26\u4E32\uFF08${String(a[0])}\uFF09`);
+    return a[0].toUpperCase();
+  },
+  lower: (a) => {
+    requireArgs("lower", a, 1);
+    if (typeof a[0] !== "string") throw new Error(`std.lower: \u671F\u671B\u5B57\u7B26\u4E32\uFF08${String(a[0])}\uFF09`);
+    return a[0].toLowerCase();
+  },
+  join: (a) => {
+    requireArgs("join", a, 2);
+    if (!Array.isArray(a[0]) || typeof a[1] !== "string") throw new Error("std.join: \u671F\u671B(\u6570\u7EC4, \u5206\u9694\u7B26)");
+    return a[0].map((v) => String(v)).join(a[1]);
+  },
+  split: (a) => {
+    requireArgs("split", a, 2);
+    if (typeof a[0] !== "string" || typeof a[1] !== "string") throw new Error("std.split: \u671F\u671B(\u5B57\u7B26\u4E32, \u5206\u9694\u7B26)");
+    return a[0].split(a[1]);
+  }
+};
+var collections = {
+  count: (a) => {
+    requireArgs("count", a, 1);
+    if (Array.isArray(a[0])) return a[0].length;
+    if (typeof a[0] === "string") return a[0].length;
+    throw new Error(`std.count: \u671F\u671B\u6570\u7EC4\u6216\u5B57\u7B26\u4E32\uFF08${String(a[0])}\uFF09`);
+  },
+  pick: (a) => {
+    requireArgs("pick", a, 2);
+    if (!Array.isArray(a[0])) throw new Error("std.pick: \u671F\u671B\u6570\u7EC4");
+    const i = toNum("pick", a[1], 1);
+    if (!Number.isInteger(i) || i < 0 || i >= a[0].length) throw new Error(`std.pick: \u7D22\u5F15 ${i} \u8D8A\u754C\uFF08\u957F\u5EA6 ${a[0].length}\uFF09`);
+    return a[0][i];
+  }
+};
+var STD_MODULES = {
+  "wf://std/math": math,
+  "wf://std/strings": strings,
+  "wf://std/collections": collections
+};
+var STD_FNS = { ...math, ...strings, ...collections };
+var STD_NAMES = Object.keys(STD_FNS);
+
+// src/server/workflow/expression.ts
+var IDENT = /[A-Za-z_$][A-Za-z0-9_$]*/;
+var NUM = /[0-9]+(?:\.[0-9]+)?/;
+var THREE_CHAR_OPS = ["===", "!=="];
+var TWO_CHAR_OPS = ["==", "!=", "&&", "||", "<=", ">="];
+var ONE_CHAR_OPS = ["!", "+", "-", "*", "/", "%", "<", ">", "?"];
+function tokenize(src) {
+  const tokens = [];
+  let i = 0;
+  const n = src.length;
+  while (i < n) {
+    const ch = src[i];
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      const quote = ch;
+      let j = i + 1;
+      let out = "";
+      while (j < n && src[j] !== quote) {
+        if (src[j] === "\\") {
+          const esc = src[j + 1];
+          if (esc === "\\" || esc === quote) {
+            out += esc;
+            j += 2;
+            continue;
+          }
+          if (esc === "n") {
+            out += "\n";
+            j += 2;
+            continue;
+          }
+          if (esc === "t") {
+            out += "	";
+            j += 2;
+            continue;
+          }
+          throw new Error(`expression: invalid escape '\\${esc ?? ""}' at ${j} (in ${JSON.stringify(src)})`);
+        }
+        out += src[j];
+        j++;
+      }
+      if (j >= n) throw new Error(`expression: unterminated string (in ${JSON.stringify(src)})`);
+      tokens.push({ t: "str", v: out, pos: i });
+      i = j + 1;
+      continue;
+    }
+    const three = src.slice(i, i + 3);
+    if (THREE_CHAR_OPS.includes(three)) {
+      tokens.push({ t: "op", v: three, pos: i });
+      i += 3;
+      continue;
+    }
+    const two = src.slice(i, i + 2);
+    if (TWO_CHAR_OPS.includes(two)) {
+      tokens.push({ t: "op", v: two, pos: i });
+      i += 2;
+      continue;
+    }
+    if (ONE_CHAR_OPS.includes(ch)) {
+      tokens.push({ t: "op", v: ch, pos: i });
+      i++;
+      continue;
+    }
+    if (ch === "." || ch === "[" || ch === "]" || ch === "(" || ch === ")" || ch === "," || ch === ":") {
+      tokens.push({ t: "punc", v: ch, pos: i });
+      i++;
+      continue;
+    }
+    if (ch >= "0" && ch <= "9") {
+      const m2 = NUM.exec(src.slice(i));
+      if (!m2) throw new Error(`expression: invalid number at ${i} (in ${JSON.stringify(src)})`);
+      tokens.push({ t: "num", v: Number(m2[0]), pos: i });
+      i += m2[0].length;
+      continue;
+    }
+    const m = IDENT.exec(src.slice(i));
+    if (m) {
+      tokens.push({ t: "ident", v: m[0], pos: i });
+      i += m[0].length;
+      continue;
+    }
+    throw new Error(`expression: unexpected character '${ch}' at ${i} (in ${JSON.stringify(src)})`);
+  }
+  tokens.push({ t: "eof", pos: n });
+  return tokens;
+}
+var Parser = class {
+  i = 0;
+  tokens;
+  src;
+  depth = 0;
+  constructor(tokens, src) {
+    this.tokens = tokens;
+    this.src = src;
+  }
+  peek() {
+    return this.tokens[this.i];
+  }
+  next() {
+    return this.tokens[this.i++];
+  }
+  fail(msg, pos) {
+    throw new Error(`${msg} at ${pos} (in ${JSON.stringify(this.src)})`);
+  }
+  expectPunc(v) {
+    const tk = this.next();
+    if (tk.t !== "punc" || tk.v !== v) this.fail(`expression: expected '${v}'`, tk.pos);
+  }
+  parse() {
+    const node = this.parseTernary();
+    const tk = this.peek();
+    if (tk.t !== "eof") this.fail(`expression: unexpected '${String(tk.v)}'`, tk.pos);
+    return node;
+  }
+  /** 三元（最低优先级）：cond ? then : else */
+  parseTernary() {
+    if (++this.depth > 65) this.fail("expression: nested expression too deep (max 64 \u5C42)", this.peek().pos);
+    try {
+      return this.parseTernaryInner();
+    } finally {
+      this.depth--;
+    }
+  }
+  parseTernaryInner() {
+    const cond = this.parseOr();
+    const tk = this.peek();
+    if (tk.t === "op" && tk.v === "?") {
+      this.next();
+      const then = this.parseTernary();
+      const col = this.next();
+      if (col.t !== "punc" || col.v !== ":") this.fail(`expression: expected ':' in ternary`, col.pos);
+      const else_ = this.parseTernary();
+      return { kind: "ternary", cond, then, else: else_ };
+    }
+    return cond;
+  }
+  parseOr() {
+    let left = this.parseAnd();
+    while (this.isOp("||")) {
+      this.next();
+      left = { kind: "or", left, right: this.parseAnd() };
+    }
+    return left;
+  }
+  parseAnd() {
+    let left = this.parseCmp();
+    while (this.isOp("&&")) {
+      this.next();
+      left = { kind: "and", left, right: this.parseCmp() };
+    }
+    return left;
+  }
+  parseCmp() {
+    const left = this.parseArith();
+    const tk = this.peek();
+    if (tk.t === "op" && ["==", "!=", "===", "!==", "<", "<=", ">", ">="].includes(tk.v)) {
+      this.next();
+      return { kind: "compare", op: tk.v, left, right: this.parseArith() };
+    }
+    return left;
+  }
+  parseArith() {
+    let left = this.parseTerm();
+    while (this.isOp("+") || this.isOp("-")) {
+      const op = this.next().v;
+      left = { kind: "arith", op, left, right: this.parseTerm() };
+    }
+    return left;
+  }
+  parseTerm() {
+    let left = this.parseUnary();
+    while (this.isOp("*") || this.isOp("/") || this.isOp("%")) {
+      const op = this.next().v;
+      left = { kind: "arith", op, left, right: this.parseUnary() };
+    }
+    return left;
+  }
+  isOp(v) {
+    const tk = this.peek();
+    return tk.t === "op" && tk.v === v;
+  }
+  parseUnary() {
+    const tk = this.peek();
+    if (tk.t === "op" && tk.v === "!") {
+      this.next();
+      return { kind: "not", operand: this.parseUnary() };
+    }
+    if (tk.t === "op" && tk.v === "-") {
+      this.next();
+      return { kind: "neg", operand: this.parseUnary() };
+    }
+    return this.parseAtom();
+  }
+  parseAtom() {
+    const tk = this.peek();
+    if (tk.t === "punc" && tk.v === "(") {
+      this.next();
+      const inner = this.parseTernary();
+      this.expectPunc(")");
+      return inner;
+    }
+    if (tk.t === "num") {
+      this.next();
+      return { kind: "literal", value: tk.v };
+    }
+    if (tk.t === "str") {
+      this.next();
+      return { kind: "literal", value: tk.v };
+    }
+    if (tk.t === "ident") {
+      const kw = tk.v;
+      if (kw === "null" || kw === "true" || kw === "false") {
+        this.next();
+        return { kind: "literal", value: kw === "null" ? null : kw === "true" };
+      }
+      const path = this.parsePath();
+      const after = this.peek();
+      if (path.kind === "path" && after.t === "punc" && after.v === "(") {
+        this.next();
+        const args = [];
+        if (!this.isPunc2(")")) {
+          for (; ; ) {
+            args.push(this.parseTernary());
+            if (this.isPunc2(",")) {
+              this.next();
+              continue;
+            }
+            break;
+          }
+        }
+        this.expectPunc(")");
+        return { kind: "call", name: path.segments[0], args };
+      }
+      return path;
+    }
+    this.fail(`expression: unexpected '${tk.t === "eof" ? "(end)" : String(tk.v)}'`, tk.pos);
+  }
+  isPunc2(v) {
+    const tk = this.peek();
+    return tk.t === "punc" && tk.v === v;
+  }
+  parsePath() {
+    const segments = [];
+    const first = this.next();
+    if (first.t !== "ident") this.fail(`expression: expected path`, first.pos);
+    segments.push(first.v);
+    for (; ; ) {
+      const tk = this.peek();
+      if (tk.t === "punc" && tk.v === ".") {
+        this.next();
+        const seg = this.next();
+        if (seg.t !== "ident") this.fail(`expression: expected property after '.'`, seg.pos);
+        segments.push(seg.v);
+        continue;
+      }
+      if (tk.t === "punc" && tk.v === "[") {
+        this.next();
+        const inner = this.next();
+        if (inner.t === "op" && inner.v === "*") {
+          this.expectPunc("]");
+          segments.push("*");
+          continue;
+        }
+        if (inner.t !== "num" || !Number.isInteger(inner.v)) this.fail(`expression: expected integer index or '*' in '[]'`, inner.pos);
+        this.expectPunc("]");
+        segments.push(inner.v);
+        continue;
+      }
+      break;
+    }
+    return { kind: "path", segments };
+  }
+};
+function parse(src) {
+  return new Parser(tokenize(src), src).parse();
+}
+function getPath(root, segments) {
+  function rest(cur, i) {
+    const seg = segments[i];
+    if (seg === void 0) return cur;
+    if (cur === null || cur === void 0) return void 0;
+    if (seg === "*") {
+      if (!Array.isArray(cur)) return [];
+      const out = [];
+      for (const el of cur) {
+        const v = rest(el, i + 1);
+        if (Array.isArray(v)) out.push(...v);
+        else if (v !== void 0) out.push(v);
+      }
+      return out;
+    }
+    let next;
+    if (typeof seg === "number") {
+      next = Array.isArray(cur) ? cur[seg] : void 0;
+    } else if (seg === "length") {
+      if (Array.isArray(cur)) next = cur.length;
+      else if (typeof cur === "string") next = cur.length;
+      else if (typeof cur === "object") next = cur[seg];
+      else next = void 0;
+    } else if (typeof cur === "object") {
+      next = cur[seg];
+    } else {
+      next = void 0;
+    }
+    return rest(next, i + 1);
+  }
+  return rest(root, 0);
+}
+function arith(op, l, r) {
+  if (typeof l !== "number" || typeof r !== "number") {
+    throw new Error(`expression: arithmetic '${op}' requires numbers (got ${typeName(l)} ${op} ${typeName(r)})`);
+  }
+  let out;
+  switch (op) {
+    case "+":
+      out = l + r;
+      break;
+    case "-":
+      out = l - r;
+      break;
+    case "*":
+      out = l * r;
+      break;
+    case "/":
+      out = l / r;
+      break;
+    case "%":
+      out = l % r;
+      break;
+  }
+  if (!Number.isFinite(out)) throw new Error(`expression: arithmetic '${op}' produced non-finite result`);
+  return out;
+}
+function typeName(v) {
+  if (v === null) return "null";
+  if (Array.isArray(v)) return "array";
+  return typeof v;
+}
+function evaluate(node, ctx, fns) {
+  switch (node.kind) {
+    case "path":
+      return getPath(ctx, node.segments);
+    case "literal":
+      return node.value;
+    case "neg": {
+      const v = evaluate(node.operand, ctx, fns);
+      if (typeof v !== "number") throw new Error(`expression: unary '-' requires number (got ${typeName(v)})`);
+      return -v;
+    }
+    case "arith":
+      return arith(node.op, evaluate(node.left, ctx, fns), evaluate(node.right, ctx, fns));
+    case "ternary":
+      return evaluateBoolean(node.cond, ctx, fns) ? evaluate(node.then, ctx, fns) : evaluate(node.else, ctx, fns);
+    case "call": {
+      if (!fns?.[node.name]) throw new Error(`expression: \u672A\u6CE8\u518C\u51FD\u6570 '${node.name}'\uFF08std \u7EAF\u51FD\u6570\uFF1A${STD_NAMES.join("/")}\uFF09`);
+      return fns[node.name](node.args.map((a) => evaluate(a, ctx, fns)));
+    }
+    case "compare": {
+      const l = evaluate(node.left, ctx, fns);
+      const r = evaluate(node.right, ctx, fns);
+      switch (node.op) {
+        // 宽松相等（JS 语义）
+        // eslint-disable-next-line eqeqeq
+        case "==":
+          return l == r;
+        // eslint-disable-next-line eqeqeq
+        case "!=":
+          return !(l == r);
+        // 严格相等（JS === 语义——不类型转换）
+        case "===":
+          return l === r;
+        case "!==":
+          return l !== r;
+        case "<":
+          return l < r;
+        case "<=":
+          return l <= r;
+        case ">":
+          return l > r;
+        case ">=":
+          return l >= r;
+      }
+    }
+    case "not":
+      return !toBoolean(evaluate(node.operand, ctx, fns));
+    // JS 语义：返回操作数（非 boolean 包装）
+    case "and": {
+      const l = evaluate(node.left, ctx, fns);
+      return toBoolean(l) ? evaluate(node.right, ctx, fns) : l;
+    }
+    case "or": {
+      const l = evaluate(node.left, ctx, fns);
+      return toBoolean(l) ? l : evaluate(node.right, ctx, fns);
+    }
+  }
+}
+function toBoolean(v) {
+  return Boolean(v);
+}
+function evaluateBoolean(node, ctx, fns) {
+  return toBoolean(evaluate(node, ctx, fns));
+}
+function compile(src, fns) {
+  const node = parse(src);
+  return (ctx) => evaluate(node, ctx, fns);
+}
+function stringifyValue(v) {
+  if (v === null || v === void 0) return "";
+  if (typeof v === "string") return v;
+  if (typeof v === "object") return JSON.stringify(v);
+  return String(v);
+}
+function interpolate(template, ctx, fns) {
+  if (!template.includes("{{")) return template;
+  let out = "";
+  let i = 0;
+  for (; ; ) {
+    const open = template.indexOf("{{", i);
+    if (open === -1) {
+      out += template.slice(i);
+      break;
+    }
+    const close = template.indexOf("}}", open + 2);
+    if (close === -1) {
+      throw new Error(`workflow/expression: interpolate: unclosed '{{' at ${open} (in ${JSON.stringify(template)})`);
+    }
+    const src = template.slice(open + 2, close).trim();
+    if (!src) throw new Error(`workflow/expression: interpolate: empty expression (in ${JSON.stringify(template)})`);
+    out += template.slice(i, open);
+    out += stringifyValue(evaluate(parse(src), ctx, fns));
+    i = close + 2;
+  }
+  return out;
+}
+function toSrc(node) {
+  switch (node.kind) {
+    case "path":
+      return node.segments.reduce((acc, s) => acc + (typeof s === "number" ? `[${s}]` : s === "*" ? "[*]" : acc === "" ? s : `.${s}`), "");
+    case "literal":
+      return node.value === null ? "null" : typeof node.value === "string" ? `'${node.value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'` : String(node.value);
+    case "ternary":
+      return `(${toSrc(node.cond)} ? ${toSrc(node.then)} : ${toSrc(node.else)})`;
+    case "call":
+      return `${node.name}(${node.args.map((a) => toSrc(a)).join(", ")})`;
+    case "neg":
+      return `-${toSrc(node.operand)}`;
+    case "arith":
+      return `(${toSrc(node.left)} ${node.op} ${toSrc(node.right)})`;
+    case "compare":
+      return `(${toSrc(node.left)} ${node.op} ${toSrc(node.right)})`;
+    case "not":
+      return `!${toSrc(node.operand)}`;
+    case "and":
+      return `(${toSrc(node.left)} && ${toSrc(node.right)})`;
+    case "or":
+      return `(${toSrc(node.left)} || ${toSrc(node.right)})`;
+  }
+}
+
+// src/server/workflow/steps.ts
+var httpStep = {
+  type: "http",
+  label: "HTTP \u8BF7\u6C42",
+  fields: [
+    { name: "url", label: "URL", type: "string" },
+    { name: "method", label: "\u65B9\u6CD5", type: "string" }
+  ],
+  required: ["url"],
+  async run(config, ctx, env) {
+    const url = String(config.url);
+    const method = method_(config.method);
+    const timeoutMs = typeof config.timeoutMs === "number" && config.timeoutMs > 0 ? config.timeoutMs : 1e4;
+    const fetchFn = env.fetch ?? globalThis.fetch;
+    if (!fetchFn) throw new Error("http step: no fetch available");
+    const headers = config.headers ?? {};
+    const body = typeof config.body === "string" ? config.body : void 0;
+    const res = await fetchFn(url, {
+      method,
+      headers,
+      body,
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    const maxBytes = typeof config.maxBytes === "number" && config.maxBytes > 0 ? config.maxBytes : 10 * 1024 * 1024;
+    const len = Number(res.headers.get("content-length") ?? 0);
+    if (len > maxBytes) throw new Error(`http step: \u54CD\u5E94 ${len} \u5B57\u8282\u8D85\u8FC7\u4E0A\u9650 ${maxBytes}`);
+    let text;
+    if (res.body) {
+      const reader = res.body.getReader();
+      const chunks = [];
+      let total = 0;
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        total += value.length;
+        if (total > maxBytes) {
+          await reader.cancel();
+          throw new Error(`http step: \u54CD\u5E94\u8D85\u8FC7\u4E0A\u9650 ${maxBytes} \u5B57\u8282\uFF08\u53EF\u7ECF config.maxBytes \u8C03\u6574\uFF09`);
+        }
+        chunks.push(value);
+      }
+      text = new TextDecoder().decode(concatChunks(chunks));
+    } else {
+      text = await res.text();
+    }
+    const data = { status: res.status, text };
+    try {
+      data.json = JSON.parse(text);
+    } catch {
+    }
+    return data;
+  }
+};
+function concatChunks(chunks) {
+  const total = chunks.reduce((n, c) => n + c.length, 0);
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const c of chunks) {
+    out.set(c, off);
+    off += c.length;
+  }
+  return out;
+}
+function method_(m) {
+  const v = String(m ?? "GET").toUpperCase();
+  return ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"].includes(v) ? v : "GET";
+}
+var templateStep = {
+  type: "template",
+  label: "\u6570\u636E\u6A21\u677F",
+  fields: [{ name: "template", label: "\u6A21\u677F", type: "string" }],
+  required: ["template"],
+  run(config, ctx) {
+    return { text: interpolate(String(config.template), ctx) };
+  }
+};
+var logStep = {
+  type: "log",
+  label: "\u65E5\u5FD7",
+  fields: [{ name: "message", label: "\u6D88\u606F", type: "string" }],
+  required: [],
+  run(config, ctx, env) {
+    const text = interpolate(String(config.message ?? ""), ctx);
+    env.log?.(text);
+    return { text };
+  }
+};
+var aiStep = {
+  type: "ai",
+  label: "AI \u751F\u6210",
+  fields: [
+    { name: "prompt", label: "\u63D0\u793A\u8BCD\uFF08\u652F\u6301 {{}} \u63D2\u503C\uFF09", type: "string" },
+    { name: "system", label: "\u7CFB\u7EDF\u6307\u4EE4", type: "string" }
+  ],
+  required: ["prompt"],
+  /** 外部 LLM 调用有成本——dry 打桩 */
+  effects: true,
+  async run(config, ctx, env) {
+    if (!env.ai?.chat) throw new Error("ai step: \u672A\u6CE8\u5165 ai \u9002\u914D\u5668\uFF08workflow({ ai })\uFF09");
+    const system = config.system ? interpolate(String(config.system), ctx) : void 0;
+    const user = interpolate(String(config.prompt), ctx);
+    const res = await env.ai.chat({
+      messages: [
+        ...system ? [{ role: "system", content: system }] : [],
+        { role: "user", content: user }
+      ]
+    });
+    return { text: res.content };
+  }
+};
+var emailStep = {
+  type: "email",
+  label: "\u53D1\u9001\u90AE\u4EF6",
+  fields: [
+    { name: "to", label: "\u6536\u4EF6\u4EBA", type: "string" },
+    { name: "subject", label: "\u4E3B\u9898\uFF08\u652F\u6301 {{}} \u63D2\u503C\uFF09", type: "string" },
+    { name: "body", label: "\u6B63\u6587\uFF08\u652F\u6301 {{}} \u63D2\u503C\uFF09", type: "string" }
+  ],
+  required: ["to"],
+  /** 真发送——dry 打桩 */
+  effects: true,
+  async run(config, ctx, env) {
+    if (!env.email?.send) throw new Error("email step: \u672A\u6CE8\u5165 email \u9002\u914D\u5668\uFF08workflow({ email })\uFF09");
+    const to = interpolate(String(config.to), ctx);
+    const subject = config.subject ? interpolate(String(config.subject), ctx) : "workflow \u901A\u77E5";
+    const body = config.body ? interpolate(String(config.body), ctx) : "";
+    const res = await env.email.send({ to: to.split(",").map((s) => s.trim()).filter(Boolean), subject, body });
+    if (!res.ok) throw new Error(`email step: \u53D1\u9001\u5931\u8D25${res.id ? ` (${res.id})` : ""}`);
+    return { id: res.id };
+  }
+};
+var storeStep = {
+  type: "store",
+  label: "KV \u5B58\u50A8",
+  fields: [
+    { name: "op", label: "\u64CD\u4F5C\uFF08get/set\uFF09", type: "string" },
+    { name: "key", label: "\u952E", type: "string" },
+    { name: "value", label: "\u503C\uFF08set \u65F6\uFF09", type: "string" }
+  ],
+  required: ["op", "key"],
+  run: async (config, ctx, env) => {
+    const store = env.store;
+    if (!store) throw new Error("store \u6B65\u9AA4\u9700\u8981\u5B58\u50A8\u6CE8\u5165\uFF1Aworkflow({ store }) \u6216 workflow({ redis })");
+    const op = String(config.op);
+    const key = interpolate(String(config.key), ctx);
+    if (op === "get") {
+      return await store.get(key);
+    }
+    if (op === "set") {
+      const value = interpolate(String(config.value ?? ""), ctx);
+      await store.set(key, value);
+      return value;
+    }
+    throw new Error(`store \u672A\u77E5\u64CD\u4F5C\uFF1A'${op}'\uFF08get/set\uFF09`);
+  }
+};
+var steps = [httpStep, templateStep, logStep, aiStep, emailStep, storeStep];
+function builtinSteps() {
+  return steps;
+}
+
+// src/server/workflow/runner.ts
+async function runWorkflow(def, opts, env, registry) {
+  const mode = opts.mode ?? "live";
+  const dry = mode === "dry";
+  const startedAt = Date.now();
+  const steps2 = {};
+  const result = { status: "success", executed: [], skippedSteps: [], stepResults: steps2, dry, startedAt, finishedAt: 0 };
+  const budgetMs = opts.budgetMs ?? 6e5;
+  const budgetSignal = AbortSignal.timeout(budgetMs);
+  const signal = opts.signal ? AbortSignal.any([opts.signal, budgetSignal]) : budgetSignal;
+  const rt = { result, steps: steps2, dry, signal, budgetMs, def, fnDepth: 0 };
+  const flow = await execSteps(def.steps, { steps: steps2, vars: {}, input: opts.input }, env, registry, rt);
+  void flow;
+  result.finishedAt = Date.now();
+  return result;
+}
+async function execSteps(steps2, ctx, env, registry, rt) {
+  const { result, steps: out } = rt;
+  for (const step of steps2) {
+    if (rt.signal?.aborted) {
+      result.status = "error";
+      result.error = rt.signal.reason?.name === "TimeoutError" ? `\u6267\u884C\u8D85\u65F6\uFF08\u9884\u7B97 ${rt.budgetMs ?? 6e5}ms\u2014\u2014\u53EF\u7ECF budgetMs \u8C03\u6574\uFF09` : `aborted before step '${step.id}'`;
+      return { k: "return" };
+    }
+    if (step.when !== void 0) {
+      let pass;
+      try {
+        pass = toBoolean(evaluateExpr(step.when, ctx, `when of '${step.id}'`));
+      } catch (e) {
+        out[step.id] = { ok: false, error: `when \u8868\u8FBE\u5F0F\u9519\u8BEF\uFF1A${e.message}` };
+        result.status = "error";
+        result.error = `step '${step.id}': ${e.message}`;
+        return { k: "return" };
+      }
+      if (!pass) {
+        result.skippedSteps.push(step.id);
+        continue;
+      }
+    }
+    switch (step.type) {
+      case "assign": {
+        const cfg = step.config;
+        try {
+          ctx.vars[cfg.target] = evaluateExpr(cfg.value, ctx, `\u8D4B\u503C ${cfg.target}`);
+          out[step.id] = { ok: true, data: ctx.vars[cfg.target] };
+          result.executed.push(step.id);
+        } catch (e) {
+          return fail(rt, step, e);
+        }
+        continue;
+      }
+      case "if": {
+        const cfg = step.config;
+        const flow = await execIf(step, cfg, ctx, env, registry, rt);
+        if (flow.k !== "continue") return flow;
+        continue;
+      }
+      case "try": {
+        const cfg = step.config;
+        const flow = await execTry(step, cfg, ctx, env, registry, rt);
+        if (flow.k !== "continue") return flow;
+        continue;
+      }
+      case "while": {
+        const cfg = step.config;
+        const flow = await execWhile(step, cfg, ctx, env, registry, rt);
+        if (flow.k !== "continue") return flow;
+        continue;
+      }
+      case "for": {
+        const cfg = step.config;
+        const flow = await execFor(step, cfg, ctx, env, registry, rt);
+        if (flow.k !== "continue") return flow;
+        continue;
+      }
+      case "return": {
+        const cfg = step.config;
+        const value = cfg.value !== void 0 ? evaluateExpr(cfg.value, ctx, `return`) : void 0;
+        out[step.id] = { ok: true, data: value };
+        result.executed.push(step.id);
+        return { k: "return", value };
+      }
+      case "call": {
+        const cfg = step.config;
+        const fn = rt.def.functions?.find((f) => f.name === cfg.name);
+        if (!fn) {
+          out[step.id] = { ok: false, error: `\u672A\u77E5\u51FD\u6570\uFF1A'${cfg.name}'` };
+          result.status = "error";
+          result.error = `step '${step.id}': \u672A\u77E5\u51FD\u6570 '${cfg.name}'`;
+          return { k: "return" };
+        }
+        if (rt.fnDepth >= 64) {
+          out[step.id] = { ok: false, error: `\u51FD\u6570\u9012\u5F52\u6DF1\u5EA6\u8D85\u8FC7 64\uFF08${cfg.name}\uFF09` };
+          result.status = "error";
+          result.error = `step '${step.id}': \u51FD\u6570\u9012\u5F52\u6DF1\u5EA6\u8D85\u8FC7 64`;
+          return { k: "return" };
+        }
+        const localVars = {};
+        try {
+          for (let i = 0; i < fn.params.length; i++) {
+            const argSrc = cfg.args?.[i] ?? "undefined";
+            localVars[fn.params[i]] = evaluateExpr(argSrc, ctx, `\u51FD\u6570 '${cfg.name}' \u53C2\u6570 ${fn.params[i]}`);
+          }
+        } catch (e) {
+          out[step.id] = { ok: false, error: e.message };
+          result.status = "error";
+          result.error = `step '${step.id}': ${e.message}`;
+          return { k: "return" };
+        }
+        const fnCtx = { ...ctx, vars: localVars };
+        rt.fnDepth++;
+        const fnFlow = await execSteps(fn.step.steps, fnCtx, env, registry, rt);
+        rt.fnDepth--;
+        if (fnFlow.k === "continue") {
+          out[step.id] = { ok: true, data: void 0 };
+        } else {
+          out[step.id] = { ok: true, data: fnFlow.value };
+        }
+        result.executed.push(step.id);
+        continue;
+      }
+    }
+    const handler = registry.get(step.type);
+    if (!handler) {
+      out[step.id] = { ok: false, error: `\u672A\u6CE8\u518C\u6B65\u9AA4\u7C7B\u578B\uFF1A'${step.type}'` };
+      result.status = "error";
+      result.error = `step '${step.id}': \u672A\u6CE8\u518C\u7C7B\u578B '${step.type}'`;
+      return { k: "return" };
+    }
+    const config = step.config ?? {};
+    try {
+      let data;
+      if (rt.dry && handler.effects) {
+        data = void 0;
+        out[step.id] = { ok: true, dry: true };
+      } else {
+        data = await handler.run(config, ctx, env);
+        out[step.id] = { ok: true, data };
+      }
+      result.executed.push(step.id);
+    } catch (e) {
+      return fail(rt, step, e);
+    }
+    if (rt.signal?.aborted) {
+      result.status = "error";
+      result.error = rt.signal.reason?.name === "TimeoutError" ? `\u6267\u884C\u8D85\u65F6\uFF08\u9884\u7B97 ${rt.budgetMs ?? 6e5}ms\u2014\u2014\u53EF\u7ECF budgetMs \u8C03\u6574\uFF09` : `aborted after step '${step.id}'`;
+      return { k: "return" };
+    }
+  }
+  return { k: "continue" };
+}
+async function execIf(step, cfg, ctx, env, registry, rt) {
+  const { result, steps: out } = rt;
+  let satisfied;
+  try {
+    satisfied = toBoolean(evaluateExpr(cfg.when, ctx, `if '${step.id}' \u6761\u4EF6`));
+  } catch (e) {
+    out[step.id] = { ok: false, error: `if \u8868\u8FBE\u5F0F\u9519\u8BEF\uFF1A${e.message}` };
+    result.status = "error";
+    result.error = `step '${step.id}': ${e.message}`;
+    return { k: "return" };
+  }
+  out[step.id] = { ok: true, data: { satisfied } };
+  result.executed.push(step.id);
+  const chain = satisfied ? cfg.then : cfg.else ?? void 0;
+  return chain ? execSteps(chain.steps, ctx, env, registry, rt) : { k: "continue" };
+}
+async function execTry(step, cfg, ctx, env, registry, rt) {
+  const { result, steps: out } = rt;
+  const preError = result.error;
+  const f = await execSteps(cfg.step.steps, ctx, env, registry, rt);
+  if (f.k === "return" && result.status === "error" && result.error !== preError) {
+    const err = result.error ?? "\u672A\u77E5\u9519\u8BEF";
+    out[step.id] = { ok: false, error: err };
+    result.status = "success";
+    result.error = void 0;
+    result.executed.push(step.id);
+    if (cfg.catch?.steps.length) return execSteps(cfg.catch.steps, ctx, env, registry, rt);
+    return { k: "continue" };
+  }
+  out[step.id] = { ok: true, data: {} };
+  result.executed.push(step.id);
+  return f;
+}
+async function execWhile(step, cfg, ctx, env, registry, rt) {
+  const { result, steps: out } = rt;
+  const maxIters = cfg.maxIters ?? 1e3;
+  for (let i = 0; ; i++) {
+    if (rt.signal?.aborted) {
+      result.status = "error";
+      result.error = `aborted in while '${step.id}'`;
+      return { k: "return" };
+    }
+    let cond;
+    try {
+      cond = toBoolean(evaluateExpr(cfg.when, ctx, `while '${step.id}' \u6761\u4EF6`));
+    } catch (e) {
+      out[step.id] = { ok: false, error: `while \u8868\u8FBE\u5F0F\u9519\u8BEF\uFF1A${e.message}` };
+      result.status = "error";
+      result.error = `step '${step.id}': ${e.message}`;
+      return { k: "return" };
+    }
+    if (!cond) {
+      out[step.id] = { ok: true, data: { iterations: i } };
+      result.executed.push(step.id);
+      return { k: "continue" };
+    }
+    if (i >= maxIters) {
+      out[step.id] = { ok: false, error: `while \u8D85\u8FC7 maxIters=${maxIters}\uFF08\u9632\u6B7B\u5FAA\u73AF\uFF09` };
+      result.status = "error";
+      result.error = `step '${step.id}': while \u8D85\u8FC7 maxIters=${maxIters}`;
+      return { k: "return" };
+    }
+    const flow = await execSteps(cfg.step.steps, ctx, env, registry, rt);
+    if (flow.k !== "continue") return flow;
+  }
+}
+async function execFor(step, cfg, ctx, env, registry, rt) {
+  const { result, steps: out } = rt;
+  let items;
+  try {
+    items = evaluateExpr(cfg.items, ctx, `for '${step.id}' items`);
+  } catch (e) {
+    out[step.id] = { ok: false, error: `for \u8868\u8FBE\u5F0F\u9519\u8BEF\uFF1A${e.message}` };
+    result.status = "error";
+    result.error = `step '${step.id}': ${e.message}`;
+    return { k: "return" };
+  }
+  if (!Array.isArray(items)) {
+    out[step.id] = { ok: false, error: `for items \u5FC5\u987B\u662F\u6570\u7EC4\uFF08\u5F97\u5230 ${String(items)}\uFF09` };
+    result.status = "error";
+    result.error = `step '${step.id}': for items \u975E\u6570\u7EC4`;
+    return { k: "return" };
+  }
+  const maxIters = cfg.maxIters ?? 1e3;
+  if (items.length > maxIters) {
+    out[step.id] = { ok: false, error: `for \u8D85\u8FC7 maxIters=${maxIters}\uFF08items ${items.length} \u9879\uFF09` };
+    result.status = "error";
+    result.error = `step '${step.id}': for \u8D85\u8FC7 maxIters=${maxIters}`;
+    return { k: "return" };
+  }
+  const prevLoop = ctx.loop;
+  for (let i = 0; i < items.length; i++) {
+    if (rt.signal?.aborted) {
+      result.status = "error";
+      result.error = `aborted in for '${step.id}'`;
+      return { k: "return" };
+    }
+    ctx.loop = { item: items[i], index: i };
+    const flow = await execSteps(cfg.step.steps, ctx, env, registry, rt);
+    if (flow.k !== "continue") {
+      ctx.loop = prevLoop;
+      return flow;
+    }
+  }
+  ctx.loop = prevLoop;
+  out[step.id] = { ok: true, data: { iterations: items.length } };
+  result.executed.push(step.id);
+  return { k: "continue" };
+}
+function fail(rt, step, e) {
+  rt.steps[step.id] = { ok: false, error: e.message };
+  rt.result.status = "error";
+  rt.result.error = `step '${step.id}' (${step.type}): ${e.message}`;
+  return { k: "return" };
+}
+function evaluateExpr(src, ctx, where) {
+  try {
+    return compile(src, STD_FNS)(ctx);
+  } catch (e) {
+    throw new Error(`\u8868\u8FBE\u5F0F\u9519\u8BEF\uFF08${where}\uFF09\uFF1A${e.message}`);
+  }
+}
+
+// src/server/workflow/store.ts
+function redisStore(redis) {
+  return {
+    get: async (key) => {
+      const v = await redis.command("GET", key);
+      return v === null || v === void 0 ? null : String(v);
+    },
+    set: async (key, value) => {
+      await redis.command("SET", key, value);
+    },
+    del: async (key) => {
+      await redis.command("DEL", key);
+    }
+  };
+}
+
+// src/server/workflow/contracts.ts
+var BUILTIN_TYPES = ["assign", "if", "try", "while", "for", "return", "call"];
+
+// src/server/workflow/validate.ts
+var MAX_DEPTH = 16;
+function validate(def, registry) {
+  const errors = [];
+  const d = def;
+  if (!Array.isArray(d?.steps) || d.steps.length === 0) {
+    return { ok: false, errors: [{ path: "steps", message: "steps \u5FC5\u987B\u4E3A\u975E\u7A7A\u6570\u7EC4" }] };
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const declaredVars = /* @__PURE__ */ new Set();
+  const stepIds = /* @__PURE__ */ new Set();
+  collectDecls(d, declaredVars, stepIds);
+  validateChain(d.steps, "steps", registry, errors, seen, 0);
+  const refChecks = [];
+  collectRefs(d, refChecks);
+  for (const rc of refChecks) {
+    let ast;
+    try {
+      ast = parse(rc.expr);
+    } catch {
+      continue;
+    }
+    checkRefs(ast, declaredVars, stepIds, rc.path, errors);
+  }
+  return { ok: errors.length === 0, errors };
+}
+function collectDecls(def, declaredVars, stepIds) {
+  const walk = (steps2) => {
+    for (const s of steps2) {
+      stepIds.add(s.id);
+      const cfg = s.config ?? {};
+      if (s.type === "assign" && typeof cfg.target === "string") declaredVars.add(cfg.target);
+      const sub = cfg.then;
+      if (sub && Array.isArray(sub.steps)) walk(sub.steps);
+      const sub2 = cfg.else;
+      if (sub2 && Array.isArray(sub2.steps)) walk(sub2.steps);
+      const chain = cfg.step;
+      if (chain && Array.isArray(chain.steps)) walk(chain.steps);
+      const chainC = cfg.catch;
+      if (chainC && Array.isArray(chainC.steps)) walk(chainC.steps);
+    }
+  };
+  walk(def.steps);
+  for (const f of def.functions ?? []) {
+    for (const p of f.params ?? []) declaredVars.add(p);
+    walk(f.step.steps);
+  }
+}
+function collectRefs(def, out) {
+  const walk = (steps2, prefix) => {
+    for (const s of steps2) {
+      const cfg = s.config ?? {};
+      const p = `${prefix}/${s.id}`;
+      if (s.type === "assign") {
+        pushE(cfg.value, `${p}.value`);
+      } else if (s.type === "if") {
+        pushE(cfg.when, `${p}.when`);
+        for (const b of ["then", "else"]) {
+          const chain = cfg[b];
+          if (chain && Array.isArray(chain.steps)) walk(chain.steps, `${p}.${b}`);
+        }
+      } else if (s.type === "while") {
+        pushE(cfg.when, `${p}.when`);
+      } else if (s.type === "for") {
+        pushE(cfg.items, `${p}.items`);
+      } else if (s.type === "return") {
+        pushE(cfg.value, `${p}.value`);
+      } else if (s.type === "call") {
+        for (const [i, a] of (cfg.args ?? []).entries()) pushE(a, `${p}.args[${i}]`);
+      } else {
+        for (const [k, v] of Object.entries(cfg)) {
+          if (typeof v === "string") pushTemplate(v, `${p}.${k}`);
+          else if (v && typeof v === "object" && !Array.isArray(v)) walkObj(v, `${p}.${k}`);
+        }
+      }
+      if (typeof s.when === "string") pushE(s.when, `${p}.when`);
+    }
+  };
+  const walkObj = (obj, prefix) => {
+    for (const [k, v] of Object.entries(obj)) {
+      if (typeof v === "string") pushTemplate(v, `${prefix}.${k}`);
+      else if (v && typeof v === "object" && !Array.isArray(v)) walkObj(v, `${prefix}.${k}`);
+    }
+  };
+  const pushE = (v, path) => {
+    if (typeof v === "string") out.push({ path, expr: v });
+  };
+  const pushTemplate = (v, path) => {
+    for (const m of v.matchAll(/\{\{([\s\S]+?)\}\}/g)) out.push({ path, expr: m[1].trim() });
+  };
+  walk(def.steps, "steps");
+  for (const f of def.functions ?? []) walk(f.step.steps, `functions.${f.name}`);
+}
+function checkRefs(node, declaredVars, stepIds, path, errors) {
+  if (!node || typeof node !== "object") return;
+  if ("segments" in node && Array.isArray(node.segments)) {
+    const first = node.segments[0];
+    if (first === "vars" && node.segments[1] === "loop") return;
+    if (first === "vars" && typeof node.segments[1] === "string" && !declaredVars.has(node.segments[1])) {
+      errors.push({ path, message: `\u672A\u58F0\u660E\u53D8\u91CF\u5F15\u7528\uFF1Avars.${node.segments[1]}\uFF08\u987B\u6709 assign target \u58F0\u660E\uFF09` });
+    } else if (first === "steps" && typeof node.segments[1] === "string" && !stepIds.has(node.segments[1])) {
+      errors.push({ path, message: `\u672A\u77E5\u6B65\u9AA4\u5F15\u7528\uFF1Asteps.${node.segments[1]}\uFF08\u987B\u662F\u5DF2\u5B9A\u4E49\u6B65\u9AA4 id\uFF09` });
+    }
+    return;
+  }
+  for (const v of Object.values(node)) {
+    if (v && typeof v === "object") checkRefs(v, declaredVars, stepIds, path, errors);
+  }
+}
+function validateChain(steps2, prefix, registry, errors, seen, depth) {
+  if (depth > MAX_DEPTH) {
+    errors.push({ path: prefix, message: `\u5B50\u94FE\u5D4C\u5957\u8D85\u8FC7 ${MAX_DEPTH} \u5C42` });
+    return;
+  }
+  for (const [i, step] of steps2.entries()) {
+    const p = `${prefix}[${i}]`;
+    if (!step || typeof step !== "object") {
+      errors.push({ path: p, message: "step \u5FC5\u987B\u662F\u5BF9\u8C61" });
+      continue;
+    }
+    if (!step.id || typeof step.id !== "string") errors.push({ path: `${p}.id`, message: "\u5FC5\u586B\uFF1A\u552F\u4E00 id" });
+    else if (seen.has(step.id)) errors.push({ path: `${p}.id`, message: `id \u91CD\u590D\uFF1A'${step.id}'` });
+    else seen.add(step.id);
+    if (!step.type || typeof step.type !== "string") {
+      errors.push({ path: `${p}.type`, message: "\u5FC5\u586B\uFF1A\u6B65\u9AA4\u7C7B\u578B" });
+      continue;
+    }
+    if (!BUILTIN_TYPES.includes(step.type) && !registry.has(step.type)) {
+      errors.push({ path: `${p}.type`, message: `\u672A\u6CE8\u518C\u7684\u6B65\u9AA4\u7C7B\u578B\uFF1A'${step.type}'` });
+      continue;
+    }
+    const config = step.config ?? {};
+    switch (step.type) {
+      case "assign":
+        checkExprField(config, "target", "\u76EE\u6807\u53D8\u91CF\u540D", errors, `${p}.config.target`, false);
+        checkExprField(config, "value", "\u8D4B\u503C\u8868\u8FBE\u5F0F", errors, `${p}.config.value`, false);
+        break;
+      case "if": {
+        checkExprField(config, "when", "\u6761\u4EF6\u8868\u8FBE\u5F0F", errors, `${p}.config.when`, false);
+        for (const branch of ["then", "else"]) {
+          const chain = config[branch];
+          if (chain !== void 0) {
+            if (!Array.isArray(chain.steps)) errors.push({ path: `${p}.config.${branch}.steps`, message: "\u5FC5\u987B\u662F\u6B65\u9AA4\u6570\u7EC4" });
+            else validateChain(chain.steps, `${p}.config.${branch}.steps`, registry, errors, seen, depth + 1);
+          }
+        }
+        break;
+      }
+      case "try": {
+        validateChainField(config, "step", registry, errors, seen, depth, p, "steps");
+        const cchain = config.catch;
+        if (!cchain || !Array.isArray(cchain.steps)) {
+          errors.push({ path: `${p}.config.catch.steps`, message: "catch \u94FE\u5FC5\u987B\u662F\u6B65\u9AA4\u6570\u7EC4\uFF08v0 try \u5FC5\u914D catch\uFF09" });
+        } else {
+          validateChain(cchain.steps, `${p}.config.catch.steps`, registry, errors, seen, depth + 1);
+        }
+        break;
+      }
+      case "while": {
+        checkExprField(config, "when", "\u5FAA\u73AF\u6761\u4EF6", errors, `${p}.config.when`, false);
+        validateChainField(config, "step", registry, errors, seen, depth, p, "steps");
+        break;
+      }
+      case "for": {
+        checkExprField(config, "items", "\u96C6\u5408\u8868\u8FBE\u5F0F", errors, `${p}.config.items`, false);
+        validateChainField(config, "step", registry, errors, seen, depth, p, "steps");
+        break;
+      }
+      case "return": {
+        if (config.value !== void 0) checkExprField(config, "value", "\u8FD4\u56DE\u503C\u8868\u8FBE\u5F0F", errors, `${p}.config.value`, true);
+        break;
+      }
+      default: {
+        const schema = registry.schema(step.type);
+        for (const field of schema?.required ?? []) {
+          if (typeof config[field] !== "string" || config[field] === "") {
+            errors.push({ path: `${p}.config.${field}`, message: `\u5FC5\u586B\uFF1A${field}` });
+          }
+        }
+      }
+    }
+    if (step.when !== void 0 && typeof step.when !== "string") {
+      errors.push({ path: `${p}.when`, message: "\u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u8868\u8FBE\u5F0F" });
+    } else if (typeof step.when === "string") {
+      try {
+        compile(step.when);
+      } catch (e) {
+        errors.push({ path: `${p}.when`, message: `\u8868\u8FBE\u5F0F\u9519\u8BEF\uFF1A${e.message}` });
+      }
+    }
+  }
+}
+function validateChainField(config, field, registry, errors, seen, depth, p, ctxPath) {
+  const chain = config[field];
+  if (!chain || !Array.isArray(chain.steps)) {
+    errors.push({ path: `${p}.config.${field}.${ctxPath}`, message: "\u5FC5\u987B\u662F\u6B65\u9AA4\u6570\u7EC4" });
+    return;
+  }
+  validateChain(chain.steps, `${p}.config.${field}.${ctxPath}`, registry, errors, seen, depth + 1);
+}
+function checkExprField(config, field, label, errors, path, optional) {
+  const v = config[field];
+  if (typeof v !== "string" || v === "") {
+    if (!optional) errors.push({ path, message: `\u5FC5\u586B\uFF1A${label}` });
+    return;
+  }
+  try {
+    compile(v);
+  } catch (e) {
+    errors.push({ path, message: `\u8868\u8FBE\u5F0F\u9519\u8BEF\uFF1A${e.message}` });
+  }
+}
+
+// src/server/workflow/views.ts
+function toJsonSchema(schemas) {
+  const properties = {};
+  for (const s of schemas) {
+    const fieldProps = {};
+    for (const f of s.fields ?? []) {
+      fieldProps[f.name] = {
+        type: f.type === "number" ? "number" : f.type === "boolean" ? "boolean" : "string",
+        title: f.label,
+        placeholder: f.placeholder
+      };
+    }
+    properties[s.type] = {
+      type: "object",
+      title: s.label,
+      properties: fieldProps,
+      ...s.required && s.required.length ? { required: s.required } : {}
+    };
+  }
+  return { type: "object", title: "Workflow", properties };
+}
+var STEP_LABELS = {
+  http: "HTTP",
+  assign: "\u8D4B\u503C",
+  call: "\u8C03\u7528",
+  if: "\u6761\u4EF6",
+  while: "\u5FAA\u73AF",
+  for: "\u904D\u5386",
+  return: "\u8FD4\u56DE",
+  store: "\u5B58\u50A8",
+  email: "\u90AE\u4EF6",
+  ai: "AI",
+  template: "\u6A21\u677F",
+  log: "\u65E5\u5FD7"
+};
+function chainSummary(type, steps2, elseSteps) {
+  if (type === "if") {
+    const thenN = steps2?.length ?? 0;
+    const elseN = elseSteps?.length ?? 0;
+    return `then\xD7${thenN}${elseN ? `/else\xD7${elseN}` : ""}`;
+  }
+  if (type === "while" || type === "for") return `\xD7${steps2?.length ?? 0} \u5B50\u6B65\u9AA4`;
+  return "";
+}
+function workflowToDag(def, opts) {
+  const labels = opts?.labels ?? {};
+  const nodes = [];
+  const edges = [];
+  const steps2 = def.steps ?? [];
+  for (const [i, s] of steps2.entries()) {
+    const cfg = s.config ?? {};
+    let label = `${labels[s.type] ?? STEP_LABELS[s.type] ?? s.type} ${s.id}`;
+    if (s.type === "if") {
+      const then = cfg.then?.steps;
+      const els = cfg.else?.steps;
+      const sum = chainSummary("if", then, els);
+      if (sum) label += `\uFF08${sum}\uFF09`;
+    } else if (s.type === "while" || s.type === "for") {
+      const sub = cfg.step?.steps;
+      const sum = chainSummary(s.type, sub);
+      if (sum) label += `\uFF08${sum}\uFF09`;
+    }
+    nodes.push({ id: s.id, label });
+    if (i > 0) edges.push({ from: steps2[i - 1].id, to: s.id });
+  }
+  return { nodes, edges };
+}
+
+// src/server/workflow/wfjs.ts
+var KEYWORDS = /* @__PURE__ */ new Set(["const", "let", "var", "if", "else", "while", "for", "of", "return", "function", "import", "export", "from", "as", "default", "await", "async", "once", "true", "false", "null", "try", "catch", "finally"]);
+var PUNCS = /* @__PURE__ */ new Set(["{", "}", "(", ")", "[", "]", ";", ",", ":", "."]);
+var BINARY_OPS = /* @__PURE__ */ new Set(["+", "-", "*", "/", "%", "<", ">", "<=", ">=", "==", "!=", "===", "!==", "&&", "||"]);
+var isBinaryOp = (v) => BINARY_OPS.has(v);
+var TWO_OPS = /* @__PURE__ */ new Set(["==", "!=", "<=", ">=", "&&", "||", "+=", "-=", "*=", "/=", "%=", "++", "--"]);
+var ONE_OPS = /* @__PURE__ */ new Set(["=", "+", "-", "*", "/", "%", "<", ">", "!", "?"]);
+function tokenizeWfjs(src) {
+  const tokens = [];
+  let i = 0;
+  const n = src.length;
+  while (i < n) {
+    const ch = src[i];
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+      i++;
+      continue;
+    }
+    if (ch === "#" || ch === "/" && src[i + 1] === "/") {
+      while (i < n && src[i] !== "\n") i++;
+      continue;
+    }
+    if (ch === "`") {
+      let j = i + 1;
+      let raw = "";
+      while (j < n && src[j] !== "`") {
+        if (src[j] === "\\") {
+          raw += src[j] + (src[j + 1] ?? "");
+          j += 2;
+          continue;
+        }
+        raw += src[j];
+        j++;
+      }
+      if (j >= n) throw new Error(`wfjs: unterminated template string at ${i}`);
+      tokens.push({ t: "template", raw, v: "", pos: i, end: j + 1 });
+      i = j + 1;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      const quote = ch;
+      let j = i + 1;
+      let out = "";
+      while (j < n && src[j] !== quote) {
+        if (src[j] === "\\") {
+          const e = src[j + 1];
+          if (e === "n") {
+            out += "\n";
+            j += 2;
+            continue;
+          }
+          if (e === "t") {
+            out += "	";
+            j += 2;
+            continue;
+          }
+          out += e ?? "";
+          j += 2;
+          continue;
+        }
+        out += src[j];
+        j++;
+      }
+      if (j >= n) throw new Error(`wfjs: unterminated string at ${i}`);
+      tokens.push({ t: "str", v: out, pos: i, end: j + 1 });
+      i = j + 1;
+      continue;
+    }
+    const three = src.slice(i, i + 3);
+    if (three === "===" || three === "!==") {
+      tokens.push({ t: "op", v: three, pos: i, end: i + 3 });
+      i += 3;
+      continue;
+    }
+    const two = src.slice(i, i + 2);
+    if (TWO_OPS.has(two)) {
+      tokens.push({ t: "op", v: two, pos: i, end: i + 2 });
+      i += 2;
+      continue;
+    }
+    if (ONE_OPS.has(ch)) {
+      tokens.push({ t: "op", v: ch, pos: i, end: i + 1 });
+      i++;
+      continue;
+    }
+    if (PUNCS.has(ch)) {
+      tokens.push({ t: "punc", v: ch, pos: i, end: i + 1 });
+      i++;
+      continue;
+    }
+    if (ch >= "0" && ch <= "9") {
+      const m2 = /[0-9]+(?:\.[0-9]+)?/.exec(src.slice(i));
+      tokens.push({ t: "num", v: Number(m2[0]), pos: i, end: i + m2[0].length });
+      i += m2[0].length;
+      continue;
+    }
+    const m = /[A-Za-z_$][A-Za-z0-9_$]*/.exec(src.slice(i));
+    if (m) {
+      tokens.push(KEYWORDS.has(m[0]) ? { t: "kw", v: m[0], pos: i, end: i + m[0].length } : { t: "ident", v: m[0], pos: i, end: i + m[0].length });
+      i += m[0].length;
+      continue;
+    }
+    throw new Error(`wfjs: unexpected character '${ch}' at ${i} (in ${JSON.stringify(src)})`);
+  }
+  tokens.push({ t: "eof", v: "", pos: n, end: n });
+  return tokens;
+}
+var WfjsParser = class {
+  i = 0;
+  tokens;
+  src;
+  constructor(tokens, src) {
+    this.tokens = tokens;
+    this.src = src;
+  }
+  peek() {
+    return this.tokens[this.i];
+  }
+  next() {
+    return this.tokens[this.i++];
+  }
+  fail(msg, pos) {
+    throw new Error(`${msg} at ${pos} (in ${JSON.stringify(this.src)})`);
+  }
+  expect(v) {
+    const tk = this.next();
+    if (tk.v !== v) this.fail(`wfjs: expected '${v}'`, tk.pos);
+    return tk;
+  }
+  isPunc(v) {
+    const tk = this.peek();
+    return tk.t === "punc" && tk.v === v;
+  }
+  isKw(v) {
+    const tk = this.peek();
+    return tk.t === "kw" && tk.v === v;
+  }
+  parseProgram() {
+    const stmts = [];
+    while (this.peek().t !== "eof") {
+      if (this.isPunc(";")) {
+        this.next();
+        continue;
+      }
+      stmts.push(this.parseStmt());
+      if (this.isPunc(";")) this.next();
+    }
+    return stmts;
+  }
+  parseStmt() {
+    if (this.peek().t === "kw") {
+      const v = this.peek().v;
+      if (v === "const" || v === "let" || v === "var") return this.parseVar();
+      if (v === "if") return this.parseIf();
+      if (v === "try") return this.parseTry();
+      if (v === "while") return this.parseWhile();
+      if (v === "for") return this.parseFor();
+      if (v === "return") return this.parseReturn();
+      if (v === "async") {
+        this.next();
+        return this.parseStmt();
+      }
+      if (v === "await") {
+        this.next();
+        return this.parseStmt();
+      }
+      if (v === "import") return this.parseImport();
+      if (v === "function") return this.parseFunction();
+      if (v === "export") return this.parseExport();
+    }
+    if (this.peek().t === "ident") return this.parseAssignOrCall();
+    this.fail(`wfjs: unexpected '${this.peek().t === "eof" ? "(end)" : String(this.peek().v)}'`, this.peek().pos);
+  }
+  parseTry() {
+    this.expect("try");
+    this.expect("{");
+    const body = this.parseBlockBody();
+    if (!this.isKw("catch")) this.fail(`wfjs: try \u5FC5\u987B\u914D catch\uFF08v0 \u65E0 finally\uFF09\u2014\u2014\u671F\u671B catch`, this.peek().pos);
+    this.next();
+    if (this.peek().t === "punc" && this.peek().v === "(") {
+      this.fail("wfjs: catch \u7ED1\u5B9A\u53D8\u91CF\u6682\u4E0D\u652F\u6301\uFF08ES2019 \u53EF\u9009\u7ED1\u5B9A\u8BED\u4E49\uFF09\u2014\u2014\u9519\u8BEF\u4ECE steps.<tryId>.error \u8BFB\u53D6", this.peek().pos);
+    }
+    this.expect("{");
+    const catchBody = this.parseBlockBody();
+    return { k: "try", body, catchBody };
+  }
+  parseBlockBody() {
+    const stmts = [];
+    while (!this.isPunc("}")) {
+      if (this.peek().t === "eof") this.fail(`wfjs: unclosed block`, this.peek().pos);
+      if (this.isPunc(";")) {
+        this.next();
+        continue;
+      }
+      stmts.push(this.parseStmt());
+      if (this.isPunc(";")) this.next();
+    }
+    this.next();
+    return stmts;
+  }
+  /** export { a, b as c } / export default f——v1 仅函数导出 */
+  parseExport() {
+    this.next();
+    if (this.isKw("default")) {
+      this.next();
+      const name = this.next();
+      if (name.t !== "ident") this.fail("wfjs: export default \u540E\u5FC5\u987B\u662F\u51FD\u6570\u540D", name.pos);
+      return { k: "export", named: [], default: String(name.v) };
+    }
+    this.expect("{");
+    const named = [];
+    while (!this.isPunc("}")) {
+      const name = this.next();
+      if (name.t !== "ident") this.fail("wfjs: export \u6210\u5458\u540D\u5FC5\u987B\u662F\u6807\u8BC6\u7B26", name.pos);
+      let asName = name.v;
+      if (this.isKw("as")) {
+        this.next();
+        const a = this.next();
+        if (a.t !== "ident") this.fail("wfjs: as \u540E\u5FC5\u987B\u662F\u6807\u8BC6\u7B26", a.pos);
+        asName = a.v;
+      }
+      if (asName !== name.v) named.push({ name: name.v, as: asName });
+      else named.push({ name: name.v });
+      if (this.isPunc(",")) {
+        this.next();
+        continue;
+      }
+    }
+    this.next();
+    return { k: "export", named, default: void 0 };
+  }
+  /** function name(a, b) { body }——先声明后调用（函数提升 v2 裁剪） */
+  parseFunction() {
+    this.next();
+    const name = this.next();
+    if (name.t !== "ident") this.fail("wfjs: function \u540E\u5FC5\u987B\u662F\u51FD\u6570\u540D", name.pos);
+    this.expect("(");
+    const params = [];
+    if (!this.isPunc(")")) {
+      for (; ; ) {
+        const p = this.next();
+        if (p.t !== "ident") this.fail("wfjs: \u53C2\u6570\u5FC5\u987B\u662F\u6807\u8BC6\u7B26", p.pos);
+        params.push(String(p.v));
+        if (this.isPunc(",")) {
+          this.next();
+          continue;
+        }
+        break;
+      }
+    }
+    this.expect(")");
+    this.expect("{");
+    const body = this.parseBlockBody();
+    return { k: "function", name: String(name.v), params, body };
+  }
+  /** parseBlockBody 在类中——检查存在 */
+  parseImport() {
+    this.next();
+    if (!this.isPunc("{")) this.fail(`wfjs: import \u4EC5\u652F\u6301\u547D\u540D\u5BFC\u5165\uFF08{ ... }\uFF09\u2014\u2014\u9ED8\u8BA4/\u547D\u540D\u7A7A\u95F4\u5BFC\u5165 W8`, this.peek().pos);
+    this.next();
+    const names = [];
+    while (!this.isPunc("}")) {
+      const name = this.next();
+      if (name.t !== "ident") this.fail(`wfjs: import \u6210\u5458\u540D\u5FC5\u987B\u662F\u6807\u8BC6\u7B26`, name.pos);
+      let asName = name.v;
+      if (this.isKw("as")) {
+        this.next();
+        const a = this.next();
+        if (a.t !== "ident") this.fail("wfjs: as \u540E\u5FC5\u987B\u662F\u6807\u8BC6\u7B26", a.pos);
+        asName = a.v;
+      }
+      if (asName !== name.v) names.push({ name: name.v, as: asName });
+      else names.push({ name: name.v });
+      if (this.isPunc(",")) {
+        this.next();
+        continue;
+      }
+    }
+    this.next();
+    this.expect("from");
+    const from = this.next();
+    if (from.t !== "str") this.fail("wfjs: import \u6765\u6E90\u5FC5\u987B\u662F\u5B57\u7B26\u4E32", from.pos);
+    return { k: "import", names, from: String(from.v) };
+  }
+  /** 方法式调用解析（store.get('k') / store.set('k', v)）——返回 null 表示非方法调用 */
+  tryParseMethodCall() {
+    const tk = this.peek();
+    const dot = this.tokens[this.i + 1];
+    const method = this.tokens[this.i + 2];
+    const paren = this.tokens[this.i + 3];
+    if (tk.t !== "ident" || dot?.t !== "punc" || dot.v !== "." || method?.t !== "ident" || paren?.t !== "punc" || paren.v !== "(") return null;
+    const obj = String(tk.v);
+    const name = String(method.v);
+    this.next();
+    this.next();
+    this.next();
+    this.next();
+    const args = [];
+    if (!this.isPunc(")")) {
+      for (; ; ) {
+        args.push({ key: null, value: this.parseValue() });
+        if (this.isPunc(",")) {
+          this.next();
+          continue;
+        }
+        break;
+      }
+    }
+    this.expect(")");
+    return { name: `@${obj}.${name}`, args };
+  }
+  parseVar() {
+    const kw = this.next();
+    if (kw.t === "kw" && kw.v === "var") this.fail(`wfjs: 'var' \u4E0D\u652F\u6301\uFF08\u51FD\u6570\u4F5C\u7528\u57DF\u8BED\u4E49\u6613\u6DF7\u6DC6\uFF09\u2014\u2014\u8BF7\u7528 let/const`, kw.pos);
+    const name = this.next();
+    if (name.t !== "ident") this.fail(`wfjs: expected variable name after '${kw.v}'`, name.pos);
+    let init = null;
+    if (this.peek().t === "op" && this.peek().v === "=") {
+      this.next();
+      init = this.parseValueOrCall();
+    }
+    return { k: "var", name: name.v, init, isConst: kw.v === "const" };
+  }
+  parseValueOrCall() {
+    let hadAwait = false;
+    if (this.peek().t === "kw" && this.peek().v === "await") {
+      this.next();
+      hadAwait = true;
+    }
+    const method = this.tryParseMethodCall();
+    if (method) return method;
+    const tk = this.peek();
+    const next = this.tokens[this.i + 1];
+    if (hadAwait && tk.t === "ident" && next?.t === "punc" && next.v === "(") {
+      const name = String(this.next().v);
+      this.next();
+      if (BUILTIN_NAMES.has(name)) return { name, args: this.parseCallArgs() };
+      const args = [];
+      if (!this.isPunc(")")) {
+        for (; ; ) {
+          args.push({ key: null, value: this.parseValue() });
+          if (this.isPunc(",")) {
+            this.next();
+            continue;
+          }
+          break;
+        }
+      }
+      this.expect(")");
+      return { name, args };
+    }
+    if (tk.t === "ident" && next?.t === "punc" && next.v === "(") {
+      const after = this.tokens[this.i + 2];
+      if (after?.t === "punc" && after.v === "{") {
+        this.fail(`wfjs: \u672A\u8BC6\u522B\u8C03\u7528 '${String(tk.v)}'\uFF08\u4EC5\u5185\u7F6E\u6216 std \u7EAF\u51FD\u6570\u2014\u2014\u51FD\u6570\u5B9A\u4E49 W8\uFF09`, tk.pos);
+      }
+    }
+    return this.parseValue();
+  }
+  parseCallArgs() {
+    if (this.isPunc(")")) {
+      this.next();
+      return [];
+    }
+    if (this.isPunc("{")) {
+      const args = this.parseObjectArgs();
+      this.expect(")");
+      return args;
+    }
+    this.fail(`wfjs: \u5185\u7F6E\u8C03\u7528\u9700\u5BF9\u8C61\u53C2\u6570\uFF08{ key: value }\uFF09\u2014\u2014\u4F4D\u7F6E\u53C2\u6570\u4EC5\u9650 W8 \u51FD\u6570\u8C03\u7528`, this.peek().pos);
+    return [];
+  }
+  parseObjectArgs() {
+    this.expect("{");
+    const args = [];
+    while (!this.isPunc("}")) {
+      const key = this.next();
+      if (key.t !== "ident" && key.t !== "str") this.fail(`wfjs: expected argument key in object literal`, key.pos);
+      this.expect(":");
+      args.push({ key: String(key.v), value: this.parseValue() });
+      if (this.isPunc(",")) this.next();
+      else break;
+    }
+    this.expect("}");
+    return args;
+  }
+  parseValue() {
+    const tk = this.peek();
+    if (tk.t === "template" || tk.t === "str" || tk.t === "num") {
+      const after = this.tokens[this.i + 1];
+      if (after && after.t === "op" && isBinaryOp(after.v)) {
+        return { t: "expr", src: this.scanExpr() };
+      }
+      if (tk.t === "template") {
+        this.next();
+        return { t: "tpl", parts: parseTemplateParts(tk.raw) };
+      }
+      if (tk.t === "str") {
+        this.next();
+        return { t: "str", v: tk.v };
+      }
+      this.next();
+      return { t: "num", v: tk.v };
+    }
+    if (tk.t === "kw" && (tk.v === "true" || tk.v === "false" || tk.v === "null")) {
+      const after = this.tokens[this.i + 1];
+      if (after && after.t === "op" && isBinaryOp(after.v)) return { t: "expr", src: this.scanExpr() };
+      this.next();
+      return { t: "expr", src: tk.v };
+    }
+    if (tk.t === "punc" && tk.v === "{") {
+      this.next();
+      const kvs = [];
+      while (!this.isPunc("}")) {
+        const key = this.next();
+        if (key.t !== "ident" && key.t !== "str") this.fail(`wfjs: expected object key`, key.pos);
+        this.expect(":");
+        kvs.push({ key: String(key.v), value: this.parseValue() });
+        if (this.isPunc(",")) this.next();
+        else break;
+      }
+      this.expect("}");
+      return { t: "obj", kvs };
+    }
+    return { t: "expr", src: this.scanExpr() };
+  }
+  /** 扫描表达式源码（单行裁剪：depth0 换行即边界——跨行表达式明确报错） */
+  scanExpr() {
+    const start = this.peek().pos;
+    let out = "";
+    let depth = 0;
+    let prevEnd = -1;
+    for (; ; ) {
+      const tk = this.peek();
+      if (tk.t === "eof") break;
+      if (depth === 0) {
+        if (tk.t === "punc" && (tk.v === "," || tk.v === ";" || tk.v === ")" || tk.v === "}")) break;
+        if (tk.t === "op" && (tk.v === "=" || tk.v === "+=" || tk.v === "-=" || tk.v === "*=" || tk.v === "/=" || tk.v === "%=")) break;
+        if (prevEnd >= 0 && this.src.slice(prevEnd, tk.pos).includes("\n")) break;
+      }
+      if (tk.t === "punc" && (tk.v === "(" || tk.v === "[")) depth++;
+      if (tk.t === "punc" && (tk.v === ")" || tk.v === "]")) {
+        if (depth === 0) break;
+        depth--;
+      }
+      out += this.src.slice(tk.pos, tk.end);
+      prevEnd = tk.end;
+      this.next();
+    }
+    const trimmed = out.trim();
+    if (!trimmed) this.fail(`wfjs: expected expression`, start);
+    return trimmed;
+  }
+  parseIf() {
+    this.expect("if");
+    let once = false;
+    if (this.isKw("once")) {
+      this.next();
+      once = true;
+    }
+    this.expect("(");
+    const cond = this.scanExpr();
+    this.expect(")");
+    this.expect("{");
+    const then = this.parseBlockBody();
+    let elseStmts = null;
+    if (this.isKw("else")) {
+      this.next();
+      if (this.isPunc("{")) {
+        this.next();
+        elseStmts = this.parseBlockBody();
+      } else elseStmts = [this.parseStmt()];
+    }
+    return { k: "if", cond, then, else: elseStmts, once };
+  }
+  parseWhile() {
+    this.expect("while");
+    this.expect("(");
+    const cond = this.scanExpr();
+    this.expect(")");
+    this.expect("{");
+    const body = this.parseBlockBody();
+    return { k: "while", cond, body };
+  }
+  parseFor() {
+    this.expect("for");
+    this.expect("(");
+    const decl = this.next();
+    if (decl.t !== "kw" || !["const", "let", "var"].includes(decl.v)) this.fail(`wfjs: for-of \u9700\u8981 const/let`, decl.pos);
+    const name = this.next();
+    if (name.t !== "ident") this.fail(`wfjs: expected loop variable`, name.pos);
+    const of = this.next();
+    if (of.t !== "kw" || of.v !== "of") this.fail(`wfjs: only for...of supported`, of.pos);
+    const items = this.scanExpr();
+    this.expect(")");
+    this.expect("{");
+    const body = this.parseBlockBody();
+    return { k: "forof", varName: name.v, items, body };
+  }
+  parseReturn() {
+    const kw = this.next();
+    const next = this.peek();
+    if (this.isPunc(";") || this.isPunc("}")) return { k: "return", value: null };
+    if (next.t === "eof") return { k: "return", value: null };
+    const gap = this.src.slice(kw.end, next.pos);
+    if (gap.includes("\n")) return { k: "return", value: null };
+    return { k: "return", value: this.parseValue() };
+  }
+  parseAssignOrCall() {
+    const method = this.tryParseMethodCall();
+    if (method) return { k: "call", call: method };
+    const name = this.next();
+    if (name.t !== "ident") this.fail(`wfjs: expected identifier`, name.pos);
+    const tk = this.peek();
+    if (tk.t === "punc" && tk.v === "(") {
+      this.next();
+      return { k: "call", call: { name: name.v, args: this.parseCallArgs() } };
+    }
+    if (tk.t === "op" && ["=", "+=", "-=", "*=", "/=", "%="].includes(tk.v)) {
+      const op = tk.v;
+      this.next();
+      return { k: "assign", target: name.v, op, value: this.scanExpr() };
+    }
+    if (tk.t === "op" && (tk.v === "++" || tk.v === "--")) {
+      this.next();
+      return { k: "incdec", target: name.v, inc: tk.v === "++" };
+    }
+    this.fail(`wfjs: expected assignment or call after '${name.v}'`, tk.pos);
+  }
+};
+function parseTemplateParts(raw) {
+  const parts = [];
+  let i = 0;
+  let lit = "";
+  while (i < raw.length) {
+    if (raw[i] === "$" && raw[i + 1] === "{") {
+      let depth = 1;
+      let j = i + 2;
+      let expr = "";
+      while (j < raw.length && depth > 0) {
+        if (raw[j] === "\\") {
+          expr += raw[j] + (raw[j + 1] ?? "");
+          j += 2;
+          continue;
+        }
+        if (raw[j] === "{") depth++;
+        if (raw[j] === "}") depth--;
+        if (depth > 0) expr += raw[j];
+        j++;
+      }
+      if (depth !== 0) throw new Error(`wfjs: unclosed '\${' in template`);
+      if (lit) {
+        parts.push(lit);
+        lit = "";
+      }
+      parts.push({ expr: expr.trim() });
+      i = j;
+      continue;
+    }
+    lit += raw[i];
+    i++;
+  }
+  if (lit) parts.push(lit);
+  return parts;
+}
+var BUILTIN_NAMES = /* @__PURE__ */ new Set(["http", "email", "ai", "template", "log", "stop"]);
+function checkExprCall(ast, env, where) {
+  const n = ast;
+  if (!n || typeof n !== "object") return;
+  if (n.kind === "call") {
+    const nm = n.name ?? "";
+    if (SIDE_EFFECT_CALLS.has(nm)) throw new Error(`wfjs: \u526F\u4F5C\u7528\u51FD\u6570 '${nm}()' \u4E0D\u80FD\u51FA\u73B0\u5728\u8868\u8FBE\u5F0F\u5185\uFF08in ${where}\uFF09\u2014\u2014\u9700\u8BED\u53E5\u7EA7\u8C03\u7528`);
+    if (!env.stdFns.has(nm)) throw new Error(`wfjs: \u8868\u8FBE\u5F0F\u5185\u672A\u5BFC\u5165\u51FD\u6570 '${nm}()'\uFF08in ${where}\uFF09\u2014\u2014std \u51FD\u6570\u9700 import \u540E\u53EF\u7528`);
+  }
+  for (const k of ["left", "right", "operand", "cond", "then", "else"]) {
+    if (n[k] && typeof n[k] === "object") checkExprCall(n[k], env, where);
+  }
+  if (n.args) for (const a of n.args) checkExprCall(a, env, where);
+}
+var SIDE_EFFECT_CALLS = /* @__PURE__ */ new Set(["http", "email", "ai", "template", "log"]);
+function rewriteExpr(src, bindings, env, where) {
+  const ast = parse(src);
+  checkExprCall(ast, env, where);
+  walkExpr(ast, (path) => {
+    const first = path.segments[0];
+    if (typeof first !== "string") return;
+    const b = bindings.get(first);
+    if (!b && (first === "input" || first === "steps" || first === "vars" || first === "loop")) return;
+    if (!b) throw new Error(`wfjs: \u672A\u58F0\u660E\u53D8\u91CF '${first}'\uFF08in ${where}: ${src}\uFF09`);
+    const prefix = b.kind === "step" ? ["steps", b.id, "data"] : b.kind === "var" ? ["vars", b.name] : ["loop", "item"];
+    path.segments = [...prefix, ...path.segments.slice(1)];
+  });
+  return toSrc(ast);
+}
+function walkExpr(node, visit) {
+  const n = node;
+  if (!n || typeof n !== "object") return;
+  if (n.kind === "path") visit(n);
+  if (n.kind === "ternary") {
+    walkExpr(n.cond, visit);
+    walkExpr(n.then, visit);
+    walkExpr(n.else, visit);
+    return;
+  }
+  if (n.kind === "call") {
+    for (const a of n.args) walkExpr(a, visit);
+    return;
+  }
+  for (const key of [["left", "right"], ["operand"]]) {
+    for (const k of key) {
+      if (n[k] && typeof n[k] === "object") walkExpr(n[k], visit);
+    }
+  }
+}
+function unusedName(env, base) {
+  for (let i = 1; ; i++) {
+    const name = `${base}${i}`;
+    if (!env.bindings.has(name) && !env.steps.some((s) => s.id === name)) return name;
+  }
+}
+var FIELD_KIND = {
+  http: { url: "template", method: "template", body: "template", headers: "template", timeoutMs: "template" },
+  email: { to: "template", subject: "template", body: "template" },
+  ai: { prompt: "template", system: "template" },
+  template: { template: "template" },
+  log: { message: "template" },
+  stop: {},
+  store: { key: "expr", value: "expr" }
+};
+function compileValue(v, env, where, kind) {
+  switch (v.t) {
+    case "str":
+      return kind === "expr" ? `'${v.v.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'` : v.v;
+    case "num":
+      return kind === "expr" ? String(v.v) : String(v.v);
+    case "expr":
+      return kind === "template" ? `{{${rewriteExpr(v.src, env.bindings, env, where)}}}` : rewriteExpr(v.src, env.bindings, env, where);
+    case "tpl": {
+      if (kind === "expr") throw new Error(`wfjs: \u8868\u8FBE\u5F0F\u5B57\u6BB5\u4E0D\u652F\u6301\u6A21\u677F\u4E32\uFF08in ${where}\uFF09`);
+      let out = "";
+      for (const p of v.parts) {
+        if (typeof p === "string") out += p;
+        else out += `{{${rewriteExpr(p.expr, env.bindings, env, where)}}}`;
+      }
+      return out;
+    }
+    case "obj": {
+      const out = {};
+      for (const kv of v.kvs) out[kv.key] = compileValue(kv.value, env, where, kind);
+      return out;
+    }
+  }
+}
+function compileArg(kv, type, env) {
+  if (kv.key === null) {
+    const v = kv.value;
+    if (v.t === "expr") return `{{${rewriteExpr(v.src, env.bindings, env, `store \u53C2\u6570`)}}}`;
+    if (v.t === "str") return v.v;
+    if (v.t === "num") return String(v.v);
+    throw new Error(`wfjs: store \u53C2\u6570\u5FC5\u987B\u662F\u8868\u8FBE\u5F0F\u6216\u5B57\u9762\u91CF`);
+  }
+  const kind = FIELD_KIND[type]?.[kv.key] ?? "template";
+  return compileValue(kv.value, env, `${type}(${kv.key})`, kind);
+}
+function childEnv(parent, steps2) {
+  return { bindings: new Map(parent.bindings), consts: new Set(parent.consts), steps: steps2, imports: parent.imports, stdBindings: parent.stdBindings, stdFns: parent.stdFns, scopes: [...parent.scopes, { names: /* @__PURE__ */ new Set() }], hideCount: parent.hideCount, functions: parent.functions, inFunction: parent.inFunction, autoPrefix: parent.autoPrefix, exports: parent.exports, remoteImports: parent.remoteImports };
+}
+function declareName(env, name, where) {
+  const top = env.scopes[env.scopes.length - 1];
+  if (top.names.has(name)) throw new Error(`wfjs: \u91CD\u590D\u58F0\u660E '${name}'\uFF08${where}\uFF09`);
+  const shadowed = env.scopes.slice(0, -1).some((s) => s.names.has(name));
+  let internal = name;
+  if (shadowed) {
+    const used = /* @__PURE__ */ new Set();
+    for (const b of env.bindings.values()) {
+      if (b.kind === "var") used.add(b.name);
+      else if (b.kind === "step") used.add(b.id);
+    }
+    do {
+      env.hideCount++;
+      internal = `${name}$${env.hideCount}`;
+    } while (used.has(internal));
+  }
+  top.names.add(name);
+  return internal;
+}
+function compileStmt(stmt, env, inLoop) {
+  const auto = () => unusedName(env, `${env.autoPrefix}_${stmt.k}`);
+  switch (stmt.k) {
+    case "export": {
+      const all = env.functions;
+      const check = (n) => {
+        if (!all.some((f) => f.name === n)) throw new Error(`wfjs: \u5BFC\u51FA '${n}' \u5FC5\u987B\u662F\u5DF2\u5B9A\u4E49\u51FD\u6570\uFF08v1 \u51FD\u6570\u5BFC\u51FA\u2014\u2014\u53D8\u91CF\u5BFC\u51FA v2\uFF09`);
+      };
+      stmt.named.forEach((n) => check(n.name));
+      if (stmt.default) check(stmt.default);
+      if (stmt.named.length === 0 && !stmt.default) throw new Error("wfjs: export \u5FC5\u987B\u81F3\u5C11\u5BFC\u51FA\u4E00\u4E2A\u6210\u5458");
+      env.exports.named.push(...stmt.named);
+      if (stmt.default) env.exports.default = stmt.default;
+      return;
+    }
+    case "function": {
+      if (env.inFunction) throw new Error(`wfjs: \u4E0D\u652F\u6301\u5D4C\u5957\u51FD\u6570\uFF08\u51FD\u6570 '${stmt.name}'\uFF09`);
+      const rec = env.functions.find((f) => f.name === stmt.name);
+      if (!rec) throw new Error(`wfjs: \u5185\u90E8\u9519\u8BEF\uFF1A\u51FD\u6570 '${stmt.name}' \u672A\u9884\u6CE8\u518C`);
+      const fnBindings = /* @__PURE__ */ new Map();
+      const fnScopeNames = /* @__PURE__ */ new Set();
+      const fnScopes = [...env.scopes, { names: fnScopeNames }];
+      for (const p of stmt.params) {
+        if (fnScopeNames.has(p)) throw new Error(`wfjs: \u91CD\u590D\u53C2\u6570 '${p}'`);
+        fnScopeNames.add(p);
+        fnBindings.set(p, { kind: "var", name: p });
+      }
+      for (const [n, b] of env.bindings) if (b.kind === "var" && !fnScopeNames.has(n)) fnBindings.set(n, b);
+      const fnEnv = {
+        bindings: fnBindings,
+        consts: /* @__PURE__ */ new Set(),
+        steps: [],
+        imports: env.imports,
+        stdBindings: env.stdBindings,
+        stdFns: env.stdFns,
+        scopes: fnScopes,
+        hideCount: env.hideCount,
+        functions: env.functions,
+        inFunction: true,
+        autoPrefix: `_fn:${stmt.name}:`,
+        exports: env.exports,
+        remoteImports: env.remoteImports
+      };
+      compileInto(stmt.body, fnEnv, false);
+      rec.step = { steps: fnEnv.steps };
+      return;
+    }
+    case "import": {
+      const isStd = stmt.from.startsWith("wf://std/");
+      if (isStd) {
+        const mod = STD_MODULES[stmt.from] ?? (stmt.from === "wf://std/store" ? { store: null } : void 0);
+        if (!mod) throw new Error(`wfjs: std \u6A21\u5757 '${stmt.from}' \u672A\u6CE8\u518C\uFF08${Object.keys(STD_MODULES).join(" / ")} \u4E0E wf://std/store\uFF09`);
+        for (const { name, as } of stmt.names) {
+          const bound = as ?? name;
+          if (name === "store" && stmt.from === "wf://std/store") {
+            env.stdBindings.set(bound, "store");
+          } else if (mod[name] !== void 0) {
+            env.stdBindings.set(bound, "fn");
+            env.stdFns.add(bound);
+          } else {
+            throw new Error(`wfjs: \u6A21\u5757 '${stmt.from}' \u65E0\u5BFC\u51FA '${name}'`);
+          }
+        }
+        env.imports.push({ from: stmt.from, names: stmt.names });
+        return;
+      }
+      if (!stmt.from.startsWith("https://")) {
+        throw new Error(`wfjs: \u6A21\u5757 '${stmt.from}' \u4E0D\u5408\u6CD5\uFF08wf://std/* \u6216 https://\u2026\uFF09`);
+      }
+      env.imports.push({ from: stmt.from, names: stmt.names });
+      return;
+    }
+    case "var": {
+      const { name } = stmt;
+      if (BUILTIN_NAMES.has(name)) throw new Error(`wfjs: \u53D8\u91CF\u540D '${name}' \u4E0E\u5185\u7F6E\u51FD\u6570\u51B2\u7A81`);
+      const internal = declareName(env, name, `\u58F0\u660E ${name}`);
+      if (stmt.init && isCall(stmt.init)) {
+        const call = stmt.init;
+        if (!BUILTIN_NAMES.has(call.name) && !call.name.startsWith("@")) {
+          if (env.functions.some((f) => f.name === call.name)) {
+            env.steps.push({ id: internal, type: "call", config: { name: call.name, args: callArgsToExprs(call.args, env) } });
+            env.bindings.set(name, { kind: "step", id: internal });
+            if (stmt.isConst) env.consts.add(internal);
+            return;
+          }
+          throw new Error(`wfjs: \u672A\u8BC6\u522B\u8C03\u7528 '${call.name}'\uFF08\u5185\u7F6E\uFF1A${[...BUILTIN_NAMES].join("/")}\uFF1B\u51FD\u6570\u9700\u5148\u58F0\u660E\uFF09`);
+        }
+        if (env.inFunction) throw new Error(`wfjs: \u51FD\u6570\u4F53\u5185\u4E0D\u652F\u6301\u526F\u4F5C\u7528\u5185\u7F6E\uFF08${call.name}\uFF09\u2014\u2014\u51FD\u6570\u662F\u7EAF\u903B\u8F91\uFF08v1 \u88C1\u526A\uFF09`);
+        addBuiltinStep(call, internal, env);
+        env.bindings.set(name, { kind: "step", id: internal });
+      } else {
+        const value = stmt.init ? compileValue(stmt.init, env, `\u58F0\u660E ${name}`, "expr") : "null";
+        env.steps.push({ id: internal, type: "assign", config: { target: internal, value } });
+        env.bindings.set(name, { kind: "var", name: internal });
+      }
+      if (stmt.isConst) env.consts.add(internal);
+      return;
+    }
+    case "assign": {
+      const b = env.bindings.get(stmt.target);
+      if (!b) throw new Error(`wfjs: \u672A\u58F0\u660E\u53D8\u91CF '${stmt.target}'`);
+      const internal = b.kind === "var" ? b.name : b.kind === "step" ? b.id : stmt.target;
+      if (env.consts.has(internal)) throw new Error(`wfjs: \u4E0D\u80FD\u7ED9 const '${stmt.target}' \u8D4B\u503C`);
+      const rhs = rewriteExpr(stmt.value, env.bindings, env, `\u8D4B\u503C ${stmt.target}`);
+      const value = stmt.op === "=" ? rhs : `(vars.${internal} ${stmt.op[0]} ${rhs})`;
+      env.steps.push({ id: auto(), type: "assign", config: { target: internal, value } });
+      return;
+    }
+    case "incdec": {
+      const b = env.bindings.get(stmt.target);
+      if (!b) throw new Error(`wfjs: \u672A\u58F0\u660E\u53D8\u91CF '${stmt.target}'`);
+      const internal = b.kind === "var" ? b.name : b.kind === "step" ? b.id : stmt.target;
+      if (env.consts.has(internal)) throw new Error(`wfjs: \u4E0D\u80FD\u7ED9 const '${stmt.target}' \u8D4B\u503C`);
+      env.steps.push({
+        id: auto(),
+        type: "assign",
+        config: { target: internal, value: `(vars.${internal} ${stmt.inc ? "+" : "-"} 1)` }
+      });
+      return;
+    }
+    case "if": {
+      const when = rewriteExpr(stmt.cond, env.bindings, env, "if \u6761\u4EF6");
+      const then = [];
+      compileInto(stmt.then, childEnv(env, then), inLoop);
+      const config = { when };
+      if (stmt.once) config.edge = true;
+      if (then.length) config.then = { steps: then };
+      if (stmt.else) {
+        const elseSteps = [];
+        compileInto(stmt.else, childEnv(env, elseSteps), inLoop);
+        if (elseSteps.length) config.else = { steps: elseSteps };
+      }
+      env.steps.push({ id: auto(), type: "if", config });
+      return;
+    }
+    case "try": {
+      const body = [];
+      compileInto(stmt.body, childEnv(env, body), inLoop);
+      const catchSteps = [];
+      compileInto(stmt.catchBody, childEnv(env, catchSteps), inLoop);
+      const config = { step: { steps: body }, catch: { steps: catchSteps } };
+      env.steps.push({ id: auto(), type: "try", config });
+      return;
+    }
+    case "while": {
+      const when = rewriteExpr(stmt.cond, env.bindings, env, "while \u6761\u4EF6");
+      const body = [];
+      compileInto(stmt.body, childEnv(env, body), true);
+      env.steps.push({ id: auto(), type: "while", config: { when, step: { steps: body } } });
+      return;
+    }
+    case "forof": {
+      const items = rewriteExpr(stmt.items, env.bindings, env, "for-of");
+      const child = childEnv(env, []);
+      child.bindings.set(stmt.varName, { kind: "loop" });
+      child.scopes[child.scopes.length - 1].names.add(stmt.varName);
+      const body = [];
+      compileInto(stmt.body, childEnv(child, body), true);
+      env.steps.push({ id: auto(), type: "for", config: { items, step: { steps: body } } });
+      return;
+    }
+    case "return": {
+      const value = stmt.value ? compileValue(stmt.value, env, "return", "expr") : void 0;
+      env.steps.push({ id: auto(), type: "return", config: value !== void 0 ? { value } : {} });
+      return;
+    }
+    case "call": {
+      if (!BUILTIN_NAMES.has(stmt.call.name) && !stmt.call.name.startsWith("@")) {
+        if (!env.functions.some((f) => f.name === stmt.call.name)) {
+          throw new Error(`wfjs: \u672A\u8BC6\u522B\u8C03\u7528 '${stmt.call.name}'\uFF08\u5185\u7F6E\uFF1A${[...BUILTIN_NAMES].join("/")}\uFF1B\u51FD\u6570\u9700\u5148\u58F0\u660E\uFF09`);
+        }
+        env.steps.push({ id: auto(), type: "call", config: { name: stmt.call.name, args: callArgsToExprs(stmt.call.args, env) } });
+        return;
+      }
+      if (env.inFunction) throw new Error(`wfjs: \u51FD\u6570\u4F53\u5185\u4E0D\u652F\u6301\u526F\u4F5C\u7528\u5185\u7F6E\uFF08${stmt.call.name}\uFF09\u2014\u2014\u51FD\u6570\u662F\u7EAF\u903B\u8F91\uFF08v1 \u88C1\u526A\uFF09`);
+      addBuiltinStep(stmt.call, null, env);
+      return;
+    }
+  }
+}
+function callArgsToExprs(args, env) {
+  return args.map((a) => {
+    if (a.key !== null) throw new Error(`wfjs: \u51FD\u6570\u8C03\u7528\u4E0D\u652F\u6301\u547D\u540D\u53C2\u6570`);
+    const v = a.value;
+    if (v.t === "expr") return rewriteExpr(v.src, env.bindings, env, `\u51FD\u6570\u53C2\u6570`);
+    if (v.t === "str") return `'${v.v.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+    if (v.t === "num") return String(v.v);
+    if (v.t === "tpl") {
+      let out = "`";
+      for (const p of v.parts) {
+        if (typeof p === "string") out += p;
+        else out += "${" + rewriteExpr(p.expr, env.bindings, env, "\u51FD\u6570\u53C2\u6570\u6A21\u677F") + "}";
+      }
+      return out + "`";
+    }
+    throw new Error(`wfjs: \u51FD\u6570\u53C2\u6570\u503C\u4E0D\u5408\u6CD5`);
+  });
+}
+function isCall(v) {
+  return typeof v.name === "string" && Array.isArray(v.args);
+}
+function compileInto(stmts, env, inLoop) {
+  for (const s of stmts) compileStmt(s, env, inLoop);
+}
+function addBuiltinStep(call, bindId, env) {
+  if (call.name === "@store.get" || call.name === "@store.set") {
+    const method = call.name.slice(1);
+    const op = method.endsWith(".get") ? "get" : "set";
+    if (!env.stdBindings.has("store") || env.stdBindings.get("store") !== "store") {
+      throw new Error(`wfjs: \u4F7F\u7528 store \u524D\u9700\u5BFC\u5165\uFF1Aimport { store } from 'wf://std/store'`);
+    }
+    if (call.args.length !== (op === "get" ? 1 : 2)) {
+      throw new Error(`wfjs: ${method}() \u53C2\u6570\u6570\u91CF\u9519\u8BEF\uFF08${op === "get" ? "key" : "key, value"}\uFF09\uFF0C\u6536\u5230 ${call.args.length}`);
+    }
+    const config2 = { op, key: compileArg(call.args[0], "store", env) };
+    if (op === "set") config2.value = compileArg(call.args[1], "store", env);
+    env.steps.push({ id: bindId ?? unusedName(env, `_store${op}`), type: "store", config: config2 });
+    return;
+  }
+  if (!BUILTIN_NAMES.has(call.name)) {
+    throw new Error(`wfjs: \u672A\u8BC6\u522B\u8C03\u7528 '${call.name}'\uFF08\u5185\u7F6E\uFF1A${[...BUILTIN_NAMES].join("/")}\uFF1B\u51FD\u6570\u8C03\u7528\u5728 W8 wave\uFF09`);
+  }
+  const id = bindId ?? unusedName(env, `_${call.name}`);
+  const config = {};
+  for (const arg of call.args) {
+    config[arg.key] = compileArg(arg, call.name, env);
+  }
+  env.steps.push({ id, type: call.name === "stop" ? "return" : call.name, config });
+}
+function validateRemoteModule(url, raw) {
+  const m = raw;
+  if (!m || typeof m !== "object" || !Array.isArray(m.functions)) {
+    throw new Error(`wfjs: \u8FDC\u7A0B\u6A21\u5757 '${url}' \u683C\u5F0F\u4E0D\u5408\u6CD5\uFF08\u671F\u671B { functions: [...] }\u2014\u2014\u767D\u540D\u5355\uFF09`);
+  }
+  for (const [i, f] of m.functions.entries()) {
+    const fn = f;
+    if (typeof fn.name !== "string" || !Array.isArray(fn.params) || typeof fn.step !== "object") {
+      throw new Error(`wfjs: \u8FDC\u7A0B\u6A21\u5757 '${url}' functions[${i}] \u7F3A\u5B57\u6BB5\uFF08name/params/step\uFF09`);
+    }
+  }
+  return { functions: m.functions };
+}
+async function compileWfjs(src, opts) {
+  const parser = new WfjsParser(tokenizeWfjs(src), src);
+  const stmts = parser.parseProgram();
+  const env = { bindings: /* @__PURE__ */ new Map(), consts: /* @__PURE__ */ new Set(), steps: [], imports: [], stdBindings: /* @__PURE__ */ new Map(), stdFns: /* @__PURE__ */ new Set(), scopes: [{ names: /* @__PURE__ */ new Set() }], hideCount: 0, functions: [], inFunction: false, autoPrefix: "", exports: { named: [] }, remoteImports: [] };
+  for (const stmt of stmts) {
+    if (stmt.k === "function") {
+      if (BUILTIN_NAMES.has(stmt.name)) throw new Error(`wfjs: \u51FD\u6570\u540D '${stmt.name}' \u4E0E\u5185\u7F6E\u51B2\u7A81`);
+      if (env.functions.some((f) => f.name === stmt.name)) throw new Error(`wfjs: \u91CD\u590D\u51FD\u6570 '${stmt.name}'`);
+      env.functions.push({ name: stmt.name, params: stmt.params, step: { steps: [] } });
+    }
+  }
+  for (const stmt of stmts) {
+    if (stmt.k === "import" && !stmt.from.startsWith("wf://std/")) env.remoteImports.push({ from: stmt.from, names: stmt.names });
+  }
+  for (const imp of env.remoteImports) {
+    if (!opts?.remoteFetch) {
+      throw new Error(`wfjs: \u8FDC\u7A0B\u5BFC\u5165 '${imp.from}' \u9700\u8981 compileWfjs({ remoteFetch })`);
+    }
+    const raw = await opts.remoteFetch(imp.from);
+    const mod = validateRemoteModule(imp.from, raw);
+    for (const { name, as } of imp.names) {
+      const bound = as ?? name;
+      const fn = mod.functions.find((f) => f.name === name);
+      if (!fn) throw new Error(`wfjs: \u8FDC\u7A0B\u6A21\u5757 '${imp.from}' \u65E0\u5BFC\u51FA\u51FD\u6570 '${name}'`);
+      if (env.functions.some((f) => f.name === bound)) throw new Error(`wfjs: \u51FD\u6570\u540D '${bound}' \u51B2\u7A81\uFF08\u8FDC\u7A0B\u5BFC\u5165\uFF09`);
+      env.functions.push({ ...fn, name: bound });
+    }
+  }
+  compileInto(stmts, env, false);
+  const def = { steps: env.steps };
+  if (env.imports.length) def.imports = env.imports;
+  if (env.functions.length) def.functions = env.functions;
+  if (env.exports.named.length || env.exports.default) def.exports = env.exports;
+  return def;
+}
+
+// src/server/workflow/tojs.ts
+function toJs(def) {
+  const head = renderImports(def.imports ?? []);
+  const fns = renderFunctions(def.functions ?? []);
+  const body = renderChain(def.steps, {
+    seenVars: /* @__PURE__ */ new Set(),
+    loopNames: [],
+    inReturn: false
+  }).trimEnd();
+  const tail = renderExports(def.exports);
+  const parts = [head, fns, body, tail].filter(Boolean);
+  return parts.join("\n\n");
+}
+function renderExports(exports) {
+  if (!exports) return "";
+  const lines = [];
+  if ((exports.named ?? []).length) {
+    lines.push(`export { ${exports.named.map((n) => n.as && n.as !== n.name ? `${n.name} as ${n.as}` : n.name).join(", ")} }`);
+  }
+  if (exports.default) lines.push(`export default ${exports.default}`);
+  return lines.join("\n");
+}
+function renderFunctions(functions) {
+  if (!functions?.length) return "";
+  return functions.map((f) => {
+    const ctx = { seenVars: /* @__PURE__ */ new Set(), loopNames: [], inReturn: false };
+    const body = renderChain(f.step.steps, ctx);
+    return `function ${f.name}(${f.params.join(", ")}) {
+${indent(body)}
+}`;
+  }).join("\n");
+}
+function renderImports(imports) {
+  if (!imports?.length) return "";
+  return imports.map((imp) => {
+    const names = imp.names.map((n) => n.as && n.as !== n.name ? `${n.name} as ${n.as}` : n.name).join(", ");
+    return `import { ${names} } from '${imp.from}'`;
+  }).join("\n");
+}
+function renderChain(steps2, ctx) {
+  return steps2.map((s) => renderStep(s, ctx)).join("\n");
+}
+function rewritePathExpr(src, ctx) {
+  const map = (segments) => {
+    const [s0, s1, s2, ...rest] = segments;
+    if (s0 === "steps" && typeof s1 === "string" && (s2 === "data" || s2 === "result") && !s1.startsWith("_")) {
+      return [s1, ...segments.slice(3)];
+    }
+    if (s0 === "vars" && typeof s1 === "string") return [s1, ...segments.slice(2)];
+    if (s0 === "loop" && s1 === "item") return [ctx.loopNames[ctx.loopNames.length - 1] ?? "it", ...segments.slice(2)];
+    return null;
+  };
+  return rewritePath(src, map);
+}
+function rewritePath(src, map) {
+  const ast = parse(src);
+  const walk = (n) => {
+    const node = n;
+    if (!node || typeof node !== "object") return;
+    if (node.kind === "path" && node.segments) {
+      const mapped = map(node.segments);
+      if (mapped) node.segments = mapped;
+      return;
+    }
+    if (node.kind === "ternary") {
+      walk(node.cond);
+      walk(node.then);
+      walk(node.else);
+      return;
+    }
+    if (node.kind === "call") {
+      node.args?.forEach(walk);
+      return;
+    }
+    for (const k of ["left", "right", "operand"]) walk(node[k]);
+  };
+  walk(ast);
+  return toSrc(ast);
+}
+function renderValue(v, kind, ctx) {
+  if (typeof v !== "string") return JSON.stringify(v);
+  if (kind === "expr") return rewritePathExpr(v, ctx);
+  if (!v.includes("{{")) return `'${v.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+  let out = "`";
+  let i = 0;
+  for (; ; ) {
+    const start = v.indexOf("{{", i);
+    if (start === -1) {
+      out += v.slice(i).replace(/`/g, "\\`").replace(/\\/g, "\\\\");
+      break;
+    }
+    out += v.slice(i, start).replace(/`/g, "\\`").replace(/\\/g, "\\\\");
+    const end = v.indexOf("}}", start + 2);
+    if (end === -1) break;
+    out += "${" + rewritePathExpr(v.slice(start + 2, end), ctx) + "}";
+    i = end + 2;
+  }
+  return out + "`";
+}
+function renderObjectParams(type, config, ctx) {
+  const parts = [];
+  for (const [key, v] of Object.entries(config)) {
+    if (v === void 0) continue;
+    const kind = FIELD_KIND[type]?.[key] ?? "template";
+    if (v && typeof v === "object" && !Array.isArray(v)) {
+      parts.push(`${key}: { ${renderObjectParams(type, v, ctx)} }`);
+      continue;
+    }
+    parts.push(`${key}: ${renderValue(v, kind, ctx)}`);
+  }
+  return parts.join(", ");
+}
+function renderBuiltin(step, ctx) {
+  const config = step.config ?? {};
+  if (step.type === "call") {
+    const args = (config.args ?? []).map((a) => rewritePathExpr(a, ctx)).join(", ");
+    const call2 = `await ${config.name}(${args})`;
+    return step.id.startsWith("_") || step.id.includes(":") ? call2 : `const ${step.id} = ${call2}`;
+  }
+  if (step.type === "store") {
+    const key = renderValue(String(config.key), "template", ctx);
+    const method = config.op === "get" ? "get" : "set";
+    const args = config.op === "set" ? `${key}, ${renderValue(String(config.value ?? ""), "template", ctx)}` : key;
+    const call2 = `await store.${method}(${args})`;
+    return step.id.startsWith("_") ? call2 : `const ${step.id} = ${call2}`;
+  }
+  const params = renderObjectParams(step.type, config, ctx);
+  const call = `await ${step.type}({ ${params} })`;
+  return step.id.startsWith("_") ? call : `const ${step.id} = ${call}`;
+}
+function renderStep(step, ctx) {
+  switch (step.type) {
+    case "assign": {
+      const cfg = step.config;
+      const value = rewritePathExpr(cfg.value, ctx);
+      if (!ctx.seenVars.has(cfg.target)) {
+        ctx.seenVars.add(cfg.target);
+        return `let ${cfg.target} = ${value}`;
+      }
+      return `${cfg.target} = ${value}`;
+    }
+    case "if": {
+      const cfg = step.config;
+      const when = rewritePathExpr(cfg.when, ctx);
+      const head = `if (${when}) {`;
+      const lines = [head];
+      if (cfg.then?.steps.length) lines.push(indent(renderChain(cfg.then.steps, childLoopCtx(ctx))));
+      if (cfg.else?.steps.length) {
+        lines.push(cfg.then?.steps.length ? "} else {" : "} else {");
+        lines.push(indent(renderChain(cfg.else.steps, childLoopCtx(ctx))));
+      }
+      lines.push("}");
+      return lines.join("\n");
+    }
+    case "try": {
+      const cfg = step.config;
+      const lines = ["try {"];
+      if (cfg.step?.steps.length) lines.push(indent(renderChain(cfg.step.steps, childLoopCtx(ctx))));
+      lines.push("} catch {");
+      if (cfg.catch?.steps.length) lines.push(indent(renderChain(cfg.catch.steps, childLoopCtx(ctx))));
+      lines.push("}");
+      return lines.join("\n");
+    }
+    case "while": {
+      const cfg = step.config;
+      const when = rewritePathExpr(cfg.when, ctx);
+      return `while (${when}) {
+${indent(renderChain(cfg.step.steps, childLoopCtx(ctx)))}
+}`;
+    }
+    case "for": {
+      const cfg = step.config;
+      const items = rewritePathExpr(cfg.items, ctx);
+      const loopName = `it${ctx.loopNames.length}`;
+      return `for (const ${loopName} of ${items}) {
+${indent(renderChain(cfg.step.steps, { ...ctx, loopNames: [...ctx.loopNames, loopName] }))}
+}`;
+    }
+    case "return": {
+      const cfg = step.config;
+      return cfg.value !== void 0 ? `return ${rewritePathExpr(cfg.value, ctx)}` : "return";
+    }
+    default:
+      return renderBuiltin(step, ctx);
+  }
+}
+function childLoopCtx(ctx) {
+  return { ...ctx, inReturn: false };
+}
+function indent(s) {
+  return s.split("\n").map((l) => "  " + l).join("\n");
+}
+
+// src/server/workflow/index.ts
+function workflow(options) {
+  const handlers = /* @__PURE__ */ new Map();
+  for (const s of builtinSteps()) handlers.set(s.type, s);
+  const env = {
+    fetch: options?.fetch,
+    ai: options?.ai,
+    email: options?.email,
+    log: options?.log,
+    store: options?.store ?? (options?.redis ? redisStore(options.redis) : void 0)
+  };
+  const registry = {
+    get: (type) => handlers.get(type),
+    has: (type) => handlers.has(type),
+    schema: (type) => {
+      const h = handlers.get(type);
+      if (!h) return void 0;
+      return { required: h.required ?? [], fields: h.fields };
+    }
+  };
+  return {
+    validate: (def) => validate(def, registry),
+    execute: (def, opts) => runWorkflow(def, opts ?? {}, env, registry),
+    registerStep: (handler) => {
+      handlers.set(handler.type, handler);
+    },
+    stepSchemas: () => [...handlers.values()].map((h) => ({
+      type: h.type,
+      label: h.label,
+      fields: h.fields,
+      required: h.required ?? []
+    }))
+  };
+}
+export {
+  compile,
+  compileWfjs,
+  evaluate,
+  evaluateBoolean,
+  interpolate,
+  parse,
+  redisStore,
+  toJs,
+  toJsonSchema,
+  workflow,
+  workflowToDag
+};