@baipeng139/72flow-nodejs 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1141 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FlowContext: () => FlowContext,
+  FlowEngine: () => FlowEngine,
+  NodeExecutorFactory: () => NodeExecutorFactory,
+  NodeStatus: () => NodeStatus,
+  NodeType: () => NodeType,
+  X6Parser: () => X6Parser,
+  createLogger: () => createLogger,
+  parseX6: () => parseX6
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types/models.ts
+var NodeStatus = /* @__PURE__ */ ((NodeStatus2) => {
+  NodeStatus2["PENDING"] = "PENDING";
+  NodeStatus2["RUNNING"] = "RUNNING";
+  NodeStatus2["COMPLETED"] = "COMPLETED";
+  NodeStatus2["FAILED"] = "FAILED";
+  NodeStatus2["SKIPPED"] = "SKIPPED";
+  NodeStatus2["CANCELLED"] = "CANCELLED";
+  return NodeStatus2;
+})(NodeStatus || {});
+var NodeType = /* @__PURE__ */ ((NodeType3) => {
+  NodeType3["START"] = "START";
+  NodeType3["END"] = "END";
+  NodeType3["SCRIPT"] = "SCRIPT";
+  NodeType3["DECISION"] = "DECISION";
+  NodeType3["CONDITION"] = "CONDITION";
+  NodeType3["PARALLEL"] = "PARALLEL";
+  NodeType3["LOOP"] = "LOOP";
+  NodeType3["API"] = "API";
+  NodeType3["SUBFLOW"] = "SUBFLOW";
+  NodeType3["LLM"] = "LLM";
+  NodeType3["BUSINESS"] = "BUSINESS";
+  return NodeType3;
+})(NodeType || {});
+
+// src/core/flow-context.ts
+var FlowContext = class {
+  executionId;
+  definition;
+  variables;
+  status = "PENDING" /* PENDING */;
+  startTime;
+  endTime;
+  // ── 性能索引（O(1) 查询）────────────────
+  nodeMap = /* @__PURE__ */ new Map();
+  outgoingMap = /* @__PURE__ */ new Map();
+  incomingMap = /* @__PURE__ */ new Map();
+  // ── 执行状态 ─────────────────────────────
+  completedNodes = /* @__PURE__ */ new Set();
+  executingNodes = /* @__PURE__ */ new Set();
+  skippedNodes = /* @__PURE__ */ new Set();
+  nodeOutputs = {};
+  convergeStates = /* @__PURE__ */ new Map();
+  traces = [];
+  constructor(executionId, definition, variables) {
+    this.executionId = executionId;
+    this.definition = definition;
+    this.variables = { ...variables };
+    this.startTime = Date.now();
+    this.buildIndex();
+  }
+  /** 构造时预建索引，所有后续查询均为 O(1) */
+  buildIndex() {
+    for (const node of this.definition.nodes) {
+      this.nodeMap.set(node.id, node);
+    }
+    for (const edge of this.definition.edges) {
+      if (!this.outgoingMap.has(edge.from)) this.outgoingMap.set(edge.from, []);
+      if (!this.incomingMap.has(edge.to)) this.incomingMap.set(edge.to, []);
+      this.outgoingMap.get(edge.from).push(edge);
+      this.incomingMap.get(edge.to).push(edge);
+    }
+  }
+  // ── Getters ──────────────────────────────
+  getExecutionId() {
+    return this.executionId;
+  }
+  getDefinition() {
+    return this.definition;
+  }
+  getVariables() {
+    return { ...this.variables };
+  }
+  getStatus() {
+    return this.status;
+  }
+  getStartTime() {
+    return this.startTime;
+  }
+  getEndTime() {
+    return this.endTime;
+  }
+  getDuration() {
+    return (this.endTime ?? Date.now()) - this.startTime;
+  }
+  getNodes() {
+    return this.definition.nodes;
+  }
+  getNode(id) {
+    return this.nodeMap.get(id);
+  }
+  getOutgoing(nodeId) {
+    return this.outgoingMap.get(nodeId) ?? [];
+  }
+  getIncoming(nodeId) {
+    return this.incomingMap.get(nodeId) ?? [];
+  }
+  getCompletedNodes() {
+    return this.completedNodes;
+  }
+  getSkippedNodes() {
+    return this.skippedNodes;
+  }
+  getExecutingNodes() {
+    return this.executingNodes;
+  }
+  getNodeOutputs() {
+    return { ...this.nodeOutputs };
+  }
+  getTraces() {
+    return [...this.traces];
+  }
+  setStatus(status) {
+    this.status = status;
+    if (["COMPLETED" /* COMPLETED */, "FAILED" /* FAILED */, "CANCELLED" /* CANCELLED */].includes(status)) {
+      this.endTime = Date.now();
+    }
+  }
+  /** 设置单个变量（供 LoopExecutor 写入 item/index 等迭代变量） */
+  setVariable(key, value) {
+    this.variables[key] = value;
+  }
+  skipNode(nodeId) {
+    this.skippedNodes.add(nodeId);
+  }
+  /** 注册并行汇聚点，expected = 分支数 */
+  registerConvergence(nodeId, expected) {
+    this.convergeStates.set(nodeId, { arrived: /* @__PURE__ */ new Set(), expected });
+  }
+  // ── 前置依赖检查（带跳过传播）────────────
+  arePrerequisitesMet(nodeId) {
+    const incoming = this.getIncoming(nodeId);
+    if (incoming.length === 0) return true;
+    return incoming.every(
+      (e) => this.completedNodes.has(e.from) || this.isEffectivelySkipped(e.from, /* @__PURE__ */ new Set())
+    );
+  }
+  isEffectivelySkipped(nodeId, visited) {
+    if (this.skippedNodes.has(nodeId)) return true;
+    if (this.completedNodes.has(nodeId)) return false;
+    if (visited.has(nodeId)) return false;
+    visited.add(nodeId);
+    const incoming = this.getIncoming(nodeId);
+    if (incoming.length === 0) return false;
+    return incoming.every((e) => this.isEffectivelySkipped(e.from, visited));
+  }
+  // ── 执行状态管理 ─────────────────────────
+  tryExecute(nodeId) {
+    if (this.executingNodes.has(nodeId)) return false;
+    this.executingNodes.add(nodeId);
+    return true;
+  }
+  complete(nodeId, output, startTime) {
+    const endTime = Date.now();
+    this.executingNodes.delete(nodeId);
+    this.completedNodes.add(nodeId);
+    const node = this.getNode(nodeId);
+    if (node) {
+      const key = node.code ?? nodeId;
+      if (output !== void 0 && output !== null) {
+        this.nodeOutputs[key] = output;
+      }
+      if (output && typeof output === "object" && !Array.isArray(output)) {
+        for (const [k, v] of Object.entries(output)) {
+          if (!k.startsWith("__")) {
+            this.variables[k] = v;
+          }
+        }
+      }
+    }
+    const durationMs = endTime - startTime;
+    this.traces.push({
+      nodeId,
+      code: node?.code ?? nodeId,
+      status: "COMPLETED" /* COMPLETED */,
+      startTime,
+      endTime,
+      duration: durationMs,
+      durationNs: durationMs * 1e6,
+      // 毫秒 → 纳秒，与 Java 对齐
+      data: output
+    });
+  }
+  fail(nodeId, error, startTime) {
+    const endTime = Date.now();
+    this.executingNodes.delete(nodeId);
+    const message = error instanceof Error ? error.message : error;
+    const durationMs = endTime - startTime;
+    const failNode = this.getNode(nodeId);
+    this.traces.push({
+      nodeId,
+      code: failNode?.code ?? nodeId,
+      status: "FAILED" /* FAILED */,
+      startTime,
+      endTime,
+      duration: durationMs,
+      durationNs: durationMs * 1e6,
+      error: message
+    });
+  }
+  /** 并行汇聚：返回 true 代表当前节点所有分支已全部到达 */
+  tryConverge(nodeId, fromNodeId) {
+    const state = this.convergeStates.get(nodeId);
+    if (state) {
+      state.arrived.add(fromNodeId);
+      return state.arrived.size >= state.expected;
+    }
+    const incoming = this.getIncoming(nodeId);
+    if (incoming.length > 1) {
+      if (!this.convergeStates.has(nodeId)) {
+        this.convergeStates.set(nodeId, { arrived: /* @__PURE__ */ new Set(), expected: incoming.length });
+      }
+      const s = this.convergeStates.get(nodeId);
+      s.arrived.add(fromNodeId);
+      return s.arrived.size >= s.expected;
+    }
+    return true;
+  }
+  /** 获取 LOOP_START 节点的循环体路径（来自解析器预计算的 loopBodyPaths） */
+  getLoopBodyPath(loopStartNodeId) {
+    return this.definition.loopBodyPaths?.[loopStartNodeId] ?? [];
+  }
+};
+
+// src/support/logger.ts
+var isDev = typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
+function log(level, tag, message, ...args) {
+  if (level === "debug" && !isDev) return;
+  const prefix = `[72flow][${tag}]`;
+  switch (level) {
+    case "debug":
+      console.debug(prefix, message, ...args);
+      break;
+    case "info":
+      console.info(prefix, message, ...args);
+      break;
+    case "warn":
+      console.warn(prefix, message, ...args);
+      break;
+    case "error":
+      console.error(prefix, message, ...args);
+      break;
+  }
+}
+function createLogger(tag) {
+  return {
+    debug: (msg, ...args) => log("debug", tag, msg, ...args),
+    info: (msg, ...args) => log("info", tag, msg, ...args),
+    warn: (msg, ...args) => log("warn", tag, msg, ...args),
+    error: (msg, ...args) => log("error", tag, msg, ...args)
+  };
+}
+
+// src/executors/factory.ts
+var log2 = createLogger("Executor");
+var NodeExecutorFactory = class {
+  static async execute(node, context) {
+    const type = String(node.type).toUpperCase();
+    log2.info(`\u6267\u884C\u8282\u70B9 [${node.id}] \u7C7B\u578B=${type}`);
+    switch (type) {
+      case "START":
+        return StartExecutor.execute(node, context);
+      case "END":
+        return EndExecutor.execute(node, context);
+      case "SCRIPT":
+        return ScriptExecutor.execute(node, context);
+      case "DECISION":
+      case "CONDITION":
+        return DecisionExecutor.execute(node, context);
+      case "PARALLEL":
+        return ParallelExecutor.execute(node, context);
+      case "LOOP":
+        return await LoopExecutor.execute(node, context);
+      case "API":
+        return await ApiExecutor.execute(node, context);
+      case "LLM":
+        return await LlmExecutor.execute(node, context);
+      default:
+        log2.warn(`\u4E0D\u652F\u6301\u7684\u8282\u70B9\u7C7B\u578B: ${type}`);
+        return { success: false, message: `Unsupported node type: ${type}` };
+    }
+  }
+};
+var StartExecutor = class {
+  static execute(node, context) {
+    return { success: true };
+  }
+};
+var EndExecutor = class {
+  static execute(node, context) {
+    return { success: true, data: context.getVariables() };
+  }
+};
+var ScriptExecutor = class {
+  static execute(node, context) {
+    const cfg = node.config;
+    const scriptCfg = cfg?.script ?? {};
+    const scriptCode = typeof scriptCfg === "string" ? scriptCfg : scriptCfg?.scriptCode ?? scriptCfg?.code;
+    const scriptType = String(scriptCfg?.scriptType ?? "javascript").toLowerCase();
+    if (scriptType === "groovy") {
+      log2.warn(`SCRIPT \u8282\u70B9 [${node.id}] \u4F7F\u7528 Groovy \u8BED\u6CD5\uFF0C\u6D4F\u89C8\u5668\u5F15\u64CE\u4E0D\u652F\u6301\uFF0C\u8BF7\u5207\u6362\u5230 Java \u6267\u884C\u6A21\u5F0F`);
+      return {
+        success: false,
+        message: "\u6D4F\u89C8\u5668\u5F15\u64CE\u4E0D\u652F\u6301 Groovy \u811A\u672C\uFF0C\u8BF7\u5728\u8282\u70B9\u914D\u7F6E\u4E2D\u5C06\u8BED\u8A00\u6539\u4E3A JavaScript\uFF0C\u6216\u5207\u6362\u5230 Java \u6267\u884C\u6A21\u5F0F"
+      };
+    }
+    if (!scriptCode?.trim()) {
+      log2.warn(`SCRIPT \u8282\u70B9 [${node.id}] \u65E0\u811A\u672C\uFF0C\u8DF3\u8FC7`);
+      return { success: true };
+    }
+    try {
+      const vars = context.getVariables();
+      const writes = {};
+      const proxy = new Proxy(vars, {
+        get(target, key) {
+          return key in writes ? writes[key] : target[key];
+        },
+        set(_target, key, value) {
+          writes[key] = value;
+          return true;
+        },
+        has(_target, key) {
+          return true;
+        }
+        // with(){} 需要 has 返回 true
+      });
+      const fn = new Function("__vars", `with(__vars) { ${scriptCode} }`);
+      fn(proxy);
+      for (const [k, v] of Object.entries(writes)) {
+        context.setVariable(k, v);
+      }
+      return { success: true, data: Object.keys(writes).length > 0 ? writes : null };
+    } catch (e) {
+      log2.error(`SCRIPT \u8282\u70B9 [${node.id}] \u6267\u884C\u5931\u8D25: ${e.message}`);
+      return { success: false, message: e.message };
+    }
+  }
+};
+var DecisionExecutor = class {
+  static execute(node, context) {
+    const cfg = node.config;
+    const type = String(node.type).toUpperCase();
+    const vars = context.getVariables();
+    const proxy = new Proxy(vars, { has: () => true });
+    if (type === "DECISION") {
+      const decCfg = cfg?.decision ?? {};
+      const scriptCode2 = decCfg.scriptCode ?? decCfg.script ?? "";
+      const scriptType2 = String(decCfg.scriptType ?? "javascript").toLowerCase();
+      if (scriptType2 === "groovy") {
+        return { success: false, message: "\u6D4F\u89C8\u5668\u5F15\u64CE\u4E0D\u652F\u6301 Groovy\uFF0C\u8BF7\u5207\u6362 Java \u6A21\u5F0F" };
+      }
+      const outgoing2 = context.getOutgoing(node.id);
+      if (scriptCode2.trim()) {
+        let exprResult = void 0;
+        try {
+          const code = scriptCode2.includes("return") ? scriptCode2 : `return (${scriptCode2})`;
+          exprResult = new Function("__vars", `with(__vars){ ${code} }`)(proxy);
+        } catch (e) {
+          log2.warn(`DECISION [${node.id}] scriptCode \u6C42\u503C\u5931\u8D25: ${e.message}`);
+        }
+        const resultStr = String(exprResult ?? "");
+        log2.info(`DECISION [${node.id}] scriptCode \u2192 ${resultStr}`);
+        let selectedBranch3 = null;
+        let defaultBranch = null;
+        for (const edge of outgoing2) {
+          const branchResult = edge.condition;
+          if (!branchResult?.trim()) defaultBranch = edge.to;
+          else if (branchResult === resultStr) selectedBranch3 = edge.to;
+        }
+        if (!selectedBranch3) selectedBranch3 = defaultBranch;
+        for (const edge of outgoing2) {
+          if (edge.to !== selectedBranch3) context.skipNode(edge.to);
+        }
+        if (selectedBranch3) {
+          return { success: true, data: { selectedBranch: selectedBranch3, decisionResult: exprResult } };
+        }
+        return { success: false, message: "DECISION: \u6CA1\u6709\u5339\u914D\u7684\u5206\u652F" };
+      }
+      let selectedBranch2 = null;
+      for (const edge of outgoing2) {
+        if (selectedBranch2) {
+          context.skipNode(edge.to);
+          continue;
+        }
+        let matched = false;
+        if (!edge.condition?.trim()) {
+          matched = true;
+        } else {
+          try {
+            matched = !!new Function("__vars", `with(__vars){ return !!(${edge.condition}); }`)(proxy);
+          } catch (e) {
+            log2.warn(`DECISION [${node.id}] \u8FB9\u6761\u4EF6\u6C42\u503C\u5931\u8D25: ${edge.condition}`);
+          }
+        }
+        if (matched) selectedBranch2 = edge.to;
+        else context.skipNode(edge.to);
+      }
+      log2.info(`DECISION [${node.id}] \u2192 ${selectedBranch2}`);
+      if (selectedBranch2) return { success: true, data: { selectedBranch: selectedBranch2 } };
+      return { success: false, message: "DECISION: \u6CA1\u6709\u5339\u914D\u7684\u5206\u652F" };
+    }
+    const condCfg = cfg?.condition ?? {};
+    const scriptCode = condCfg.scriptCode ?? condCfg.script ?? "";
+    const scriptType = String(condCfg.scriptType ?? "javascript").toLowerCase();
+    if (scriptType === "groovy") {
+      return { success: false, message: "\u6D4F\u89C8\u5668\u5F15\u64CE\u4E0D\u652F\u6301 Groovy\uFF0C\u8BF7\u5207\u6362 Java \u6A21\u5F0F" };
+    }
+    const outgoing = context.getOutgoing(node.id);
+    let selectedBranch = null;
+    if (scriptCode.trim()) {
+      let condResult = false;
+      try {
+        const code = scriptCode.includes("return") ? scriptCode : `return !!(${scriptCode})`;
+        condResult = !!new Function("__vars", `with(__vars){ ${code} }`)(proxy);
+      } catch (e) {
+        log2.warn(`CONDITION [${node.id}] scriptCode \u6C42\u503C\u5931\u8D25: ${e.message}`);
+      }
+      log2.info(`CONDITION [${node.id}] \u2192 ${condResult}`);
+      for (const edge of outgoing) {
+        const br = edge.condition?.trim();
+        const edgeExpected = !br || br === "true";
+        const match = condResult ? br === "true" || !br : br === "false" || !br;
+        if (!selectedBranch && (br === String(condResult) || !br)) {
+          selectedBranch = edge.to;
+        } else {
+          context.skipNode(edge.to);
+        }
+      }
+    } else {
+      for (const edge of outgoing) {
+        if (selectedBranch) {
+          context.skipNode(edge.to);
+          continue;
+        }
+        let matched = false;
+        if (!edge.condition?.trim()) {
+          matched = true;
+        } else {
+          try {
+            matched = !!new Function("__vars", `with(__vars){ return !!(${edge.condition}); }`)(proxy);
+          } catch (e) {
+            log2.warn(`CONDITION [${node.id}] \u8FB9\u6761\u4EF6\u6C42\u503C\u5931\u8D25: ${edge.condition}`);
+          }
+        }
+        if (matched) selectedBranch = edge.to;
+        else context.skipNode(edge.to);
+      }
+    }
+    if (selectedBranch) {
+      log2.info(`CONDITION [${node.id}] \u2192 ${selectedBranch}`);
+      return { success: true, data: { selectedBranch } };
+    }
+    return { success: false, message: "CONDITION: \u6CA1\u6709\u5339\u914D\u7684\u5206\u652F" };
+  }
+};
+var ParallelExecutor = class {
+  static execute(node, context) {
+    const outgoing = context.getOutgoing(node.id);
+    if (outgoing.length === 0) {
+      return { success: true, data: { branches: 0 } };
+    }
+    const convergeNodeId = context.getDefinition().convergeMap?.[node.id];
+    if (convergeNodeId) {
+      context.registerConvergence(convergeNodeId, outgoing.length);
+      log2.info(`PARALLEL [${node.id}] \u6CE8\u518C\u6C47\u805A\u8282\u70B9 ${convergeNodeId}`);
+    } else {
+      log2.warn(`PARALLEL [${node.id}] \u672A\u627E\u5230\u6C47\u805A\u70B9\uFF08convergeMap \u7F3A\u5931\uFF09`);
+    }
+    return {
+      success: true,
+      data: { branches: outgoing.length, convergeTo: convergeNodeId }
+    };
+  }
+};
+var LoopExecutor = class _LoopExecutor {
+  static async execute(node, context) {
+    const cfg = node.config?.loop;
+    if (!cfg?.loopType) {
+      return { success: false, message: "LOOP \u8282\u70B9\u7F3A\u5C11 loopType (START|END)" };
+    }
+    const loopType = String(cfg.loopType).toUpperCase();
+    if (loopType === "START") return _LoopExecutor.executeStart(node, cfg, context);
+    if (loopType === "END") return { success: true, data: { action: "collected" } };
+    return { success: false, message: `\u672A\u77E5 loopType: ${cfg.loopType}` };
+  }
+  static async executeStart(node, cfg, context) {
+    const itemsExpr = cfg.itemsExpr ?? cfg.arrayExpression;
+    const maxIter = cfg.maxIterations ?? Infinity;
+    const itemVar = cfg.itemVar ?? "item";
+    const indexVar = cfg.indexVar ?? "index";
+    const items = _LoopExecutor.evalItems(itemsExpr, context);
+    const bodyPath = context.getLoopBodyPath(node.id);
+    const loopEndNodeId = bodyPath.length > 0 ? bodyPath[bodyPath.length - 1] : null;
+    log2.info(`LOOP_START [${node.id}] items=${items.length}, bodyPath=${bodyPath.join("->")}`);
+    if (items.length === 0) {
+      if (loopEndNodeId) {
+        context.complete(loopEndNodeId, { results: [] }, Date.now());
+      }
+      return {
+        success: true,
+        data: { action: "exit", totalIterations: 0, results: [], __loopEndNodeId: loopEndNodeId }
+      };
+    }
+    const allResults = [];
+    let iteration = 0;
+    for (let i = 0; i < items.length && i < maxIter; i++) {
+      context.setVariable(itemVar, items[i]);
+      context.setVariable(indexVar, i);
+      iteration++;
+      for (const nodeId of bodyPath) {
+        const bodyNode = context.getNode(nodeId);
+        if (!bodyNode) continue;
+        context.getCompletedNodes().delete(nodeId);
+        context.getExecutingNodes().delete(nodeId);
+        const t0 = Date.now();
+        const result = await NodeExecutorFactory.execute(bodyNode, context);
+        context.complete(nodeId, result.data, t0);
+        if (String(bodyNode.type).toUpperCase() === "LOOP") {
+          const endCfg = bodyNode.config?.loop;
+          if (endCfg?.loopType?.toUpperCase() === "END") {
+            const resultExpr = endCfg.resultExpr ?? endCfg.resultExpression;
+            if (resultExpr) {
+              try {
+                const val = _LoopExecutor.evalExpr(resultExpr, context);
+                if (val !== void 0) allResults.push(val);
+              } catch (e) {
+              }
+            } else if (result.data !== void 0) {
+              allResults.push(result.data);
+            }
+          }
+        }
+      }
+    }
+    const resultData = {
+      action: "exit",
+      totalIterations: iteration,
+      results: allResults
+    };
+    if (loopEndNodeId) resultData["__loopEndNodeId"] = loopEndNodeId;
+    log2.info(`LOOP_START [${node.id}] \u6267\u884C\u5B8C\u6210\uFF0CtotalIterations=${iteration}`);
+    return { success: true, data: resultData };
+  }
+  static evalItems(expr, context) {
+    if (!expr?.trim()) return [];
+    try {
+      const vars = context.getVariables();
+      const proxy = new Proxy(vars, { has: () => true });
+      const result = new Function("__vars", `with(__vars){ return (${expr}); }`)(proxy);
+      if (Array.isArray(result)) return result;
+      if (typeof result === "number") return Array.from({ length: result }, (_, i) => i);
+      return [];
+    } catch (e) {
+      log2.error(`LOOP items \u8868\u8FBE\u5F0F\u6C42\u503C\u5931\u8D25: ${expr}`);
+      return [];
+    }
+  }
+  static evalExpr(expr, context) {
+    const vars = { ...context.getVariables(), outputs: context.getNodeOutputs() };
+    const proxy = new Proxy(vars, { has: () => true });
+    return new Function("__vars", `with(__vars){ return (${expr}); }`)(proxy);
+  }
+};
+var ApiExecutor = class _ApiExecutor {
+  static async execute(node, context) {
+    const cfg = node.config?.api;
+    if (!cfg?.url) {
+      return { success: false, message: "API \u8282\u70B9\u7F3A\u5C11 url \u914D\u7F6E" };
+    }
+    const vars = context.getVariables();
+    let url = _ApiExecutor.interpolate(cfg.url, vars);
+    const method = (cfg.method ?? "GET").toUpperCase();
+    const timeoutMs = (cfg.timeout ?? 30) * 1e3;
+    const rawHeaders = {
+      "Content-Type": "application/json",
+      ...cfg.headers ?? {}
+    };
+    if (cfg.params && Object.keys(cfg.params).length > 0) {
+      const qs = new URLSearchParams(
+        Object.entries(cfg.params).map(([k, v]) => [k, String(v)])
+      ).toString();
+      url = url + (url.includes("?") ? "&" : "?") + qs;
+    }
+    let body;
+    if (cfg.body && ["POST", "PUT", "PATCH"].includes(method)) {
+      const rawBody = typeof cfg.body === "string" ? _ApiExecutor.interpolate(cfg.body, vars) : JSON.stringify(cfg.body);
+      body = rawBody;
+    }
+    log2.info(`API [${node.id}] ${method} ${url}`);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      let response;
+      const isBrowser = typeof window !== "undefined";
+      if (isBrowser) {
+        const proxyBase = window.location.origin;
+        response = await fetch(`${proxyBase}/api-proxy`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ url, method, headers: rawHeaders, body: body ?? null }),
+          signal: controller.signal
+        });
+      } else {
+        response = await fetch(url, {
+          method,
+          headers: rawHeaders,
+          body,
+          signal: controller.signal
+        });
+      }
+      clearTimeout(timer);
+      if (!response.ok) {
+        const errText = await response.text().catch(() => "");
+        return { success: false, message: `HTTP ${response.status}: ${errText}` };
+      }
+      const contentType = response.headers.get("content-type") ?? "";
+      let data;
+      if (contentType.includes("application/json")) {
+        data = await response.json();
+      } else {
+        data = { rawResponse: await response.text() };
+      }
+      return { success: true, data: { apiResponse: data } };
+    } catch (e) {
+      clearTimeout(timer);
+      if (e.name === "AbortError") {
+        return { success: false, message: `API \u8BF7\u6C42\u8D85\u65F6\uFF08${cfg.timeout ?? 30}s\uFF09` };
+      }
+      log2.error(`API [${node.id}] \u8BF7\u6C42\u5931\u8D25: ${e.message}`);
+      return { success: false, message: `API call failed: ${e.message}` };
+    }
+  }
+  /** 简单字符串插值：{{变量名}} → 变量值 */
+  static interpolate(template, vars) {
+    return template.replace(
+      /\{\{(\w+)\}\}/g,
+      (_, key) => key in vars ? String(vars[key]) : `{{${key}}}`
+    );
+  }
+};
+var LlmExecutor = class _LlmExecutor {
+  static async execute(node, context) {
+    const cfg = node.config?.llm;
+    if (!cfg) {
+      return { success: false, message: "LLM \u8282\u70B9\u7F3A\u5C11\u914D\u7F6E" };
+    }
+    if (!cfg.userPrompt?.trim()) {
+      return { success: false, message: "\u7F3A\u5C11 userPrompt\uFF08\u7528\u6237\u63D0\u793A\u8BCD\uFF09" };
+    }
+    const vars = context.getVariables();
+    const apiKey = cfg.apiKey ?? "";
+    const provider = cfg.provider ?? "openai";
+    const model = cfg.modelName ?? "gpt-3.5-turbo";
+    const endpoint = cfg.endpoint ?? _LlmExecutor.defaultEndpoint(provider);
+    const temperature = cfg.temperature ?? 0.7;
+    const maxTokens = cfg.maxTokens ?? 2048;
+    const userPrompt = _LlmExecutor.interpolate(cfg.userPrompt, vars);
+    const systemPrompt = _LlmExecutor.interpolate(cfg.systemPrompt ?? "", vars);
+    const messages = [];
+    if (systemPrompt.trim()) messages.push({ role: "system", content: systemPrompt });
+    messages.push({ role: "user", content: userPrompt });
+    log2.info(`LLM [${node.id}] provider=${provider} model=${model}`);
+    try {
+      const response = await fetch(`${endpoint}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({ model, messages, temperature, max_tokens: maxTokens })
+      });
+      if (!response.ok) {
+        const err = await response.json().catch(() => ({ error: { message: response.statusText } }));
+        return { success: false, message: `LLM \u8C03\u7528\u5931\u8D25: ${err?.error?.message ?? response.status}` };
+      }
+      const data = await response.json();
+      const content = data.choices?.[0]?.message?.content ?? "";
+      const usage = data.usage ?? {};
+      return {
+        success: true,
+        data: {
+          llmResponse: content,
+          model: data.model ?? model,
+          inputTokens: usage.prompt_tokens ?? 0,
+          outputTokens: usage.completion_tokens ?? 0
+        }
+      };
+    } catch (e) {
+      log2.error(`LLM [${node.id}] \u8BF7\u6C42\u5931\u8D25: ${e.message}`);
+      return { success: false, message: `LLM call failed: ${e.message}` };
+    }
+  }
+  static defaultEndpoint(provider) {
+    switch (provider.toLowerCase()) {
+      case "openai":
+        return "https://api.openai.com/v1";
+      case "qwen":
+        return "https://dashscope.aliyuncs.com/compatible-mode/v1";
+      case "claude":
+        return "https://api.anthropic.com/v1";
+      case "ollama":
+        return "http://localhost:11434/v1";
+      default:
+        return "https://api.openai.com/v1";
+    }
+  }
+  static interpolate(template, vars) {
+    return template.replace(
+      /\{\{(\w+)\}\}/g,
+      (_, key) => key in vars ? String(vars[key]) : `{{${key}}}`
+    );
+  }
+};
+
+// src/core/flow-engine.ts
+var log3 = createLogger("Engine");
+var SimpleEmitter = class {
+  handlers = /* @__PURE__ */ new Map();
+  on(event, handler) {
+    if (!this.handlers.has(event)) this.handlers.set(event, []);
+    this.handlers.get(event).push(handler);
+    return this;
+  }
+  once(event, handler) {
+    const wrapper = (...args) => {
+      handler(...args);
+      this.off(event, wrapper);
+    };
+    return this.on(event, wrapper);
+  }
+  off(event, handler) {
+    const list = this.handlers.get(event) ?? [];
+    this.handlers.set(event, list.filter((h) => h !== handler));
+    return this;
+  }
+  emit(event, ...args) {
+    const list = this.handlers.get(event) ?? [];
+    for (const h of list) {
+      try {
+        h(...args);
+      } catch (e) {
+      }
+    }
+    return this;
+  }
+};
+var FlowEngine = class extends SimpleEmitter {
+  activeContexts = /* @__PURE__ */ new Map();
+  constructor() {
+    super();
+  }
+  // ─── 公开入口 ────────────────────────────────────────────
+  async execute(definition, variables = {}) {
+    const executionId = `exec-${Math.random().toString(36).slice(2, 10)}`;
+    const context = new FlowContext(executionId, definition, variables);
+    this.activeContexts.set(executionId, context);
+    return new Promise((resolve) => {
+      this.once(`flow.finished.${executionId}`, () => {
+        this.activeContexts.delete(executionId);
+        resolve(this.buildResult(context));
+      });
+      const startNode = context.getNodes().find(
+        (n) => String(n.type).toUpperCase() === "START"
+      );
+      if (!startNode) {
+        context.setStatus("FAILED" /* FAILED */);
+        this.emit(`flow.finished.${executionId}`);
+        return;
+      }
+      this.scheduleNode(context, startNode.id);
+    });
+  }
+  // ─── 调度单个节点（setTimeout(0) 让并行可以真正并发，兼容浏览器）────
+  scheduleNode(context, nodeId) {
+    setTimeout(() => this.runNode(context, nodeId), 0);
+  }
+  // ─── 执行单个节点 ────────────────────────────────────────
+  async runNode(context, nodeId) {
+    const executionId = context.getExecutionId();
+    if (context.getCompletedNodes().has(nodeId)) return;
+    if (context.getSkippedNodes().has(nodeId)) return;
+    if (!context.tryExecute(nodeId)) return;
+    if (!context.arePrerequisitesMet(nodeId)) {
+      context.getExecutingNodes().delete(nodeId);
+      return;
+    }
+    const node = context.getNode(nodeId);
+    if (!node) {
+      log3.warn(`\u8282\u70B9 [${nodeId}] \u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7`);
+      return;
+    }
+    const type = String(node.type).toUpperCase();
+    log3.debug(`RUN [${nodeId}] type=${type}`);
+    this.emit("node.starting", { executionId, nodeId });
+    const t0 = Date.now();
+    try {
+      const result = await NodeExecutorFactory.execute(node, context);
+      if (!result.success) {
+        context.fail(nodeId, result.message ?? "Unknown error", t0);
+        this.handleFailure(context, nodeId, result.message ?? "");
+        return;
+      }
+      context.complete(nodeId, result.data, t0);
+      this.emit("node.completed", { executionId, nodeId, output: result.data });
+      if (type === "END") {
+        context.setStatus("COMPLETED" /* COMPLETED */);
+        this.emit(`flow.finished.${executionId}`);
+        return;
+      }
+      if (type === "LOOP") {
+        const loopType = String(node.config?.loop?.loopType ?? "").toUpperCase();
+        if (loopType === "START") {
+          const loopEndNodeId = result.data?.__loopEndNodeId;
+          if (loopEndNodeId) {
+            for (const e of context.getOutgoing(loopEndNodeId)) {
+              this.triggerDownstream(context, loopEndNodeId, e.to);
+            }
+          } else {
+            for (const e of context.getOutgoing(nodeId)) {
+              this.triggerDownstream(context, nodeId, e.to);
+            }
+          }
+          return;
+        }
+      }
+      if (type === "DECISION" || type === "CONDITION") {
+        const selected = result.data?.selectedBranch;
+        if (selected) {
+          this.scheduleNode(context, selected);
+        } else {
+          this.handleFailure(context, nodeId, "No branch matched");
+        }
+        return;
+      }
+      if (type === "PARALLEL") {
+        for (const e of context.getOutgoing(nodeId)) {
+          this.scheduleNode(context, e.to);
+        }
+        return;
+      }
+      for (const e of context.getOutgoing(nodeId)) {
+        this.triggerDownstream(context, nodeId, e.to);
+      }
+    } catch (e) {
+      context.fail(nodeId, e.message, t0);
+      this.handleFailure(context, nodeId, e.message);
+    }
+  }
+  /**
+   * 触发下游节点。有汇聚时，等所有【非跳过】入边到达后才 schedule。
+   */
+  triggerDownstream(context, fromNodeId, toNodeId) {
+    const incoming = context.getIncoming(toNodeId);
+    if (incoming.length <= 1) {
+      this.scheduleNode(context, toNodeId);
+      return;
+    }
+    const effectiveDone = incoming.filter(
+      (e) => context.getCompletedNodes().has(e.from) || context.getSkippedNodes().has(e.from)
+    ).length;
+    if (effectiveDone >= incoming.length) {
+      this.scheduleNode(context, toNodeId);
+    }
+  }
+  // ─── 失败处理 ─────────────────────────────────────────
+  handleFailure(context, nodeId, error) {
+    const executionId = context.getExecutionId();
+    const node = context.getNode(nodeId);
+    const errorMode = node?.config?.error?.mode;
+    log3.error(`\u8282\u70B9 [${nodeId}] \u5931\u8D25: ${error}`);
+    this.emit("node.failed", { executionId, nodeId, error });
+    if (errorMode && errorMode !== "throw" && errorMode !== "fail") {
+      const target = context.getNode(errorMode);
+      if (target) {
+        this.scheduleNode(context, target.id);
+        return;
+      }
+    }
+    context.setStatus("FAILED" /* FAILED */);
+    this.emit(`flow.finished.${executionId}`);
+  }
+  // ─── 结果构建 ─────────────────────────────────────────
+  buildResult(context) {
+    const outputs = context.getNodeOutputs();
+    const endOutput = Object.entries(outputs).find(
+      ([k]) => String(context.getNode(k)?.type ?? k).toUpperCase() === "END" || (k.startsWith("END") || k.startsWith("end"))
+    )?.[1];
+    return {
+      executionId: context.getExecutionId(),
+      status: context.getStatus(),
+      output: endOutput,
+      error: context.getTraces().find((t) => t.status === "FAILED" /* FAILED */)?.error,
+      duration: context.getDuration(),
+      startTime: context.getStartTime(),
+      endTime: context.getEndTime(),
+      variables: context.getVariables(),
+      traces: context.getTraces()
+    };
+  }
+};
+
+// src/parser/x6-parser.ts
+var log4 = createLogger("X6Parser");
+var X6Parser = class {
+  /**
+   * 将前端 X6 序列化的 JSON 解析为引擎可执行的 FlowDefinition
+   */
+  parse(x6Json) {
+    const raw = typeof x6Json === "string" ? JSON.parse(x6Json) : x6Json;
+    const nodes = this.parseNodes(raw.nodes ?? []);
+    const edges = this.parseEdges(raw.edges ?? []);
+    const convergeMap = this.computeConvergeMap(nodes, edges);
+    const loopBodyPaths = this.computeLoopBodyPaths(nodes, edges);
+    log4.debug(`\u89E3\u6790\u5B8C\u6210: nodes=${nodes.length}, edges=${edges.length}, convergeMap keys=${Object.keys(convergeMap).length}`);
+    return {
+      id: `flow-${Date.now()}`,
+      name: "x6-flow",
+      version: "1.0",
+      nodes,
+      edges,
+      convergeMap,
+      loopBodyPaths
+    };
+  }
+  // ── 节点解析 ──────────────────────────────────────────
+  parseNodes(x6Nodes) {
+    return x6Nodes.map((n) => {
+      const rawConfig = n.data?.config ?? {};
+      const meta = n.data?.meta ?? {};
+      const type = (meta.type ?? n.shape ?? "UNKNOWN").toUpperCase();
+      const code = rawConfig.code ?? type;
+      const config = this.normalizeConfig(rawConfig, type);
+      return {
+        id: n.id,
+        type,
+        name: rawConfig.title ?? meta.label ?? type,
+        code,
+        config,
+        metadata: meta
+      };
+    });
+  }
+  normalizeConfig(raw, type) {
+    const cfg = { ...raw };
+    if (cfg.loop) {
+      const loop = cfg.loop;
+      if (!loop.loopType && loop.nodeType) {
+        loop.loopType = String(loop.nodeType).toUpperCase();
+        delete loop.nodeType;
+      } else if (loop.loopType) {
+        loop.loopType = String(loop.loopType).toUpperCase();
+      }
+      if (!loop.itemsExpr && loop.arrayExpression) {
+        loop.itemsExpr = loop.arrayExpression;
+        delete loop.arrayExpression;
+      }
+      if (!loop.resultExpr && loop.resultExpression) {
+        loop.resultExpr = loop.resultExpression;
+        delete loop.resultExpression;
+      }
+    }
+    if (cfg.api) {
+      cfg.api = this.normalizeApiField(cfg.api, "params");
+      cfg.api = this.normalizeApiField(cfg.api, "headers");
+    }
+    return cfg;
+  }
+  normalizeApiField(api, field) {
+    const value = api[field];
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        try {
+          api[field] = JSON.parse(trimmed);
+        } catch {
+          log4.warn(`api.${field} \u4E0D\u662F\u5408\u6CD5 JSON\uFF0C\u5DF2\u5FFD\u7565`);
+          delete api[field];
+        }
+      } else if (!trimmed || trimmed === "null") {
+        delete api[field];
+      }
+    }
+    return api;
+  }
+  // ── 边解析 ────────────────────────────────────────────
+  parseEdges(x6Edges) {
+    const result = [];
+    for (const e of x6Edges) {
+      const from = this.extractCellId(e.source);
+      const to = this.extractCellId(e.target);
+      if (!from || !to) {
+        log4.warn(`\u8FB9\u7F3A\u5C11 source \u6216 target\uFF0C\u5DF2\u8DF3\u8FC7`);
+        continue;
+      }
+      const condition = e.data?.config?.branchResult ?? void 0;
+      result.push({
+        id: e.id ?? `edge-${from}-${to}`,
+        from,
+        to,
+        condition,
+        metadata: { priority: e.data?.priority ?? 0 }
+      });
+    }
+    return result;
+  }
+  extractCellId(value) {
+    if (!value) return null;
+    if (typeof value === "string") return value.trim() || null;
+    return value.cell ?? null;
+  }
+  // ── 预计算：PARALLEL 汇聚点（BFS 找公共后继）────────
+  computeConvergeMap(nodes, edges) {
+    const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+    const outgoingMap = this.buildOutgoingMap(edges);
+    const result = {};
+    for (const node of nodes) {
+      if (String(node.type).toUpperCase() !== "PARALLEL") continue;
+      const outgoing = outgoingMap.get(node.id) ?? [];
+      if (outgoing.length === 0) continue;
+      const convergeId = this.findConvergeNode(outgoing.map((e) => e.to), outgoingMap);
+      if (convergeId) {
+        result[node.id] = convergeId;
+        log4.debug(`PARALLEL ${node.id} \u2192 converge ${convergeId}`);
+      }
+    }
+    return result;
+  }
+  /** BFS 找所有分支的第一个公共后继节点 */
+  findConvergeNode(starts, outgoingMap) {
+    const reachCount = /* @__PURE__ */ new Map();
+    for (const start of starts) {
+      const visited = /* @__PURE__ */ new Set();
+      const queue = [start];
+      while (queue.length > 0) {
+        const cur = queue.shift();
+        if (visited.has(cur)) continue;
+        visited.add(cur);
+        reachCount.set(cur, (reachCount.get(cur) ?? 0) + 1);
+        if (reachCount.get(cur) === starts.length && !starts.includes(cur)) {
+          return cur;
+        }
+        for (const e of outgoingMap.get(cur) ?? []) queue.push(e.to);
+      }
+    }
+    return null;
+  }
+  // ── 预计算：LOOP_START 循环体路径（BFS）──────────────
+  computeLoopBodyPaths(nodes, edges) {
+    const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+    const outgoingMap = this.buildOutgoingMap(edges);
+    const result = {};
+    for (const node of nodes) {
+      if (String(node.type).toUpperCase() !== "LOOP") continue;
+      const loopType = String(node.config?.loop?.loopType ?? "").toUpperCase();
+      if (loopType !== "START") continue;
+      const path = this.computeSingleLoopPath(node, nodeMap, outgoingMap);
+      result[node.id] = path;
+      log4.debug(`LOOP_START ${node.id} bodyPath=[${path.join(",")}]`);
+    }
+    return result;
+  }
+  computeSingleLoopPath(loopStart, nodeMap, outgoingMap) {
+    const path = [];
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [];
+    for (const e of outgoingMap.get(loopStart.id) ?? []) {
+      const toNode = nodeMap.get(e.to);
+      if (!toNode || String(toNode.type).toUpperCase() === "END") continue;
+      if (visited.add(e.to)) queue.push(e.to);
+    }
+    while (queue.length > 0) {
+      const cur = queue.shift();
+      path.push(cur);
+      const curNode = nodeMap.get(cur);
+      if (!curNode) continue;
+      if (String(curNode.type).toUpperCase() === "LOOP" && String(curNode.config?.loop?.loopType ?? "").toUpperCase() === "END") break;
+      for (const e of outgoingMap.get(cur) ?? []) {
+        if (e.to === loopStart.id) continue;
+        const toNode = nodeMap.get(e.to);
+        if (!toNode || String(toNode.type).toUpperCase() === "END") continue;
+        if (visited.add(e.to)) queue.push(e.to);
+      }
+    }
+    return path;
+  }
+  buildOutgoingMap(edges) {
+    const map = /* @__PURE__ */ new Map();
+    for (const e of edges) {
+      if (!map.has(e.from)) map.set(e.from, []);
+      map.get(e.from).push(e);
+    }
+    return map;
+  }
+};
+function parseX6(x6Json) {
+  return new X6Parser().parse(x6Json);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FlowContext,
+  FlowEngine,
+  NodeExecutorFactory,
+  NodeStatus,
+  NodeType,
+  X6Parser,
+  createLogger,
+  parseX6
+});