@timo9378/flow2code 0.1.0

package/dist/compiler.cjs

@@ -0,0 +1,4177 @@
+"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/lib/index.ts
+var lib_exports = {};
+__export(lib_exports, {
+  ActionType: () => ActionType,
+  CURRENT_IR_VERSION: () => CURRENT_IR_VERSION,
+  LogicType: () => LogicType,
+  NodeCategory: () => NodeCategory,
+  NodeRegistry: () => NodeRegistry,
+  OutputType: () => OutputType,
+  TriggerType: () => TriggerType,
+  VariableType: () => VariableType,
+  builtinPlugins: () => builtinPlugins,
+  clearPlugins: () => clearPlugins,
+  compile: () => compile,
+  createPluginRegistry: () => createPluginRegistry,
+  decompile: () => decompile,
+  detectFormat: () => detectFormat,
+  formatDiff: () => formatDiff,
+  formatSecurityReport: () => formatSecurityReport,
+  formatTraceResults: () => formatTraceResults,
+  getAllPlugins: () => getAllPlugins,
+  getAvailablePlatforms: () => getAvailablePlatforms,
+  getPlatform: () => getPlatform,
+  getPlugin: () => getPlugin,
+  hasPlugin: () => hasPlugin,
+  inferFlowStateTypes: () => inferFlowStateTypes,
+  installFlowTracer: () => installFlowTracer,
+  loadFlowProject: () => loadFlowProject,
+  mergeIR: () => mergeIR,
+  migrateToSplit: () => migrateToSplit,
+  nodeRegistry: () => nodeRegistry,
+  parseExpression: () => parseExpression,
+  registerPlatform: () => registerPlatform,
+  registerPlugin: () => registerPlugin,
+  registerPlugins: () => registerPlugins,
+  saveFlowProject: () => saveFlowProject,
+  semanticDiff: () => semanticDiff,
+  splitIR: () => splitIR,
+  topologicalSort: () => topologicalSort,
+  traceError: () => traceError,
+  traceLineToNode: () => traceLineToNode,
+  validate: () => validateFlowIR,
+  validateFlowIR: () => validateFlowIR,
+  validateIRSecurity: () => validateIRSecurity,
+  withFlowTrace: () => withFlowTrace
+});
+module.exports = __toCommonJS(lib_exports);
+
+// src/lib/compiler/compiler.ts
+var import_ts_morph = require("ts-morph");
+
+// src/lib/ir/types.ts
+var CURRENT_IR_VERSION = "1.0.0";
+var NodeCategory = /* @__PURE__ */ ((NodeCategory2) => {
+  NodeCategory2["TRIGGER"] = "trigger";
+  NodeCategory2["ACTION"] = "action";
+  NodeCategory2["LOGIC"] = "logic";
+  NodeCategory2["VARIABLE"] = "variable";
+  NodeCategory2["OUTPUT"] = "output";
+  return NodeCategory2;
+})(NodeCategory || {});
+var TriggerType = /* @__PURE__ */ ((TriggerType2) => {
+  TriggerType2["HTTP_WEBHOOK"] = "http_webhook";
+  TriggerType2["CRON_JOB"] = "cron_job";
+  TriggerType2["MANUAL"] = "manual";
+  return TriggerType2;
+})(TriggerType || {});
+var ActionType = /* @__PURE__ */ ((ActionType2) => {
+  ActionType2["FETCH_API"] = "fetch_api";
+  ActionType2["SQL_QUERY"] = "sql_query";
+  ActionType2["REDIS_CACHE"] = "redis_cache";
+  ActionType2["CUSTOM_CODE"] = "custom_code";
+  ActionType2["CALL_SUBFLOW"] = "call_subflow";
+  return ActionType2;
+})(ActionType || {});
+var LogicType = /* @__PURE__ */ ((LogicType2) => {
+  LogicType2["IF_ELSE"] = "if_else";
+  LogicType2["FOR_LOOP"] = "for_loop";
+  LogicType2["TRY_CATCH"] = "try_catch";
+  LogicType2["PROMISE_ALL"] = "promise_all";
+  return LogicType2;
+})(LogicType || {});
+var VariableType = /* @__PURE__ */ ((VariableType2) => {
+  VariableType2["DECLARE"] = "declare";
+  VariableType2["TRANSFORM"] = "transform";
+  return VariableType2;
+})(VariableType || {});
+var OutputType = /* @__PURE__ */ ((OutputType2) => {
+  OutputType2["RETURN_RESPONSE"] = "return_response";
+  return OutputType2;
+})(OutputType || {});
+
+// src/lib/ir/migrations/engine.ts
+var migrations = [];
+function migrateIR(raw, targetVersion = CURRENT_IR_VERSION) {
+  const applied = [];
+  let current = { ...raw };
+  if (current.version === targetVersion) {
+    return { ir: current, applied, migrated: false };
+  }
+  const maxIterations = migrations.length + 1;
+  let iterations = 0;
+  while (current.version !== targetVersion) {
+    if (iterations++ > maxIterations) {
+      throw new MigrationError(
+        `Migration exceeded max iterations (${maxIterations}), possible circular migration`,
+        current.version,
+        targetVersion
+      );
+    }
+    const migration = migrations.find(
+      (m) => m.fromVersion === current.version
+    );
+    if (!migration) {
+      throw new MigrationError(
+        `No migration path found from ${current.version} to ${targetVersion}`,
+        current.version,
+        targetVersion
+      );
+    }
+    current = migration.migrate(current);
+    applied.push(
+      `${migration.fromVersion} \u2192 ${migration.toVersion}: ${migration.description}`
+    );
+  }
+  return { ir: current, applied, migrated: true };
+}
+function needsMigration(version, targetVersion = CURRENT_IR_VERSION) {
+  return version !== targetVersion;
+}
+var MigrationError = class extends Error {
+  constructor(message, fromVersion, targetVersion) {
+    super(message);
+    this.fromVersion = fromVersion;
+    this.targetVersion = targetVersion;
+    this.name = "MigrationError";
+  }
+};
+
+// src/lib/ir/validator.ts
+function validateFlowIR(ir) {
+  const errors = [];
+  if (!ir || typeof ir !== "object") {
+    return {
+      valid: false,
+      errors: [{ code: "INVALID_INPUT", message: "IR input must be a non-null object" }]
+    };
+  }
+  if (!Array.isArray(ir.nodes)) {
+    return {
+      valid: false,
+      errors: [{ code: "MISSING_NODES", message: "IR is missing required 'nodes' array" }]
+    };
+  }
+  if (!Array.isArray(ir.edges)) {
+    return {
+      valid: false,
+      errors: [{ code: "MISSING_EDGES", message: "IR is missing required 'edges' array" }]
+    };
+  }
+  let workingIR = ir;
+  let migrated = false;
+  let migrationLog;
+  if (needsMigration(ir.version)) {
+    try {
+      const result = migrateIR(
+        { version: ir.version, meta: ir.meta, nodes: ir.nodes, edges: ir.edges },
+        CURRENT_IR_VERSION
+      );
+      if (result.migrated) {
+        workingIR = result.ir;
+        migrated = true;
+        migrationLog = result.applied;
+      }
+    } catch (err) {
+      if (err instanceof MigrationError) {
+        errors.push({
+          code: "MIGRATION_FAILED",
+          message: `IR version migration failed: ${err.message}`
+        });
+      } else {
+        errors.push({
+          code: "INVALID_VERSION",
+          message: `Unsupported IR version: ${ir.version}`
+        });
+      }
+    }
+  }
+  if (!migrated && workingIR.version !== CURRENT_IR_VERSION) {
+    errors.push({
+      code: "INVALID_VERSION",
+      message: `Unsupported IR version: ${workingIR.version} (current: ${CURRENT_IR_VERSION})`
+    });
+  }
+  const workingNodeMap = new Map(workingIR.nodes.map((n) => [n.id, n]));
+  const triggers = workingIR.nodes.filter(
+    (n) => n.category === "trigger" /* TRIGGER */
+  );
+  if (triggers.length === 0) {
+    errors.push({
+      code: "NO_TRIGGER",
+      message: "Workflow must contain at least one trigger node"
+    });
+  }
+  if (triggers.length > 1) {
+    errors.push({
+      code: "MULTIPLE_TRIGGERS",
+      message: `Workflow must have exactly one trigger, found ${triggers.length}`
+    });
+  }
+  const idSet = /* @__PURE__ */ new Set();
+  for (const node of workingIR.nodes) {
+    if (idSet.has(node.id)) {
+      errors.push({
+        code: "DUPLICATE_NODE_ID",
+        message: `Duplicate node ID: ${node.id}`,
+        nodeId: node.id
+      });
+    }
+    idSet.add(node.id);
+  }
+  for (const edge of workingIR.edges) {
+    if (!workingNodeMap.has(edge.sourceNodeId)) {
+      errors.push({
+        code: "INVALID_EDGE_SOURCE",
+        message: `Edge "${edge.id}" references non-existent source node "${edge.sourceNodeId}"`,
+        edgeId: edge.id
+      });
+    }
+    if (!workingNodeMap.has(edge.targetNodeId)) {
+      errors.push({
+        code: "INVALID_EDGE_TARGET",
+        message: `Edge "${edge.id}" references non-existent target node "${edge.targetNodeId}"`,
+        edgeId: edge.id
+      });
+    }
+  }
+  const cycleErrors = detectCycles(workingIR.nodes, workingIR.edges);
+  errors.push(...cycleErrors);
+  const connectedNodes = /* @__PURE__ */ new Set();
+  for (const edge of workingIR.edges) {
+    connectedNodes.add(edge.sourceNodeId);
+    connectedNodes.add(edge.targetNodeId);
+  }
+  for (const node of workingIR.nodes) {
+    if (node.category !== "trigger" /* TRIGGER */ && !connectedNodes.has(node.id)) {
+      errors.push({
+        code: "ORPHAN_NODE",
+        message: `Node "${node.id}" (${node.label}) is not connected to any other node`,
+        nodeId: node.id
+      });
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    migrated,
+    migratedIR: migrated ? workingIR : void 0,
+    migrationLog
+  };
+}
+function detectCycles(nodes, edges) {
+  const errors = [];
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    adjacency.set(node.id, []);
+  }
+  for (const edge of edges) {
+    adjacency.get(edge.sourceNodeId)?.push(edge.targetNodeId);
+  }
+  const WHITE = 0;
+  const GRAY = 1;
+  const BLACK = 2;
+  const color = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    color.set(node.id, WHITE);
+  }
+  function dfs(nodeId) {
+    color.set(nodeId, GRAY);
+    for (const neighbor of adjacency.get(nodeId) ?? []) {
+      if (color.get(neighbor) === GRAY) {
+        errors.push({
+          code: "CYCLE_DETECTED",
+          message: `Cycle detected: node "${nodeId}" \u2192 "${neighbor}"`,
+          nodeId
+        });
+      } else if (color.get(neighbor) === WHITE) {
+        dfs(neighbor);
+      }
+    }
+    color.set(nodeId, BLACK);
+  }
+  for (const node of nodes) {
+    if (color.get(node.id) === WHITE) {
+      dfs(node.id);
+    }
+  }
+  return errors;
+}
+
+// src/lib/ir/topological-sort.ts
+function buildGraph(nodes, edges) {
+  const indegree = /* @__PURE__ */ new Map();
+  const adjacency = /* @__PURE__ */ new Map();
+  const reverseAdjacency = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    indegree.set(node.id, 0);
+    adjacency.set(node.id, /* @__PURE__ */ new Set());
+    reverseAdjacency.set(node.id, /* @__PURE__ */ new Set());
+  }
+  for (const edge of edges) {
+    adjacency.get(edge.sourceNodeId).add(edge.targetNodeId);
+    reverseAdjacency.get(edge.targetNodeId).add(edge.sourceNodeId);
+    indegree.set(
+      edge.targetNodeId,
+      (indegree.get(edge.targetNodeId) ?? 0) + 1
+    );
+  }
+  return { indegree, adjacency, reverseAdjacency };
+}
+function topologicalSort(ir) {
+  const { nodes, edges } = ir;
+  const { indegree, adjacency, reverseAdjacency } = buildGraph(nodes, edges);
+  const indegreeCopy = new Map(indegree);
+  const sortedNodeIds = [];
+  const steps = [];
+  let currentLevel = [];
+  for (const [nodeId, degree] of indegreeCopy) {
+    if (degree === 0) {
+      currentLevel.push(nodeId);
+    }
+  }
+  let stepIndex = 0;
+  while (currentLevel.length > 0) {
+    steps.push({
+      index: stepIndex,
+      nodeIds: [...currentLevel],
+      concurrent: currentLevel.length > 1
+    });
+    sortedNodeIds.push(...currentLevel);
+    const nextLevel = [];
+    for (const nodeId of currentLevel) {
+      for (const neighbor of adjacency.get(nodeId) ?? []) {
+        const newDegree = (indegreeCopy.get(neighbor) ?? 1) - 1;
+        indegreeCopy.set(neighbor, newDegree);
+        if (newDegree === 0) {
+          nextLevel.push(neighbor);
+        }
+      }
+    }
+    currentLevel = nextLevel;
+    stepIndex++;
+  }
+  const dependencies = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    dependencies.set(node.id, reverseAdjacency.get(node.id) ?? /* @__PURE__ */ new Set());
+    dependents.set(node.id, adjacency.get(node.id) ?? /* @__PURE__ */ new Set());
+  }
+  if (sortedNodeIds.length !== nodes.length) {
+    throw new Error(
+      `Topological sort failed: cycle detected in graph. Sorted ${sortedNodeIds.length}/${nodes.length} nodes.`
+    );
+  }
+  return {
+    steps,
+    sortedNodeIds,
+    dependencies,
+    dependents
+  };
+}
+
+// src/lib/compiler/expression-parser.ts
+function parseExpression(expr, context) {
+  const tokens = tokenize(expr);
+  return tokens.map((token) => {
+    if (token.type === "literal") return token.value;
+    return resolveReference(parseReference(token.value), context);
+  }).join("");
+}
+function tokenize(input) {
+  const tokens = [];
+  let i = 0;
+  let literalBuf = "";
+  while (i < input.length) {
+    if (input[i] === "\\" && input[i + 1] === "{" && input[i + 2] === "{") {
+      literalBuf += "{{";
+      i += 3;
+      continue;
+    }
+    if (input[i] === "{" && input[i + 1] === "{") {
+      if (literalBuf) {
+        tokens.push({ type: "literal", value: literalBuf });
+        literalBuf = "";
+      }
+      i += 2;
+      const refStart = i;
+      let bracketDepth = 0;
+      while (i < input.length) {
+        if (input[i] === "[") {
+          bracketDepth++;
+          i++;
+        } else if (input[i] === "]") {
+          bracketDepth--;
+          i++;
+        } else if (input[i] === "}" && input[i + 1] === "}" && bracketDepth === 0) {
+          break;
+        } else {
+          i++;
+        }
+      }
+      if (i >= input.length) {
+        throw new ExpressionParseError(
+          `Unclosed template expression: missing matching '}}' (at position ${refStart - 2})`,
+          input,
+          refStart - 2
+        );
+      }
+      const refContent = input.slice(refStart, i).trim();
+      if (!refContent) {
+        throw new ExpressionParseError(
+          "Empty template expression {{}}",
+          input,
+          refStart - 2
+        );
+      }
+      tokens.push({ type: "reference", value: refContent });
+      i += 2;
+      continue;
+    }
+    literalBuf += input[i];
+    i++;
+  }
+  if (literalBuf) {
+    tokens.push({ type: "literal", value: literalBuf });
+  }
+  return tokens;
+}
+function parseReference(ref) {
+  const match = ref.match(/^(\$?\w+)((?:\.[\w]+|\[.+?\])*)$/);
+  if (!match) {
+    const dotIndex = ref.indexOf(".");
+    const bracketIndex = ref.indexOf("[");
+    let splitAt = -1;
+    if (dotIndex !== -1 && bracketIndex !== -1) {
+      splitAt = Math.min(dotIndex, bracketIndex);
+    } else if (dotIndex !== -1) {
+      splitAt = dotIndex;
+    } else if (bracketIndex !== -1) {
+      splitAt = bracketIndex;
+    }
+    if (splitAt > 0) {
+      return {
+        base: ref.slice(0, splitAt),
+        path: ref.slice(splitAt)
+      };
+    }
+    return { base: ref, path: "" };
+  }
+  return {
+    base: match[1],
+    path: match[2] || ""
+  };
+}
+function resolveReference(ref, context) {
+  const { base, path } = ref;
+  if (base === "$input") {
+    return resolveInputRef(path, context);
+  }
+  if (base === "$trigger") {
+    return resolveTriggerRef(path, context);
+  }
+  if (context.scopeStack) {
+    for (let i = context.scopeStack.length - 1; i >= 0; i--) {
+      const scope = context.scopeStack[i];
+      if (scope.nodeId === base) {
+        return `${scope.scopeVar}['${base}']${path}`;
+      }
+    }
+  }
+  if (context.blockScopedNodeIds?.has(base)) {
+    return `flowState['${base}']${path}`;
+  }
+  if (context.symbolTable?.hasVar(base)) {
+    return `${context.symbolTable.getVarName(base)}${path}`;
+  }
+  return `flowState['${base}']${path}`;
+}
+function resolveInputRef(path, context) {
+  if (!context.currentNodeId) {
+    throw new Error(
+      `Expression parser error: No current node context for $input reference`
+    );
+  }
+  const incoming = context.ir.edges.filter(
+    (e) => e.targetNodeId === context.currentNodeId
+  );
+  const dataSource = incoming.find((e) => {
+    const src = context.nodeMap.get(e.sourceNodeId);
+    return src && src.category !== "trigger" /* TRIGGER */;
+  }) || incoming[0];
+  if (dataSource) {
+    const srcId = dataSource.sourceNodeId;
+    if (context.blockScopedNodeIds?.has(srcId)) {
+      return `flowState['${srcId}']${path}`;
+    }
+    if (context.symbolTable?.hasVar(srcId)) {
+      return `${context.symbolTable.getVarName(srcId)}${path}`;
+    }
+    return `flowState['${srcId}']${path}`;
+  }
+  throw new Error(
+    `Expression parser error: Node "${context.currentNodeId}" has no input connected`
+  );
+}
+function resolveTriggerRef(path, context) {
+  const trigger = context.ir.nodes.find(
+    (n) => n.category === "trigger" /* TRIGGER */
+  );
+  if (trigger) {
+    if (context.symbolTable?.hasVar(trigger.id)) {
+      return `${context.symbolTable.getVarName(trigger.id)}${path}`;
+    }
+    return `flowState['${trigger.id}']${path}`;
+  }
+  return "undefined";
+}
+var ExpressionParseError = class extends Error {
+  constructor(message, expression, position) {
+    super(message);
+    this.expression = expression;
+    this.position = position;
+    this.name = "ExpressionParseError";
+  }
+};
+
+// src/lib/compiler/platforms/types.ts
+var platformRegistry = /* @__PURE__ */ new Map();
+function registerPlatform(name, factory) {
+  platformRegistry.set(name, factory);
+}
+function getPlatform(name) {
+  const factory = platformRegistry.get(name);
+  if (!factory) {
+    throw new Error(
+      `Unknown platform "${name}". Available platforms: ${[...platformRegistry.keys()].join(", ")}`
+    );
+  }
+  return factory();
+}
+function getAvailablePlatforms() {
+  return [...platformRegistry.keys()];
+}
+
+// src/lib/compiler/platforms/nextjs.ts
+var NextjsPlatform = class {
+  name = "nextjs";
+  generateImports(sourceFile, trigger, _context) {
+    if (trigger.nodeType !== "http_webhook" /* HTTP_WEBHOOK */) return;
+    const params = trigger.params;
+    const isGetOrDelete = ["GET", "DELETE"].includes(params.method);
+    sourceFile.addImportDeclaration({
+      namedImports: isGetOrDelete ? ["NextRequest", "NextResponse"] : ["NextResponse"],
+      moduleSpecifier: "next/server"
+    });
+  }
+  generateFunction(sourceFile, trigger, _context, bodyGenerator) {
+    switch (trigger.nodeType) {
+      case "http_webhook" /* HTTP_WEBHOOK */:
+        this.generateHttpFunction(sourceFile, trigger, bodyGenerator);
+        break;
+      case "cron_job" /* CRON_JOB */:
+        this.generateCronFunction(sourceFile, trigger, bodyGenerator);
+        break;
+      case "manual" /* MANUAL */:
+        this.generateManualFunction(sourceFile, trigger, bodyGenerator);
+        break;
+      default:
+        throw new Error(`Unsupported trigger type: ${trigger.nodeType}`);
+    }
+  }
+  generateResponse(writer, bodyExpr, statusCode, headers) {
+    if (headers && Object.keys(headers).length > 0) {
+      writer.writeLine(
+        `throw new EarlyResponse(NextResponse.json(${bodyExpr}, { status: ${statusCode}, headers: ${JSON.stringify(headers)} }));`
+      );
+    } else {
+      writer.writeLine(
+        `throw new EarlyResponse(NextResponse.json(${bodyExpr}, { status: ${statusCode} }));`
+      );
+    }
+  }
+  generateErrorResponse(writer) {
+    writer.write("if (error instanceof EarlyResponse) ").block(() => {
+      writer.writeLine("return error.response;");
+    });
+    writer.writeLine('console.error("Workflow failed:", error);');
+    writer.writeLine(
+      'return NextResponse.json({ error: error instanceof Error ? error.message : "Internal Server Error" }, { status: 500 });'
+    );
+  }
+  getOutputFilePath(trigger) {
+    if (trigger.nodeType === "http_webhook" /* HTTP_WEBHOOK */) {
+      const params = trigger.params;
+      const routePath = params.routePath.replace(/^\//, "");
+      return `src/app/${routePath}/route.ts`;
+    }
+    if (trigger.nodeType === "cron_job" /* CRON_JOB */) {
+      const params = trigger.params;
+      return `src/lib/cron/${params.functionName}.ts`;
+    }
+    if (trigger.nodeType === "manual" /* MANUAL */) {
+      const params = trigger.params;
+      return `src/lib/functions/${params.functionName}.ts`;
+    }
+    return "src/generated/flow.ts";
+  }
+  getImplicitDependencies() {
+    return [];
+  }
+  generateTriggerInit(writer, trigger, context) {
+    const varName = context.symbolTable.getVarName(trigger.id);
+    switch (trigger.nodeType) {
+      case "http_webhook" /* HTTP_WEBHOOK */: {
+        const params = trigger.params;
+        const isGetOrDelete = ["GET", "DELETE"].includes(params.method);
+        if (isGetOrDelete) {
+          writer.writeLine("const searchParams = req.nextUrl.searchParams;");
+          writer.writeLine(
+            "const query = Object.fromEntries(searchParams.entries());"
+          );
+          writer.writeLine(`const ${varName} = { query, url: req.url };`);
+          writer.writeLine(`flowState['${trigger.id}'] = ${varName};`);
+        } else if (params.parseBody && ["POST", "PUT", "PATCH"].includes(params.method)) {
+          writer.writeLine("let body: unknown;");
+          writer.write("try ").block(() => {
+            writer.writeLine("body = await req.json();");
+          });
+          writer.write(" catch ").block(() => {
+            writer.writeLine(
+              'return NextResponse.json({ error: "Invalid JSON body" }, { status: 400 });'
+            );
+          });
+          writer.writeLine(`const ${varName} = { body, url: req.url };`);
+          writer.writeLine(`flowState['${trigger.id}'] = ${varName};`);
+        } else {
+          writer.writeLine(`const ${varName} = { url: req.url };`);
+          writer.writeLine(`flowState['${trigger.id}'] = ${varName};`);
+        }
+        break;
+      }
+      case "cron_job" /* CRON_JOB */: {
+        writer.writeLine(
+          `const ${varName} = { triggeredAt: new Date().toISOString() };`
+        );
+        writer.writeLine(`flowState['${trigger.id}'] = ${varName};`);
+        break;
+      }
+      case "manual" /* MANUAL */: {
+        const params = trigger.params;
+        if (params.args.length > 0) {
+          const argsObj = params.args.map((a) => a.name).join(", ");
+          writer.writeLine(`const ${varName} = { ${argsObj} };`);
+          writer.writeLine(`flowState['${trigger.id}'] = ${varName};`);
+        }
+        break;
+      }
+    }
+  }
+  // ── Private ──
+  generateHttpFunction(sourceFile, trigger, bodyGenerator) {
+    const params = trigger.params;
+    const isGetOrDelete = ["GET", "DELETE"].includes(params.method);
+    const funcDecl = sourceFile.addFunction({
+      name: params.method,
+      isAsync: true,
+      isExported: true,
+      parameters: [
+        { name: "req", type: isGetOrDelete ? "NextRequest" : "Request" }
+      ]
+    });
+    sourceFile.insertStatements(funcDecl.getChildIndex(), (writer) => {
+      writer.writeLine("class EarlyResponse extends Error {");
+      writer.writeLine("  constructor(public response: Response) { super(); }");
+      writer.writeLine("}");
+      writer.blankLine();
+    });
+    funcDecl.addStatements((writer) => {
+      writer.write("try ").block(() => {
+        bodyGenerator(writer);
+      });
+      writer.write(" catch (error) ").block(() => {
+        this.generateErrorResponse(writer);
+      });
+    });
+  }
+  generateCronFunction(sourceFile, trigger, bodyGenerator) {
+    const params = trigger.params;
+    sourceFile.addStatements(`// @schedule ${params.schedule}`);
+    const funcDecl = sourceFile.addFunction({
+      name: params.functionName,
+      isAsync: true,
+      isExported: true
+    });
+    funcDecl.addStatements((writer) => {
+      bodyGenerator(writer);
+    });
+  }
+  generateManualFunction(sourceFile, trigger, bodyGenerator) {
+    const params = trigger.params;
+    const funcDecl = sourceFile.addFunction({
+      name: params.functionName,
+      isAsync: true,
+      isExported: true,
+      parameters: params.args.map((arg) => ({
+        name: arg.name,
+        type: arg.type
+      }))
+    });
+    funcDecl.addStatements((writer) => {
+      bodyGenerator(writer);
+    });
+  }
+};
+
+// src/lib/compiler/platforms/express.ts
+var ExpressPlatform = class {
+  name = "express";
+  generateImports(sourceFile, trigger, _context) {
+    if (trigger.nodeType === "http_webhook" /* HTTP_WEBHOOK */) {
+      sourceFile.addImportDeclaration({
+        namedImports: ["Request", "Response"],
+        moduleSpecifier: "express"
+      });
+    }
+  }
+  generateFunction(sourceFile, trigger, _context, bodyGenerator) {
+    switch (trigger.nodeType) {
+      case "http_webhook" /* HTTP_WEBHOOK */:
+        this.generateHttpHandler(sourceFile, trigger, bodyGenerator);
+        break;
+      case "cron_job" /* CRON_JOB */:
+        this.generateCronFunction(sourceFile, trigger, bodyGenerator);
+        break;
+      case "manual" /* MANUAL */:
+        this.generateManualFunction(sourceFile, trigger, bodyGenerator);
+        break;
+      default:
+        throw new Error(`Unsupported trigger type: ${trigger.nodeType}`);
+    }
+  }
+  generateResponse(writer, bodyExpr, statusCode, headers) {
+    if (headers && Object.keys(headers).length > 0) {
+      for (const [key, value] of Object.entries(headers)) {
+        writer.writeLine(`res.setHeader(${JSON.stringify(key)}, ${JSON.stringify(value)});`);
+      }
+    }
+    writer.writeLine(`throw new EarlyResponse(() => res.status(${statusCode}).json(${bodyExpr}));`);
+  }
+  generateErrorResponse(writer) {
+    writer.write("if (error instanceof EarlyResponse) ").block(() => {
+      writer.writeLine("return error.send();");
+    });
+    writer.writeLine('console.error("Workflow failed:", error);');
+    writer.writeLine(
+      'return res.status(500).json({ error: error instanceof Error ? error.message : "Internal Server Error" });'
+    );
+  }
+  getOutputFilePath(trigger) {
+    if (trigger.nodeType === "http_webhook" /* HTTP_WEBHOOK */) {
+      const params = trigger.params;
+      const routePath = params.routePath.replace(/^\//, "").replace(/\//g, "-");
+      return `src/routes/${routePath}.ts`;
+    }
+    if (trigger.nodeType === "cron_job" /* CRON_JOB */) {
+      const params = trigger.params;
+      return `src/cron/${params.functionName}.ts`;
+    }
+    if (trigger.nodeType === "manual" /* MANUAL */) {
+      const params = trigger.params;
+      return `src/functions/${params.functionName}.ts`;
+    }
+    return "src/generated/flow.ts";
+  }
+  getImplicitDependencies() {
+    return ["express", "@types/express"];
+  }
+  generateTriggerInit(writer, trigger, context) {
+    const varName = context.symbolTable.getVarName(trigger.id);
+    switch (trigger.nodeType) {
+      case "http_webhook" /* HTTP_WEBHOOK */: {
+        const params = trigger.params;
+        const isGetOrDelete = ["GET", "DELETE"].includes(params.method);
+        if (isGetOrDelete) {
+          writer.writeLine(
+            "const query = req.query as Record<string, string>;"
+          );
+          writer.writeLine(
+            `const ${varName} = { query, url: req.originalUrl };`
+          );
+          writer.writeLine(`flowState['${trigger.id}'] = ${varName};`);
+        } else if (params.parseBody && ["POST", "PUT", "PATCH"].includes(params.method)) {
+          writer.writeLine("const body = req.body;");
+          writer.writeLine(
+            `const ${varName} = { body, url: req.originalUrl };`
+          );
+          writer.writeLine(`flowState['${trigger.id}'] = ${varName};`);
+        } else {
+          writer.writeLine(
+            `const ${varName} = { url: req.originalUrl };`
+          );
+          writer.writeLine(`flowState['${trigger.id}'] = ${varName};`);
+        }
+        break;
+      }
+      case "cron_job" /* CRON_JOB */: {
+        writer.writeLine(
+          `const ${varName} = { triggeredAt: new Date().toISOString() };`
+        );
+        writer.writeLine(`flowState['${trigger.id}'] = ${varName};`);
+        break;
+      }
+      case "manual" /* MANUAL */: {
+        const params = trigger.params;
+        if (params.args.length > 0) {
+          const argsObj = params.args.map((a) => a.name).join(", ");
+          writer.writeLine(`const ${varName} = { ${argsObj} };`);
+          writer.writeLine(`flowState['${trigger.id}'] = ${varName};`);
+        }
+        break;
+      }
+    }
+  }
+  // ── Private ──
+  generateHttpHandler(sourceFile, trigger, bodyGenerator) {
+    const params = trigger.params;
+    const funcDecl = sourceFile.addFunction({
+      name: `handle${params.method.charAt(0)}${params.method.slice(1).toLowerCase()}`,
+      isAsync: true,
+      isExported: true,
+      parameters: [
+        { name: "req", type: "Request" },
+        { name: "res", type: "Response" }
+      ]
+    });
+    sourceFile.insertStatements(funcDecl.getChildIndex(), (writer) => {
+      writer.writeLine("class EarlyResponse extends Error {");
+      writer.writeLine("  constructor(public send: () => void) { super(); }");
+      writer.writeLine("}");
+      writer.blankLine();
+    });
+    funcDecl.addStatements((writer) => {
+      writer.write("try ").block(() => {
+        bodyGenerator(writer);
+      });
+      writer.write(" catch (error) ").block(() => {
+        this.generateErrorResponse(writer);
+      });
+    });
+  }
+  generateCronFunction(sourceFile, trigger, bodyGenerator) {
+    const params = trigger.params;
+    sourceFile.addStatements(`// @schedule ${params.schedule}`);
+    const funcDecl = sourceFile.addFunction({
+      name: params.functionName,
+      isAsync: true,
+      isExported: true
+    });
+    funcDecl.addStatements((writer) => {
+      bodyGenerator(writer);
+    });
+  }
+  generateManualFunction(sourceFile, trigger, bodyGenerator) {
+    const params = trigger.params;
+    const funcDecl = sourceFile.addFunction({
+      name: params.functionName,
+      isAsync: true,
+      isExported: true,
+      parameters: params.args.map((arg) => ({
+        name: arg.name,
+        type: arg.type
+      }))
+    });
+    funcDecl.addStatements((writer) => {
+      bodyGenerator(writer);
+    });
+  }
+};
+
+// src/lib/compiler/platforms/cloudflare.ts
+var CloudflarePlatform = class {
+  name = "cloudflare";
+  generateImports(_sourceFile, _trigger, _context) {
+  }
+  generateFunction(sourceFile, trigger, _context, bodyGenerator) {
+    switch (trigger.nodeType) {
+      case "http_webhook" /* HTTP_WEBHOOK */:
+        this.generateFetchHandler(sourceFile, trigger, bodyGenerator);
+        break;
+      case "cron_job" /* CRON_JOB */:
+        this.generateScheduledHandler(sourceFile, trigger, bodyGenerator);
+        break;
+      case "manual" /* MANUAL */:
+        this.generateManualFunction(sourceFile, trigger, bodyGenerator);
+        break;
+      default:
+        throw new Error(`Unsupported trigger type: ${trigger.nodeType}`);
+    }
+  }
+  generateResponse(writer, bodyExpr, statusCode, headers) {
+    const headersObj = headers && Object.keys(headers).length > 0 ? `, { status: ${statusCode}, headers: ${JSON.stringify({ "Content-Type": "application/json", ...headers })} }` : `, { status: ${statusCode}, headers: { "Content-Type": "application/json" } }`;
+    writer.writeLine(
+      `throw new EarlyResponse(new Response(JSON.stringify(${bodyExpr})${headersObj}));`
+    );
+  }
+  generateErrorResponse(writer) {
+    writer.write("if (error instanceof EarlyResponse) ").block(() => {
+      writer.writeLine("return error.response;");
+    });
+    writer.writeLine('console.error("Workflow failed:", error);');
+    writer.writeLine(
+      `return new Response(JSON.stringify({ error: error instanceof Error ? error.message : "Internal Server Error" }), { status: 500, headers: { "Content-Type": "application/json" } });`
+    );
+  }
+  getOutputFilePath(trigger) {
+    if (trigger.nodeType === "http_webhook" /* HTTP_WEBHOOK */) {
+      return "src/worker.ts";
+    }
+    if (trigger.nodeType === "cron_job" /* CRON_JOB */) {
+      const params = trigger.params;
+      return `src/scheduled/${params.functionName}.ts`;
+    }
+    if (trigger.nodeType === "manual" /* MANUAL */) {
+      const params = trigger.params;
+      return `src/functions/${params.functionName}.ts`;
+    }
+    return "src/generated/flow.ts";
+  }
+  getImplicitDependencies() {
+    return ["@cloudflare/workers-types"];
+  }
+  generateTriggerInit(writer, trigger, context) {
+    const varName = context.symbolTable.getVarName(trigger.id);
+    switch (trigger.nodeType) {
+      case "http_webhook" /* HTTP_WEBHOOK */: {
+        const params = trigger.params;
+        const isGetOrDelete = ["GET", "DELETE"].includes(params.method);
+        if (isGetOrDelete) {
+          writer.writeLine(
+            "const url = new URL(request.url);"
+          );
+          writer.writeLine(
+            "const query = Object.fromEntries(url.searchParams.entries());"
+          );
+          writer.writeLine(
+            `const ${varName} = { query, url: request.url };`
+          );
+          writer.writeLine(`flowState['${trigger.id}'] = ${varName};`);
+        } else if (params.parseBody && ["POST", "PUT", "PATCH"].includes(params.method)) {
+          writer.writeLine("let body: unknown;");
+          writer.write("try ").block(() => {
+            writer.writeLine("body = await request.json();");
+          });
+          writer.write(" catch ").block(() => {
+            writer.writeLine(
+              'return new Response(JSON.stringify({ error: "Invalid JSON body" }), { status: 400, headers: { "Content-Type": "application/json" } });'
+            );
+          });
+          writer.writeLine(
+            `const ${varName} = { body, url: request.url };`
+          );
+          writer.writeLine(`flowState['${trigger.id}'] = ${varName};`);
+        } else {
+          writer.writeLine(
+            `const ${varName} = { url: request.url };`
+          );
+          writer.writeLine(`flowState['${trigger.id}'] = ${varName};`);
+        }
+        break;
+      }
+      case "cron_job" /* CRON_JOB */: {
+        writer.writeLine(
+          `const ${varName} = { triggeredAt: new Date().toISOString() };`
+        );
+        writer.writeLine(`flowState['${trigger.id}'] = ${varName};`);
+        break;
+      }
+      case "manual" /* MANUAL */: {
+        const params = trigger.params;
+        if (params.args.length > 0) {
+          const argsObj = params.args.map((a) => a.name).join(", ");
+          writer.writeLine(`const ${varName} = { ${argsObj} };`);
+          writer.writeLine(`flowState['${trigger.id}'] = ${varName};`);
+        }
+        break;
+      }
+    }
+  }
+  // ── Private ──
+  generateFetchHandler(sourceFile, trigger, bodyGenerator) {
+    const params = trigger.params;
+    sourceFile.addStatements(`// Cloudflare Workers handler`);
+    const funcDecl = sourceFile.addFunction({
+      name: "handleRequest",
+      isAsync: true,
+      isExported: true,
+      parameters: [
+        { name: "request", type: "Request" },
+        { name: "env", type: "Env" },
+        { name: "ctx", type: "ExecutionContext" }
+      ]
+    });
+    sourceFile.insertStatements(funcDecl.getChildIndex(), (writer) => {
+      writer.writeLine("class EarlyResponse extends Error {");
+      writer.writeLine("  constructor(public response: Response) { super(); }");
+      writer.writeLine("}");
+      writer.blankLine();
+    });
+    funcDecl.addStatements((writer) => {
+      writer.write("try ").block(() => {
+        bodyGenerator(writer);
+      });
+      writer.write(" catch (error) ").block(() => {
+        this.generateErrorResponse(writer);
+      });
+    });
+    sourceFile.addStatements(`
+export default {
+  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
+    return handleRequest(request, env, ctx);
+  },
+};`);
+  }
+  generateScheduledHandler(sourceFile, trigger, bodyGenerator) {
+    const params = trigger.params;
+    sourceFile.addStatements(`// @schedule ${params.schedule}`);
+    const funcDecl = sourceFile.addFunction({
+      name: params.functionName,
+      isAsync: true,
+      isExported: true
+    });
+    funcDecl.addStatements((writer) => {
+      bodyGenerator(writer);
+    });
+  }
+  generateManualFunction(sourceFile, trigger, bodyGenerator) {
+    const params = trigger.params;
+    const funcDecl = sourceFile.addFunction({
+      name: params.functionName,
+      isAsync: true,
+      isExported: true,
+      parameters: params.args.map((arg) => ({
+        name: arg.name,
+        type: arg.type
+      }))
+    });
+    funcDecl.addStatements((writer) => {
+      bodyGenerator(writer);
+    });
+  }
+};
+
+// src/lib/compiler/platforms/index.ts
+registerPlatform("nextjs", () => new NextjsPlatform());
+registerPlatform("express", () => new ExpressPlatform());
+registerPlatform("cloudflare", () => new CloudflarePlatform());
+
+// src/lib/compiler/plugins/types.ts
+function createPluginRegistry() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    register(plugin) {
+      map.set(plugin.nodeType, plugin);
+    },
+    registerAll(plugins) {
+      for (const p of plugins) map.set(p.nodeType, p);
+    },
+    get(nodeType) {
+      return map.get(nodeType);
+    },
+    has(nodeType) {
+      return map.has(nodeType);
+    },
+    getAll() {
+      return new Map(map);
+    },
+    clear() {
+      map.clear();
+    }
+  };
+}
+var globalRegistry = createPluginRegistry();
+function registerPlugin(plugin) {
+  globalRegistry.register(plugin);
+}
+function registerPlugins(plugins) {
+  globalRegistry.registerAll(plugins);
+}
+function getPlugin(nodeType) {
+  return globalRegistry.get(nodeType);
+}
+function getAllPlugins() {
+  return globalRegistry.getAll();
+}
+function clearPlugins() {
+  globalRegistry.clear();
+}
+function hasPlugin(nodeType) {
+  return globalRegistry.has(nodeType);
+}
+
+// src/lib/compiler/plugins/builtin.ts
+function inferTypeFromExpression(expr) {
+  const trimmed = expr.trim();
+  if (/\.map\s*\(/.test(trimmed)) return "unknown[]";
+  if (/\.filter\s*\(/.test(trimmed)) return "unknown[]";
+  if (/\.flatMap\s*\(/.test(trimmed)) return "unknown[]";
+  if (/\.slice\s*\(/.test(trimmed)) return "unknown[]";
+  if (/\.concat\s*\(/.test(trimmed)) return "unknown[]";
+  if (/\.sort\s*\(/.test(trimmed)) return "unknown[]";
+  if (/\.reverse\s*\(/.test(trimmed)) return "unknown[]";
+  if (/Array\.from\s*\(/.test(trimmed)) return "unknown[]";
+  if (/\.flat\s*\(/.test(trimmed)) return "unknown[]";
+  if (/\.entries\s*\(/.test(trimmed)) return "[string, unknown][]";
+  if (/\.reduce\s*\(/.test(trimmed)) return "unknown";
+  if (/\.length\b/.test(trimmed)) return "number";
+  if (/\.indexOf\s*\(/.test(trimmed)) return "number";
+  if (/\.findIndex\s*\(/.test(trimmed)) return "number";
+  if (/parseInt\s*\(/.test(trimmed)) return "number";
+  if (/parseFloat\s*\(/.test(trimmed)) return "number";
+  if (/Number\s*\(/.test(trimmed)) return "number";
+  if (/Math\./.test(trimmed)) return "number";
+  if (/\.includes\s*\(/.test(trimmed)) return "boolean";
+  if (/\.some\s*\(/.test(trimmed)) return "boolean";
+  if (/\.every\s*\(/.test(trimmed)) return "boolean";
+  if (/\.has\s*\(/.test(trimmed)) return "boolean";
+  if (/^!/.test(trimmed)) return "boolean";
+  if (/===|!==|==|!=|>=|<=|>|<|&&|\|\|/.test(trimmed)) return "boolean";
+  if (/\.join\s*\(/.test(trimmed)) return "string";
+  if (/\.toString\s*\(/.test(trimmed)) return "string";
+  if (/\.trim\s*\(/.test(trimmed)) return "string";
+  if (/\.replace\s*\(/.test(trimmed)) return "string";
+  if (/\.toLowerCase\s*\(/.test(trimmed)) return "string";
+  if (/\.toUpperCase\s*\(/.test(trimmed)) return "string";
+  if (/String\s*\(/.test(trimmed)) return "string";
+  if (/JSON\.stringify\s*\(/.test(trimmed)) return "string";
+  if (/`[^`]*`/.test(trimmed)) return "string";
+  if (/JSON\.parse\s*\(/.test(trimmed)) return "unknown";
+  if (/Object\.keys\s*\(/.test(trimmed)) return "string[]";
+  if (/Object\.values\s*\(/.test(trimmed)) return "unknown[]";
+  if (/Object\.entries\s*\(/.test(trimmed)) return "[string, unknown][]";
+  if (/Object\.assign\s*\(/.test(trimmed)) return "Record<string, unknown>";
+  if (/Object\.fromEntries\s*\(/.test(trimmed)) return "Record<string, unknown>";
+  if (/^\{/.test(trimmed)) return "Record<string, unknown>";
+  if (/^\[/.test(trimmed)) return "unknown[]";
+  if (/\.\.\.\s*\{\{/.test(trimmed)) return "Record<string, unknown>";
+  if (/\.find\s*\(/.test(trimmed)) return "unknown | undefined";
+  return "unknown";
+}
+function inferTypeFromCode(code, returnVar) {
+  const declMatch = code.match(
+    new RegExp(`(?:const|let|var)\\s+${escapeRegex(returnVar)}\\s*(?::\\s*([^=]+?))?\\s*=\\s*(.+?)(?:;|$)`, "m")
+  );
+  if (declMatch) {
+    const typeAnnotation = declMatch[1]?.trim();
+    if (typeAnnotation) return typeAnnotation;
+    const initializer = declMatch[2]?.trim();
+    if (initializer) {
+      if (/^\[/.test(initializer)) return "unknown[]";
+      if (/^\{/.test(initializer)) return "Record<string, unknown>";
+      if (/^["'`]/.test(initializer)) return "string";
+      if (/^\d/.test(initializer)) return "number";
+      if (/^(true|false)$/.test(initializer)) return "boolean";
+      if (/^new Map/.test(initializer)) return "Map<unknown, unknown>";
+      if (/^new Set/.test(initializer)) return "Set<unknown>";
+      if (/\.map\s*\(/.test(initializer)) return "unknown[]";
+      if (/\.filter\s*\(/.test(initializer)) return "unknown[]";
+    }
+  }
+  return "unknown";
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var httpWebhookPlugin = {
+  nodeType: "http_webhook" /* HTTP_WEBHOOK */,
+  generate: () => {
+  },
+  getOutputType(node) {
+    const params = node.params;
+    if (["GET", "DELETE"].includes(params.method)) {
+      return "{ query: Record<string, string>; url: string }";
+    }
+    if (params.parseBody) {
+      return "{ body: unknown; url: string }";
+    }
+    return "{ url: string }";
+  }
+};
+var cronJobPlugin = {
+  nodeType: "cron_job" /* CRON_JOB */,
+  generate: () => {
+  },
+  getOutputType: () => "{ triggeredAt: string }"
+};
+var manualPlugin = {
+  nodeType: "manual" /* MANUAL */,
+  generate: () => {
+  },
+  getOutputType: () => "Record<string, unknown>"
+};
+var fetchApiPlugin = {
+  nodeType: "fetch_api" /* FETCH_API */,
+  generate(node, writer, context) {
+    const params = node.params;
+    const url = context.resolveEnvVars(params.url);
+    writer.write("try ").block(() => {
+      const hasBody = params.body && ["POST", "PUT", "PATCH"].includes(params.method);
+      writer.writeLine(`const response = await fetch(${url}, {`);
+      writer.writeLine(`  method: "${params.method}",`);
+      if (params.headers && Object.keys(params.headers).length > 0) {
+        writer.writeLine(`  headers: ${JSON.stringify(params.headers)},`);
+      } else if (hasBody) {
+        writer.writeLine(
+          `  headers: { "Content-Type": "application/json" },`
+        );
+      }
+      if (hasBody) {
+        const bodyExpr = context.resolveExpression(params.body, node.id);
+        if (bodyExpr.trimStart().startsWith("JSON.stringify")) {
+          writer.writeLine(`  body: ${bodyExpr},`);
+        } else {
+          writer.writeLine(`  body: JSON.stringify(${bodyExpr}),`);
+        }
+      }
+      writer.writeLine("});");
+      writer.blankLine();
+      writer.write("if (!response.ok) ").block(() => {
+        writer.writeLine(
+          `throw new Error(\`${node.label} failed: HTTP \${response.status} \${response.statusText}\`);`
+        );
+      });
+      writer.blankLine();
+      if (params.parseJson) {
+        writer.writeLine(`const data = await response.json();`);
+        writer.writeLine(`flowState['${node.id}'] = {`);
+        writer.writeLine(`  data,`);
+        writer.writeLine(`  status: response.status,`);
+        writer.writeLine(`  headers: Object.fromEntries(response.headers.entries()),`);
+        writer.writeLine(`};`);
+      } else {
+        writer.writeLine(`flowState['${node.id}'] = response;`);
+      }
+    });
+    writer.write(" catch (fetchError) ").block(() => {
+      writer.writeLine(
+        `console.error("Fetch failed for ${node.label}:", fetchError);`
+      );
+      writer.writeLine(`throw fetchError;`);
+    });
+  },
+  getRequiredPackages: () => [],
+  getOutputType(node) {
+    const params = node.params;
+    return params.parseJson ? "{ data: unknown; status: number; headers: Record<string, string> }" : "Response";
+  }
+};
+var sqlQueryPlugin = {
+  nodeType: "sql_query" /* SQL_QUERY */,
+  generate(node, writer) {
+    const params = node.params;
+    switch (params.orm) {
+      case "drizzle":
+        writer.writeLine(`// Drizzle ORM Query`);
+        writer.writeLine(
+          `const result = await db.execute(sql\`${params.query}\`);`
+        );
+        writer.writeLine(`flowState['${node.id}'] = result;`);
+        break;
+      case "prisma":
+        writer.writeLine(`// Prisma Query`);
+        writer.writeLine(
+          `const result = await prisma.$queryRaw\`${params.query}\`;`
+        );
+        writer.writeLine(`flowState['${node.id}'] = result;`);
+        break;
+      case "raw":
+      default:
+        writer.writeLine(`// Raw SQL Query`);
+        writer.writeLine(
+          `const result = await db.query(\`${params.query}\`);`
+        );
+        writer.writeLine(`flowState['${node.id}'] = result;`);
+        break;
+    }
+  },
+  getRequiredPackages(node) {
+    const params = node.params;
+    const map = {
+      drizzle: ["drizzle-orm"],
+      prisma: ["@prisma/client"],
+      raw: []
+    };
+    return map[params.orm] ?? [];
+  },
+  getOutputType: () => "unknown[]"
+};
+var redisCachePlugin = {
+  nodeType: "redis_cache" /* REDIS_CACHE */,
+  generate(node, writer) {
+    const params = node.params;
+    const needsInterpolation = params.key.includes("${") || params.key.includes("{{");
+    const keyExpr = needsInterpolation ? `\`${params.key}\`` : `"${params.key}"`;
+    switch (params.operation) {
+      case "get":
+        writer.writeLine(
+          `flowState['${node.id}'] = await redis.get(${keyExpr});`
+        );
+        break;
+      case "set":
+        if (params.ttl) {
+          writer.writeLine(
+            `await redis.set(${keyExpr}, ${params.value ?? "null"}, "EX", ${params.ttl});`
+          );
+        } else {
+          writer.writeLine(
+            `await redis.set(${keyExpr}, ${params.value ?? "null"});`
+          );
+        }
+        writer.writeLine(`flowState['${node.id}'] = true;`);
+        break;
+      case "del":
+        writer.writeLine(`await redis.del(${keyExpr});`);
+        writer.writeLine(`flowState['${node.id}'] = true;`);
+        break;
+    }
+  },
+  getRequiredPackages: () => ["ioredis"],
+  getOutputType(node) {
+    const params = node.params;
+    return params.operation === "get" ? "string | null" : "boolean";
+  }
+};
+var DANGEROUS_CODE_PATTERNS = [
+  { pattern: /\bprocess\.exit\b/, desc: "process.exit() \u2014 terminates the Node.js process" },
+  { pattern: /\bchild_process\b/, desc: "child_process \u2014 can execute arbitrary system commands" },
+  { pattern: /\beval\s*\(/, desc: "eval() \u2014 dynamically executes arbitrary code" },
+  { pattern: /\bnew\s+Function\s*\(/, desc: "new Function() \u2014 dynamically constructs functions" },
+  { pattern: /\brequire\s*\(\s*['"]fs['"]/, desc: "require('fs') \u2014 file system access" },
+  { pattern: /\bimport\s*\(\s*['"]fs['"]/, desc: "import('fs') \u2014 file system access" },
+  { pattern: /\bfs\.\w*(unlink|rmdir|rm|writeFile)\b/, desc: "fs delete/write operations" }
+];
+var customCodePlugin = {
+  nodeType: "custom_code" /* CUSTOM_CODE */,
+  generate(node, writer, context) {
+    const params = node.params;
+    const warnings = [];
+    for (const { pattern, desc } of DANGEROUS_CODE_PATTERNS) {
+      if (pattern.test(params.code)) {
+        warnings.push(desc);
+      }
+    }
+    if (warnings.length > 0) {
+      writer.writeLine(`// \u26A0\uFE0F SECURITY WARNING: This custom code uses the following dangerous APIs:`);
+      for (const w of warnings) {
+        writer.writeLine(`//   - ${w}`);
+      }
+      writer.writeLine(`// Please carefully review this code before deployment.`);
+      if (context && "addWarning" in context) {
+        const addWarning = context.addWarning;
+        addWarning?.(`[${node.id}] Custom code uses dangerous API: ${warnings.join(", ")}`);
+      }
+    }
+    const resultVar = `custom_result_${node.id.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+    if (params.returnVariable) {
+      writer.writeLine(`const ${resultVar} = await (async () => {`);
+    } else {
+      writer.writeLine(`await (async () => {`);
+    }
+    writer.writeLine(`// Custom Code: ${node.label}`);
+    const lines = params.code.split("\n");
+    for (const line of lines) {
+      writer.writeLine(`  ${line}`);
+    }
+    if (params.returnVariable) {
+      writer.writeLine(`  if (typeof ${params.returnVariable} !== 'undefined') return ${params.returnVariable};`);
+    }
+    writer.writeLine(`})();`);
+    if (params.returnVariable) {
+      writer.writeLine(`flowState['${node.id}'] = ${resultVar};`);
+    }
+  },
+  getOutputType(node) {
+    const params = node.params;
+    if (params.returnType) return params.returnType;
+    if (!params.returnVariable) return "void";
+    return inferTypeFromCode(params.code, params.returnVariable);
+  }
+};
+var callSubflowPlugin = {
+  nodeType: "call_subflow" /* CALL_SUBFLOW */,
+  generate(node, writer, context) {
+    const params = node.params;
+    const existing = context.imports.get(params.flowPath);
+    if (existing) {
+      existing.add(params.functionName);
+    } else {
+      context.imports.set(params.flowPath, /* @__PURE__ */ new Set([params.functionName]));
+    }
+    const args = Object.entries(params.inputMapping).map(([key, expr]) => {
+      const resolved = context.resolveExpression(expr, node.id);
+      return `${key}: ${resolved}`;
+    }).join(", ");
+    writer.writeLine(
+      `flowState['${node.id}'] = await ${params.functionName}({ ${args} });`
+    );
+  },
+  getOutputType(node) {
+    const params = node.params;
+    if (params.returnType) return params.returnType;
+    return `Awaited<ReturnType<typeof ${params.functionName}>>`;
+  }
+};
+var ifElsePlugin = {
+  nodeType: "if_else" /* IF_ELSE */,
+  generate(node, writer, context) {
+    const params = node.params;
+    const trueEdges = context.ir.edges.filter(
+      (e) => e.sourceNodeId === node.id && e.sourcePortId === "true"
+    );
+    const falseEdges = context.ir.edges.filter(
+      (e) => e.sourceNodeId === node.id && e.sourcePortId === "false"
+    );
+    const conditionExpr = context.resolveExpression(
+      params.condition,
+      node.id
+    );
+    writer.write(`if (${conditionExpr}) `).block(() => {
+      writer.writeLine(`flowState['${node.id}'] = true;`);
+      for (const edge of trueEdges) {
+        const childNode = context.nodeMap.get(edge.targetNodeId);
+        if (childNode) {
+          context.generateChildNode(writer, childNode);
+        }
+      }
+    });
+    if (falseEdges.length > 0) {
+      writer.write(" else ").block(() => {
+        writer.writeLine(`flowState['${node.id}'] = false;`);
+        for (const edge of falseEdges) {
+          const childNode = context.nodeMap.get(edge.targetNodeId);
+          if (childNode) {
+            context.generateChildNode(writer, childNode);
+          }
+        }
+      });
+    }
+  },
+  getOutputType: () => "boolean"
+};
+var forLoopPlugin = {
+  nodeType: "for_loop" /* FOR_LOOP */,
+  generate(node, writer, context) {
+    const params = node.params;
+    const iterableExpr = context.resolveExpression(
+      params.iterableExpression,
+      node.id
+    );
+    const sanitizedId = node.id.replace(/[^a-zA-Z0-9_]/g, "_");
+    const scopeVar = `_scope_${sanitizedId}`;
+    writer.writeLine(`const ${sanitizedId}_results: unknown[] = [];`);
+    if (params.indexVariable) {
+      writer.write(
+        `for (const [${params.indexVariable}, ${params.itemVariable}] of (${iterableExpr}).entries()) `
+      );
+    } else {
+      writer.write(
+        `for (const ${params.itemVariable} of ${iterableExpr}) `
+      );
+    }
+    writer.block(() => {
+      writer.writeLine(
+        `const ${scopeVar}: Record<string, unknown> = {};`
+      );
+      writer.writeLine(
+        `${scopeVar}['${node.id}'] = ${params.itemVariable};`
+      );
+      context.pushScope(node.id, scopeVar);
+      const childEdges = context.ir.edges.filter(
+        (e) => e.sourceNodeId === node.id && e.sourcePortId === "body"
+      );
+      for (const edge of childEdges) {
+        const childNode = context.nodeMap.get(edge.targetNodeId);
+        if (childNode) {
+          context.generateChildNode(writer, childNode);
+        }
+      }
+      context.popScope();
+      writer.writeLine(`${sanitizedId}_results.push(${params.itemVariable});`);
+    });
+    writer.writeLine(`flowState['${node.id}'] = ${sanitizedId}_results;`);
+  },
+  getOutputType: () => "unknown[]"
+};
+var tryCatchPlugin = {
+  nodeType: "try_catch" /* TRY_CATCH */,
+  generate(node, writer, context) {
+    const params = node.params;
+    const successEdges = context.ir.edges.filter(
+      (e) => e.sourceNodeId === node.id && e.sourcePortId === "success"
+    );
+    const errorEdges = context.ir.edges.filter(
+      (e) => e.sourceNodeId === node.id && e.sourcePortId === "error"
+    );
+    const tryScopeVar = `_scope_${node.id.replace(/[^a-zA-Z0-9_]/g, "_")}_try`;
+    const catchScopeVar = `_scope_${node.id.replace(/[^a-zA-Z0-9_]/g, "_")}_catch`;
+    writer.write("try ").block(() => {
+      writer.writeLine(
+        `const ${tryScopeVar}: Record<string, unknown> = {};`
+      );
+      context.pushScope(node.id, tryScopeVar);
+      for (const edge of successEdges) {
+        const childNode = context.nodeMap.get(edge.targetNodeId);
+        if (childNode) {
+          context.generateChildNode(writer, childNode);
+        }
+      }
+      context.popScope();
+      writer.writeLine(
+        `flowState['${node.id}'] = { success: true };`
+      );
+    });
+    writer.write(` catch (${params.errorVariable}) `).block(() => {
+      writer.writeLine(
+        `console.error("Error in ${node.label}:", ${params.errorVariable});`
+      );
+      writer.writeLine(
+        `const ${catchScopeVar}: Record<string, unknown> = {};`
+      );
+      writer.writeLine(
+        `flowState['${node.id}'] = { success: false, error: ${params.errorVariable} };`
+      );
+      context.pushScope(node.id, catchScopeVar);
+      for (const edge of errorEdges) {
+        const childNode = context.nodeMap.get(edge.targetNodeId);
+        if (childNode) {
+          context.generateChildNode(writer, childNode);
+        }
+      }
+      context.popScope();
+    });
+  },
+  getOutputType: () => "{ success: boolean; error?: unknown }"
+};
+var promiseAllPlugin = {
+  nodeType: "promise_all" /* PROMISE_ALL */,
+  generate(node, writer) {
+    writer.writeLine(`// Promise.all handled by concurrent execution`);
+    writer.writeLine(
+      `flowState['${node.id}'] = undefined; // populated by concurrent handler`
+    );
+  },
+  getOutputType: () => "unknown[]"
+};
+var declarePlugin = {
+  nodeType: "declare" /* DECLARE */,
+  generate(node, writer) {
+    const params = node.params;
+    const keyword = params.isConst ? "const" : "let";
+    const initialValue = params.initialValue ?? "undefined";
+    writer.writeLine(`${keyword} ${params.name} = ${initialValue};`);
+    writer.writeLine(`flowState['${node.id}'] = ${params.name};`);
+  },
+  getOutputType(node) {
+    const params = node.params;
+    return params.dataType;
+  }
+};
+var transformPlugin = {
+  nodeType: "transform" /* TRANSFORM */,
+  generate(node, writer, context) {
+    const params = node.params;
+    const expr = context.resolveExpression(params.expression, node.id);
+    writer.writeLine(`flowState['${node.id}'] = ${expr};`);
+  },
+  getOutputType(node) {
+    const params = node.params;
+    return inferTypeFromExpression(params.expression);
+  }
+};
+var returnResponsePlugin = {
+  nodeType: "return_response" /* RETURN_RESPONSE */,
+  generate(node, writer, context) {
+    const params = node.params;
+    const bodyExpr = context.resolveExpression(
+      params.bodyExpression,
+      node.id
+    );
+    const ctx = context;
+    if (ctx.__platformResponse) {
+      ctx.__platformResponse(writer, bodyExpr, params.statusCode, params.headers);
+    } else {
+      if (params.headers && Object.keys(params.headers).length > 0) {
+        writer.writeLine(
+          `return NextResponse.json(${bodyExpr}, { status: ${params.statusCode}, headers: ${JSON.stringify(params.headers)} });`
+        );
+      } else {
+        writer.writeLine(
+          `return NextResponse.json(${bodyExpr}, { status: ${params.statusCode} });`
+        );
+      }
+    }
+  },
+  getOutputType: () => "never"
+};
+var builtinPlugins = [
+  // Triggers
+  httpWebhookPlugin,
+  cronJobPlugin,
+  manualPlugin,
+  // Actions
+  fetchApiPlugin,
+  sqlQueryPlugin,
+  redisCachePlugin,
+  customCodePlugin,
+  callSubflowPlugin,
+  // Logic
+  ifElsePlugin,
+  forLoopPlugin,
+  tryCatchPlugin,
+  promiseAllPlugin,
+  // Variables
+  declarePlugin,
+  transformPlugin,
+  // Output
+  returnResponsePlugin
+];
+
+// src/lib/compiler/type-inference.ts
+function inferFlowStateTypes(ir, registry) {
+  const nodeTypes = /* @__PURE__ */ new Map();
+  for (const node of ir.nodes) {
+    const type = inferNodeOutputType(node, registry);
+    nodeTypes.set(node.id, type);
+  }
+  const fields = ir.nodes.map((node) => {
+    const type = nodeTypes.get(node.id) || "unknown";
+    const safeId = node.id;
+    return `  '${safeId}'?: ${type};`;
+  }).join("\n");
+  const interfaceCode = `interface FlowState {
+${fields}
+}`;
+  return { interfaceCode, nodeTypes };
+}
+function inferNodeOutputType(node, registry) {
+  const plugin = registry?.get(node.nodeType) ?? getPlugin(node.nodeType);
+  if (plugin?.getOutputType) {
+    return plugin.getOutputType(node);
+  }
+  if (node.outputs && node.outputs.length > 0) {
+    const primaryOutput = node.outputs[0];
+    return mapFlowDataTypeToTS(primaryOutput.dataType);
+  }
+  return "unknown";
+}
+function mapFlowDataTypeToTS(dataType) {
+  switch (dataType) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "object":
+      return "Record<string, unknown>";
+    case "array":
+      return "unknown[]";
+    case "void":
+      return "void";
+    case "Response":
+      return "Response";
+    case "any":
+    default:
+      return "unknown";
+  }
+}
+
+// src/lib/compiler/symbol-table.ts
+function buildSymbolTable(ir) {
+  const mappings = /* @__PURE__ */ new Map();
+  const usedNames = /* @__PURE__ */ new Set();
+  for (const node of ir.nodes) {
+    let name = labelToVarName(node.label);
+    if (!name || RESERVED_WORDS.has(name)) {
+      name = `${name || "node"}Result`;
+    }
+    if (/^[0-9]/.test(name)) {
+      name = `_${name}`;
+    }
+    let uniqueName = name;
+    let counter = 2;
+    while (usedNames.has(uniqueName)) {
+      uniqueName = `${name}${counter}`;
+      counter++;
+    }
+    usedNames.add(uniqueName);
+    mappings.set(node.id, uniqueName);
+  }
+  return {
+    getVarName(nodeId) {
+      return mappings.get(nodeId) ?? `node_${nodeId.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+    },
+    hasVar(nodeId) {
+      return mappings.has(nodeId);
+    },
+    getAllMappings() {
+      return mappings;
+    }
+  };
+}
+function labelToVarName(label) {
+  const cleaned = label.replace(/[/\-_.]/g, " ").replace(/[^a-zA-Z0-9\s]/g, "").trim();
+  if (!cleaned) return "";
+  const words = cleaned.replace(/([a-z])([A-Z])/g, "$1 $2").split(/\s+/).filter((w) => w.length > 0);
+  if (words.length === 0) return "";
+  return words.map((word, i) => {
+    const lower = word.toLowerCase();
+    if (i === 0) return lower;
+    return lower.charAt(0).toUpperCase() + lower.slice(1);
+  }).join("");
+}
+var RESERVED_WORDS = /* @__PURE__ */ new Set([
+  // JavaScript reserved words
+  "break",
+  "case",
+  "catch",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "in",
+  "instanceof",
+  "new",
+  "return",
+  "switch",
+  "this",
+  "throw",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "class",
+  "const",
+  "enum",
+  "export",
+  "extends",
+  "import",
+  "super",
+  "implements",
+  "interface",
+  "let",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "static",
+  "yield",
+  "await",
+  "async",
+  // Built-in global values
+  "undefined",
+  "null",
+  "true",
+  "false",
+  "NaN",
+  "Infinity",
+  // Common identifiers in generated code (avoid shadowing)
+  "req",
+  "res",
+  "body",
+  "query",
+  "data",
+  "result",
+  "response",
+  "error",
+  "flowState",
+  "searchParams",
+  "NextResponse",
+  "NextRequest"
+]);
+
+// src/lib/compiler/compiler.ts
+function compile(ir, options) {
+  const pluginRegistry = createPluginRegistry();
+  pluginRegistry.registerAll(builtinPlugins);
+  if (options?.plugins) {
+    pluginRegistry.registerAll(options.plugins);
+  }
+  const validation = validateFlowIR(ir);
+  if (!validation.valid) {
+    return {
+      success: false,
+      errors: validation.errors.map((e) => `[${e.code}] ${e.message}`)
+    };
+  }
+  let plan;
+  try {
+    plan = topologicalSort(ir);
+  } catch (err) {
+    return {
+      success: false,
+      errors: [err instanceof Error ? err.message : String(err)]
+    };
+  }
+  const nodeMap = new Map(ir.nodes.map((n) => [n.id, n]));
+  const platformName = options?.platform ?? "nextjs";
+  const platform = getPlatform(platformName);
+  const symbolTable = buildSymbolTable(ir);
+  const context = {
+    ir,
+    plan,
+    nodeMap,
+    envVars: /* @__PURE__ */ new Set(),
+    imports: /* @__PURE__ */ new Map(),
+    requiredPackages: /* @__PURE__ */ new Set(),
+    sourceMapEntries: /* @__PURE__ */ new Map(),
+    currentLine: 1,
+    platform,
+    symbolTable,
+    scopeStack: [],
+    childBlockNodeIds: /* @__PURE__ */ new Set(),
+    dagMode: false,
+    symbolTableExclusions: /* @__PURE__ */ new Set(),
+    generatedBlockNodeIds: /* @__PURE__ */ new Set(),
+    pluginRegistry
+  };
+  const trigger = ir.nodes.find((n) => n.category === "trigger" /* TRIGGER */);
+  const preComputedBlockNodes = computeControlFlowDescendants(ir, trigger.id);
+  for (const nodeId of preComputedBlockNodes) {
+    context.childBlockNodeIds.add(nodeId);
+    context.symbolTableExclusions.add(nodeId);
+  }
+  const hasConcurrency = plan.steps.some(
+    (s) => s.concurrent && s.nodeIds.filter((id) => id !== trigger.id).length > 1
+  );
+  if (hasConcurrency) {
+    context.dagMode = true;
+    for (const node of ir.nodes) {
+      if (node.category !== "trigger" /* TRIGGER */) {
+        context.symbolTableExclusions.add(node.id);
+      }
+    }
+  }
+  const project = new import_ts_morph.Project({ useInMemoryFileSystem: true });
+  const sourceFile = project.createSourceFile("generated.ts", "");
+  try {
+    generateCode(sourceFile, trigger, context);
+  } catch (err) {
+    throw err;
+  }
+  sourceFile.formatText({
+    indentSize: 2,
+    convertTabsToSpaces: true
+  });
+  const code = sourceFile.getFullText();
+  const filePath = platform.getOutputFilePath(trigger);
+  collectRequiredPackages(ir, context);
+  const sourceMap = buildSourceMap(code, ir, filePath);
+  const dependencies = {
+    all: [...context.requiredPackages].sort(),
+    missing: [...context.requiredPackages].sort(),
+    installCommand: context.requiredPackages.size > 0 ? `npm install ${[...context.requiredPackages].sort().join(" ")}` : void 0
+  };
+  return {
+    success: true,
+    code,
+    filePath,
+    dependencies,
+    sourceMap
+  };
+}
+function generateCode(sourceFile, trigger, context) {
+  const { platform } = context;
+  platform.generateImports(sourceFile, trigger, {
+    ir: context.ir,
+    nodeMap: context.nodeMap,
+    envVars: context.envVars,
+    imports: context.imports
+  });
+  platform.generateFunction(
+    sourceFile,
+    trigger,
+    {
+      ir: context.ir,
+      nodeMap: context.nodeMap,
+      envVars: context.envVars,
+      imports: context.imports
+    },
+    (writer) => {
+      generateFunctionBody(writer, trigger, context);
+    }
+  );
+}
+function generateFunctionBody(writer, trigger, context) {
+  const { ir } = context;
+  const typeInfo = inferFlowStateTypes(ir, context.pluginRegistry);
+  writer.writeLine(typeInfo.interfaceCode);
+  writer.writeLine("const flowState: Partial<FlowState> = {};");
+  writer.blankLine();
+  context.platform.generateTriggerInit(writer, trigger, {
+    symbolTable: context.symbolTable
+  });
+  writer.blankLine();
+  generateNodeChain(writer, trigger.id, context);
+}
+var CONTROL_FLOW_PORT_MAP = {
+  ["if_else" /* IF_ELSE */]: /* @__PURE__ */ new Set(["true", "false"]),
+  ["for_loop" /* FOR_LOOP */]: /* @__PURE__ */ new Set(["body"]),
+  ["try_catch" /* TRY_CATCH */]: /* @__PURE__ */ new Set(["success", "error"])
+};
+function isControlFlowEdge(edge, nodeMap) {
+  const sourceNode = nodeMap.get(edge.sourceNodeId);
+  if (!sourceNode) return false;
+  const controlPorts = CONTROL_FLOW_PORT_MAP[sourceNode.nodeType];
+  return controlPorts !== void 0 && controlPorts.has(edge.sourcePortId);
+}
+function computeControlFlowDescendants(ir, triggerId) {
+  const nodeMap = new Map(ir.nodes.map((n) => [n.id, n]));
+  const strippedSuccessors = /* @__PURE__ */ new Map();
+  for (const node of ir.nodes) {
+    strippedSuccessors.set(node.id, /* @__PURE__ */ new Set());
+  }
+  for (const edge of ir.edges) {
+    if (isControlFlowEdge(edge, nodeMap)) continue;
+    strippedSuccessors.get(edge.sourceNodeId)?.add(edge.targetNodeId);
+  }
+  const reachableWithoutControlFlow = /* @__PURE__ */ new Set();
+  const queue = [triggerId];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    if (reachableWithoutControlFlow.has(id)) continue;
+    reachableWithoutControlFlow.add(id);
+    for (const succ of strippedSuccessors.get(id) ?? []) {
+      if (!reachableWithoutControlFlow.has(succ)) {
+        queue.push(succ);
+      }
+    }
+  }
+  const childBlockNodeIds = /* @__PURE__ */ new Set();
+  for (const node of ir.nodes) {
+    if (node.id === triggerId) continue;
+    if (!reachableWithoutControlFlow.has(node.id)) {
+      childBlockNodeIds.add(node.id);
+    }
+  }
+  return childBlockNodeIds;
+}
+function generateBlockContinuation(writer, fromNodeId, context) {
+  const reachable = /* @__PURE__ */ new Set();
+  const bfsQueue = [fromNodeId];
+  const edgeSuccessors = /* @__PURE__ */ new Map();
+  for (const edge of context.ir.edges) {
+    if (!edgeSuccessors.has(edge.sourceNodeId)) {
+      edgeSuccessors.set(edge.sourceNodeId, []);
+    }
+    edgeSuccessors.get(edge.sourceNodeId).push(edge.targetNodeId);
+  }
+  while (bfsQueue.length > 0) {
+    const id = bfsQueue.shift();
+    if (reachable.has(id)) continue;
+    reachable.add(id);
+    for (const succ of edgeSuccessors.get(id) ?? []) {
+      if (!reachable.has(succ)) {
+        bfsQueue.push(succ);
+      }
+    }
+  }
+  for (const nodeId of context.plan.sortedNodeIds) {
+    if (nodeId === fromNodeId) continue;
+    if (!reachable.has(nodeId)) continue;
+    if (!context.childBlockNodeIds.has(nodeId)) continue;
+    if (context.generatedBlockNodeIds.has(nodeId)) continue;
+    const deps = context.plan.dependencies.get(nodeId) ?? /* @__PURE__ */ new Set();
+    const allBlockDepsReady = [...deps].every((depId) => {
+      if (!context.childBlockNodeIds.has(depId)) return true;
+      return context.generatedBlockNodeIds.has(depId);
+    });
+    if (!allBlockDepsReady) continue;
+    const node = context.nodeMap.get(nodeId);
+    if (!node) continue;
+    context.generatedBlockNodeIds.add(nodeId);
+    context.symbolTableExclusions.add(nodeId);
+    writer.writeLine(`// --- ${node.label} (${node.nodeType}) [${node.id}] ---`);
+    generateNodeBody(writer, node, context);
+  }
+}
+function generateNodeChain(writer, triggerId, context) {
+  if (context.dagMode) {
+    generateNodeChainDAG(writer, triggerId, context);
+  } else {
+    generateNodeChainSequential(writer, triggerId, context);
+  }
+}
+function generateNodeChainSequential(writer, triggerId, context) {
+  const { plan, nodeMap } = context;
+  for (const step of plan.steps) {
+    const activeNodes = step.nodeIds.filter(
+      (id) => id !== triggerId && !context.childBlockNodeIds.has(id)
+    );
+    if (activeNodes.length === 0) continue;
+    if (step.concurrent && activeNodes.length > 1) {
+      generateConcurrentNodes(writer, activeNodes, context);
+    } else {
+      for (const nodeId of activeNodes) {
+        const node = nodeMap.get(nodeId);
+        if (!node) continue;
+        generateSingleNode(writer, node, context);
+        writer.blankLine();
+      }
+    }
+  }
+}
+function resolveToDAGNodes(depId, triggerId, context, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(depId) || depId === triggerId) return [];
+  visited.add(depId);
+  if (!context.childBlockNodeIds.has(depId)) return [depId];
+  const parentDeps = context.plan.dependencies.get(depId) ?? /* @__PURE__ */ new Set();
+  const result = [];
+  for (const pd of parentDeps) {
+    result.push(...resolveToDAGNodes(pd, triggerId, context, visited));
+  }
+  return result;
+}
+function generateNodeChainDAG(writer, triggerId, context) {
+  const { plan, nodeMap } = context;
+  const allNodeIds = plan.sortedNodeIds.filter((id) => id !== triggerId);
+  const outputNodeIds = [];
+  const dagNodeIds = [];
+  for (const id of allNodeIds) {
+    if (context.childBlockNodeIds.has(id)) continue;
+    const node = nodeMap.get(id);
+    if (!node) continue;
+    if (node.category === "output" /* OUTPUT */) {
+      outputNodeIds.push(id);
+    } else {
+      dagNodeIds.push(id);
+    }
+  }
+  if (dagNodeIds.length > 0) {
+    writer.writeLine("// --- DAG Concurrent Execution ---");
+    writer.blankLine();
+  }
+  for (const nodeId of dagNodeIds) {
+    const node = nodeMap.get(nodeId);
+    const rawDeps = [...plan.dependencies.get(nodeId) ?? []];
+    const resolvedDeps = /* @__PURE__ */ new Set();
+    for (const depId of rawDeps) {
+      for (const dagDep of resolveToDAGNodes(depId, triggerId, context)) {
+        resolvedDeps.add(dagDep);
+      }
+    }
+    resolvedDeps.delete(nodeId);
+    const promiseVar = `p_${sanitizeId(nodeId)}`;
+    writer.write(`const ${promiseVar} = (async () => `).block(() => {
+      for (const depId of resolvedDeps) {
+        writer.writeLine(`await p_${sanitizeId(depId)};`);
+      }
+      writer.writeLine(`// --- ${node.label} (${node.nodeType}) [${node.id}] ---`);
+      generateNodeBody(writer, node, context);
+    });
+    writer.writeLine(`)();`);
+    writer.writeLine(`${promiseVar}.catch(() => {});`);
+    writer.blankLine();
+  }
+  if (dagNodeIds.length > 0) {
+    writer.writeLine("// --- Sync Barrier: await all DAG promises before output ---");
+    const allPromiseVars = dagNodeIds.map((id) => `p_${sanitizeId(id)}`);
+    writer.writeLine(`await Promise.allSettled([${allPromiseVars.join(", ")}]);`);
+    writer.blankLine();
+  }
+  for (const nodeId of outputNodeIds) {
+    const node = nodeMap.get(nodeId);
+    const rawDeps = [...plan.dependencies.get(nodeId) ?? []];
+    const resolvedDeps = /* @__PURE__ */ new Set();
+    for (const depId of rawDeps) {
+      for (const dagDep of resolveToDAGNodes(depId, triggerId, context)) {
+        resolvedDeps.add(dagDep);
+      }
+    }
+    for (const depId of resolvedDeps) {
+      writer.writeLine(`await p_${sanitizeId(depId)};`);
+    }
+    writer.writeLine(`// --- ${node.label} (${node.nodeType}) [${node.id}] ---`);
+    generateNodeBody(writer, node, context);
+  }
+}
+function generateConcurrentNodes(writer, nodeIds, context) {
+  const { nodeMap } = context;
+  const activeNodeIds = nodeIds.filter((id) => !context.childBlockNodeIds.has(id));
+  if (activeNodeIds.length === 0) return;
+  if (activeNodeIds.length === 1) {
+    const node = nodeMap.get(activeNodeIds[0]);
+    if (node) {
+      generateSingleNode(writer, node, context);
+      writer.blankLine();
+    }
+    return;
+  }
+  writer.writeLine("// --- Concurrent Execution ---");
+  const taskNames = [];
+  for (const nodeId of activeNodeIds) {
+    const node = nodeMap.get(nodeId);
+    if (!node) continue;
+    const taskName = `task_${sanitizeId(nodeId)}`;
+    taskNames.push(taskName);
+    writer.write(`const ${taskName} = async () => `).block(() => {
+      generateNodeBody(writer, node, context);
+    });
+    writer.writeLine(";");
+  }
+  writer.writeLine(
+    `const [${taskNames.map((_, i) => `r${i}`).join(", ")}] = await Promise.all([${taskNames.map((t) => `${t}()`).join(", ")}]);`
+  );
+  activeNodeIds.forEach((nodeId, i) => {
+    writer.writeLine(`flowState['${nodeId}'] = r${i};`);
+  });
+  activeNodeIds.forEach((nodeId) => {
+    const varName = context.symbolTable.getVarName(nodeId);
+    writer.writeLine(`const ${varName} = flowState['${nodeId}'];`);
+  });
+  writer.blankLine();
+}
+function generateSingleNode(writer, node, context) {
+  writer.writeLine(`// --- ${node.label} (${node.nodeType}) [${node.id}] ---`);
+  generateNodeBody(writer, node, context);
+  if (node.category !== "output" /* OUTPUT */) {
+    const varName = context.symbolTable.getVarName(node.id);
+    writer.writeLine(`const ${varName} = flowState['${node.id}'];`);
+  }
+}
+function generateNodeBody(writer, node, context) {
+  const plugin = context.pluginRegistry.get(node.nodeType);
+  if (plugin) {
+    const pluginCtx = createPluginContext(context);
+    plugin.generate(node, writer, pluginCtx);
+  } else {
+    throw new Error(
+      `[flow2code] Unsupported node type: "${node.nodeType}". Register a plugin via pluginRegistry.register() or use a built-in node type.`
+    );
+  }
+}
+function createPluginContext(context) {
+  return {
+    ir: context.ir,
+    nodeMap: context.nodeMap,
+    envVars: context.envVars,
+    imports: context.imports,
+    requiredPackages: context.requiredPackages,
+    getVarName(nodeId) {
+      return context.symbolTable.getVarName(nodeId);
+    },
+    resolveExpression(expr, currentNodeId) {
+      const exprContext = {
+        ir: context.ir,
+        nodeMap: context.nodeMap,
+        symbolTable: context.symbolTable,
+        scopeStack: context.scopeStack.length > 0 ? [...context.scopeStack] : void 0,
+        // Merge child block + DAG exclusion list
+        blockScopedNodeIds: context.symbolTableExclusions.size > 0 ? context.symbolTableExclusions : void 0,
+        currentNodeId
+      };
+      return parseExpression(expr, exprContext);
+    },
+    resolveEnvVars(url) {
+      return resolveEnvVars(url, context);
+    },
+    generateChildNode(writer, node) {
+      context.childBlockNodeIds.add(node.id);
+      context.symbolTableExclusions.add(node.id);
+      context.generatedBlockNodeIds.add(node.id);
+      writer.writeLine(`// --- ${node.label} (${node.nodeType}) [${node.id}] ---`);
+      generateNodeBody(writer, node, context);
+      generateBlockContinuation(writer, node.id, context);
+    },
+    pushScope(nodeId, scopeVar) {
+      context.scopeStack.push({ nodeId, scopeVar });
+    },
+    popScope() {
+      context.scopeStack.pop();
+    },
+    __platformResponse: context.platform.generateResponse.bind(context.platform)
+  };
+}
+function sanitizeId(id) {
+  return id.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+function resolveEnvVars(url, context) {
+  const hasEnvVar = /\$\{(\w+)\}/.test(url);
+  if (hasEnvVar) {
+    return "`" + url.replace(/\$\{(\w+)\}/g, (_match, varName) => {
+      context.envVars.add(varName);
+      return "${process.env." + varName + "}";
+    }) + "`";
+  }
+  if (url.includes("${")) {
+    return "`" + url + "`";
+  }
+  return `"${url}"`;
+}
+function collectRequiredPackages(ir, context) {
+  for (const node of ir.nodes) {
+    const plugin = context.pluginRegistry.get(node.nodeType);
+    if (plugin?.getRequiredPackages) {
+      const packages = plugin.getRequiredPackages(node);
+      packages.forEach((pkg) => context.requiredPackages.add(pkg));
+    }
+  }
+  const platformDeps = context.platform.getImplicitDependencies();
+  platformDeps.forEach((pkg) => context.requiredPackages.add(pkg));
+}
+function buildSourceMap(code, ir, filePath) {
+  const lines = code.split("\n");
+  const mappings = {};
+  const nodeMarkerRegex = /^[\s]*\/\/ --- .+? \(.+?\) \[(.+?)\] ---$/;
+  let currentNodeId = null;
+  let currentStartLine = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const lineNum = i + 1;
+    const match = lines[i].match(nodeMarkerRegex);
+    if (match) {
+      if (currentNodeId) {
+        mappings[currentNodeId] = {
+          startLine: currentStartLine,
+          endLine: lineNum - 1
+        };
+      }
+      const [, nodeId] = match;
+      if (ir.nodes.some((n) => n.id === nodeId)) {
+        currentNodeId = nodeId;
+        currentStartLine = lineNum;
+      } else {
+        currentNodeId = null;
+      }
+    }
+  }
+  if (currentNodeId) {
+    mappings[currentNodeId] = {
+      startLine: currentStartLine,
+      endLine: lines.length
+    };
+  }
+  const trigger = ir.nodes.find((n) => n.category === "trigger" /* TRIGGER */);
+  if (trigger && !mappings[trigger.id]) {
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].includes("export async function") || lines[i].includes("@schedule")) {
+        mappings[trigger.id] = { startLine: i + 1, endLine: lines.length };
+        break;
+      }
+    }
+  }
+  return {
+    version: 1,
+    generatedFile: filePath,
+    mappings
+  };
+}
+function traceLineToNode(sourceMap, line) {
+  for (const [nodeId, range] of Object.entries(sourceMap.mappings)) {
+    if (line >= range.startLine && line <= range.endLine) {
+      return { nodeId, ...range };
+    }
+  }
+  return null;
+}
+
+// src/lib/ir/security.ts
+var SECURITY_PATTERNS = [
+  // ── Critical: Remote Code Execution / System Access ──
+  { pattern: /\beval\s*\(/, desc: "eval() \u2014 dynamically executes arbitrary code", severity: "critical" },
+  { pattern: /\bnew\s+Function\s*\(/, desc: "new Function() \u2014 dynamically constructs a function", severity: "critical" },
+  { pattern: /\bchild_process\b/, desc: "child_process \u2014 can execute arbitrary system commands", severity: "critical" },
+  { pattern: /\bexec\s*\(/, desc: "exec() \u2014 executes shell commands", severity: "critical" },
+  { pattern: /\bexecSync\s*\(/, desc: "execSync() \u2014 synchronously executes shell commands", severity: "critical" },
+  { pattern: /\bspawn\s*\(/, desc: "spawn() \u2014 spawns a child process", severity: "critical" },
+  { pattern: /\bprocess\.exit\b/, desc: "process.exit() \u2014 terminates the Node.js process", severity: "critical" },
+  { pattern: /\bprocess\.env\b/, desc: "process.env \u2014 accesses environment variables (may leak secrets)", severity: "critical" },
+  { pattern: /\bprocess\.kill\b/, desc: "process.kill() \u2014 kills a process", severity: "critical" },
+  { pattern: /\brequire\s*\(\s*['"`]child_process/, desc: "require('child_process')", severity: "critical" },
+  { pattern: /\brequire\s*\(\s*['"`]vm['"`]/, desc: "require('vm') \u2014 V8 virtual machine", severity: "critical" },
+  // ── Critical: File System Destructive ──
+  { pattern: /\bfs\.\w*(unlink|rmdir|rm|rmSync|unlinkSync)\b/, desc: "fs delete operation", severity: "critical" },
+  { pattern: /\bfs\.\w*(writeFile|writeFileSync|appendFile)\b/, desc: "fs write operation", severity: "critical" },
+  { pattern: /\brequire\s*\(\s*['"`]fs['"`]\)/, desc: "require('fs') \u2014 file system access", severity: "critical" },
+  // ── Warning: Network / Dynamic Import ──
+  { pattern: /\bimport\s*\(/, desc: "dynamic import() \u2014 can load arbitrary modules", severity: "warning" },
+  { pattern: /\brequire\s*\(\s*['"`]https?['"`]/, desc: "require('http/https') \u2014 network module", severity: "warning" },
+  { pattern: /\brequire\s*\(\s*['"`]net['"`]/, desc: "require('net') \u2014 low-level network access", severity: "warning" },
+  { pattern: /\bglobalThis\b/, desc: "globalThis \u2014 accesses the global scope", severity: "warning" },
+  { pattern: /\b__proto__\b/, desc: "__proto__ \u2014 prototype pollution risk", severity: "warning" },
+  { pattern: /\bconstructor\s*\[\s*['"`]/, desc: "constructor[] \u2014 prototype pollution risk", severity: "warning" },
+  // ── Warning: FS Read (non-destructive but sensitive) ──
+  { pattern: /\brequire\s*\(\s*['"`]fs['"`]\s*\)\.read/, desc: "fs read operation", severity: "warning" },
+  { pattern: /\bfs\.\w*(readFile|readFileSync|readdir)\b/, desc: "fs read operation", severity: "warning" },
+  // ── Info: Uncommon patterns ──
+  { pattern: /\bsetTimeout\s*\(\s*[^,]+,\s*\d{5,}/, desc: "long setTimeout (>10s) \u2014 possibly a malicious delay", severity: "info" },
+  { pattern: /\bwhile\s*\(\s*true\s*\)/, desc: "while(true) \u2014 possible infinite loop", severity: "info" },
+  { pattern: /\bfor\s*\(\s*;\s*;\s*\)/, desc: "for(;;) \u2014 possible infinite loop", severity: "info" }
+];
+function truncate(str, maxLen) {
+  return str.length > maxLen ? str.slice(0, maxLen) + "\u2026" : str;
+}
+function scanCode(nodeId, nodeLabel, code) {
+  const findings = [];
+  for (const { pattern, desc, severity } of SECURITY_PATTERNS) {
+    const globalPattern = new RegExp(pattern.source, "g");
+    let match;
+    while ((match = globalPattern.exec(code)) !== null) {
+      findings.push({
+        severity,
+        nodeId,
+        nodeLabel,
+        pattern: desc,
+        match: truncate(match[0], 80)
+      });
+    }
+  }
+  return findings;
+}
+function extractCodeFields(node) {
+  const codes = [];
+  const params = node.params;
+  if (!params) return codes;
+  if (node.nodeType === "custom_code" /* CUSTOM_CODE */ && typeof params.code === "string") {
+    codes.push(params.code);
+  }
+  if (typeof params.expression === "string") {
+    codes.push(params.expression);
+  }
+  if (typeof params.inputMapping === "string") {
+    codes.push(params.inputMapping);
+  } else if (typeof params.inputMapping === "object" && params.inputMapping !== null) {
+    codes.push(JSON.stringify(params.inputMapping));
+  }
+  if (typeof params.body === "string") {
+    codes.push(params.body);
+  }
+  if (typeof params.query === "string") {
+    codes.push(params.query);
+  }
+  if (typeof params.bodyExpression === "string") {
+    codes.push(params.bodyExpression);
+  }
+  if (typeof params.condition === "string") {
+    codes.push(params.condition);
+  }
+  return codes;
+}
+function validateIRSecurity(ir) {
+  const findings = [];
+  let nodesScanned = 0;
+  for (const node of ir.nodes) {
+    const codeFields = extractCodeFields(node);
+    if (codeFields.length === 0) continue;
+    nodesScanned++;
+    for (const code of codeFields) {
+      const nodeFindings = scanCode(node.id, node.label ?? node.id, code);
+      findings.push(...nodeFindings);
+    }
+  }
+  const hasCritical = findings.some((f) => f.severity === "critical");
+  return {
+    safe: !hasCritical,
+    findings,
+    nodesScanned
+  };
+}
+function formatSecurityReport(result) {
+  if (result.findings.length === 0) {
+    return `\u2705 Security check passed (scanned ${result.nodesScanned} nodes, no dangerous patterns detected)`;
+  }
+  const lines = [];
+  const critical = result.findings.filter((f) => f.severity === "critical");
+  const warnings = result.findings.filter((f) => f.severity === "warning");
+  const infos = result.findings.filter((f) => f.severity === "info");
+  lines.push(`\u26A0\uFE0F Security check results (scanned ${result.nodesScanned} nodes)`);
+  lines.push("");
+  if (critical.length > 0) {
+    lines.push(`\u{1F534} Critical (${critical.length}):`);
+    for (const f of critical) {
+      lines.push(`  [${f.nodeId}] ${f.pattern} \u2014 match: "${f.match}"`);
+    }
+  }
+  if (warnings.length > 0) {
+    lines.push(`\u{1F7E1} Warning (${warnings.length}):`);
+    for (const f of warnings) {
+      lines.push(`  [${f.nodeId}] ${f.pattern} \u2014 match: "${f.match}"`);
+    }
+  }
+  if (infos.length > 0) {
+    lines.push(`\u{1F535} Info (${infos.length}):`);
+    for (const f of infos) {
+      lines.push(`  [${f.nodeId}] ${f.pattern} \u2014 match: "${f.match}"`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/lib/compiler/decompiler.ts
+var import_ts_morph2 = require("ts-morph");
+function decompile(code, options = {}) {
+  const errors = [];
+  const { fileName = "input.ts", audit: enableAudit = true } = options;
+  try {
+    const project = new import_ts_morph2.Project({ useInMemoryFileSystem: true });
+    const sourceFile = project.createSourceFile(fileName, code);
+    const targetFn = findTargetFunction(sourceFile, options.functionName);
+    if (!targetFn) {
+      errors.push("No exported function found to decompile");
+      return { success: false, errors, confidence: 0 };
+    }
+    const ctx = createDecompileContext();
+    const trigger = createTriggerFromFunction(targetFn, sourceFile, ctx);
+    ctx.addNode(trigger);
+    const body = targetFn.fn.getBody();
+    if (body && body.getKind() === import_ts_morph2.SyntaxKind.Block) {
+      walkBlock(body, trigger.id, ctx);
+    }
+    buildEdges(ctx);
+    const auditHints = enableAudit ? computeAuditHints(ctx) : [];
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const ir = {
+      version: CURRENT_IR_VERSION,
+      meta: {
+        name: targetFn.name ?? fileName.replace(/\.(ts|tsx|js|jsx)$/, ""),
+        description: `Decompiled from ${fileName}`,
+        createdAt: now,
+        updatedAt: now
+      },
+      nodes: ctx.getNodes(),
+      edges: ctx.getEdges()
+    };
+    const nodeCount = ir.nodes.length;
+    const hasControlFlow = ir.nodes.some((n) => n.category === "logic" /* LOGIC */);
+    const confidence = Math.min(
+      0.95,
+      0.3 + nodeCount * 0.08 + (hasControlFlow ? 0.15 : 0)
+    );
+    return {
+      success: true,
+      ir,
+      errors: errors.length > 0 ? errors : void 0,
+      confidence,
+      audit: auditHints.length > 0 ? auditHints : void 0
+    };
+  } catch (err) {
+    return {
+      success: false,
+      errors: [err instanceof Error ? err.message : String(err)],
+      confidence: 0
+    };
+  }
+}
+function createDecompileContext() {
+  const ctx = {
+    nodes: /* @__PURE__ */ new Map(),
+    edgeList: [],
+    varDefs: /* @__PURE__ */ new Map(),
+    varUses: /* @__PURE__ */ new Map(),
+    seqPredecessors: /* @__PURE__ */ new Map(),
+    controlFlowChildren: /* @__PURE__ */ new Map(),
+    auditData: [],
+    counters: {},
+    nodeLines: /* @__PURE__ */ new Map(),
+    addNode(node, line) {
+      ctx.nodes.set(node.id, node);
+      if (line !== void 0) ctx.nodeLines.set(node.id, line);
+    },
+    getNodes() {
+      return Array.from(ctx.nodes.values());
+    },
+    getEdges() {
+      return ctx.edgeList;
+    },
+    nextId(prefix) {
+      ctx.counters[prefix] = (ctx.counters[prefix] ?? 0) + 1;
+      return `${prefix}_${ctx.counters[prefix]}`;
+    }
+  };
+  return ctx;
+}
+function findTargetFunction(sourceFile, targetName) {
+  const httpMethods = ["GET", "POST", "PUT", "PATCH", "DELETE"];
+  if (targetName) {
+    const fn = sourceFile.getFunction(targetName);
+    if (fn) {
+      const name = fn.getName();
+      const httpMethod = name && httpMethods.includes(name.toUpperCase()) ? name.toUpperCase() : void 0;
+      return { name: targetName, fn, httpMethod, isExported: fn.isExported() };
+    }
+  }
+  for (const fn of sourceFile.getFunctions()) {
+    if (!fn.isExported()) continue;
+    const name = fn.getName();
+    if (name && httpMethods.includes(name.toUpperCase())) {
+      return { name, fn, httpMethod: name.toUpperCase(), isExported: true };
+    }
+  }
+  for (const fn of sourceFile.getFunctions()) {
+    if (fn.isExported()) {
+      return { name: fn.getName(), fn, isExported: true };
+    }
+  }
+  const allFns = sourceFile.getFunctions();
+  if (allFns.length > 0) {
+    const fn = allFns[0];
+    return { name: fn.getName(), fn, isExported: fn.isExported() };
+  }
+  for (const stmt of sourceFile.getVariableStatements()) {
+    if (!stmt.isExported()) continue;
+    for (const decl of stmt.getDeclarations()) {
+      const init = decl.getInitializer();
+      if (init && init.getKind() === import_ts_morph2.SyntaxKind.ArrowFunction) {
+        return {
+          name: decl.getName(),
+          fn: init,
+          isExported: true
+        };
+      }
+    }
+  }
+  return null;
+}
+function createTriggerFromFunction(target, sourceFile, ctx) {
+  const id = ctx.nextId("trigger");
+  if (target.httpMethod) {
+    const routePath = inferRoutePath(sourceFile);
+    const method = target.httpMethod;
+    const parseBody = method !== "GET";
+    return {
+      id,
+      nodeType: "http_webhook" /* HTTP_WEBHOOK */,
+      category: "trigger" /* TRIGGER */,
+      label: `${method} ${routePath}`,
+      params: { method, routePath, parseBody },
+      inputs: [],
+      outputs: [
+        { id: "request", label: "Request", dataType: "object" },
+        { id: "body", label: "Body", dataType: "object" },
+        { id: "query", label: "Query", dataType: "object" }
+      ]
+    };
+  }
+  return {
+    id,
+    nodeType: "manual" /* MANUAL */,
+    category: "trigger" /* TRIGGER */,
+    label: target.name ?? "Entry Point",
+    params: {
+      functionName: target.name ?? "handler",
+      args: target.fn.getParameters?.() ? target.fn.getParameters().map((p) => ({
+        name: p.getName(),
+        type: inferDataType(p.getType().getText())
+      })) : []
+    },
+    inputs: [],
+    outputs: [{ id: "output", label: "Output", dataType: "any" }]
+  };
+}
+function walkBlock(block, parentNodeId, ctx, controlFlowPort) {
+  const statements = block.getStatements();
+  let lastNodeId = parentNodeId;
+  for (const stmt of statements) {
+    const nodeId = processStatement(stmt, lastNodeId, ctx);
+    if (nodeId) {
+      if (lastNodeId !== parentNodeId || !controlFlowPort) {
+        ctx.seqPredecessors.set(nodeId, lastNodeId);
+      }
+      if (lastNodeId === parentNodeId && controlFlowPort) {
+        if (!ctx.controlFlowChildren.has(parentNodeId)) {
+          ctx.controlFlowChildren.set(parentNodeId, []);
+        }
+        ctx.controlFlowChildren.get(parentNodeId).push({
+          portId: controlFlowPort,
+          nodeId
+        });
+      }
+      lastNodeId = nodeId;
+    }
+  }
+}
+function processStatement(stmt, prevNodeId, ctx) {
+  const kind = stmt.getKind();
+  const line = stmt.getStartLineNumber();
+  switch (kind) {
+    case import_ts_morph2.SyntaxKind.VariableStatement:
+      return processVariableStatement(stmt, prevNodeId, ctx, line);
+    case import_ts_morph2.SyntaxKind.IfStatement:
+      return processIfStatement(stmt, prevNodeId, ctx, line);
+    case import_ts_morph2.SyntaxKind.ForOfStatement:
+      return processForOfStatement(stmt, prevNodeId, ctx, line);
+    case import_ts_morph2.SyntaxKind.ForInStatement:
+      return processForInStatement(stmt, prevNodeId, ctx, line);
+    case import_ts_morph2.SyntaxKind.ForStatement:
+      return processForStatement(stmt, prevNodeId, ctx, line);
+    case import_ts_morph2.SyntaxKind.TryStatement:
+      return processTryStatement(stmt, prevNodeId, ctx, line);
+    case import_ts_morph2.SyntaxKind.ReturnStatement:
+      return processReturnStatement(stmt, prevNodeId, ctx, line);
+    case import_ts_morph2.SyntaxKind.ExpressionStatement:
+      return processExpressionStatement(stmt, prevNodeId, ctx, line);
+    default:
+      return null;
+  }
+}
+function processVariableStatement(stmt, _prevNodeId, ctx, line) {
+  const declarations = stmt.getDeclarations();
+  if (declarations.length === 0) return null;
+  const decl = declarations[0];
+  return processVariableDeclaration(decl, ctx, line);
+}
+function processVariableDeclaration(decl, ctx, line) {
+  const varName = decl.getName();
+  const init = decl.getInitializer();
+  if (!init) return null;
+  const initText = init.getText();
+  if (isFetchCall(init)) {
+    const nodeId2 = ctx.nextId("fetch");
+    const node = parseFetchNode(nodeId2, initText, varName);
+    ctx.addNode(node, line);
+    ctx.varDefs.set(varName, { nodeId: nodeId2, portId: "data", varName });
+    return nodeId2;
+  }
+  if (hasAwaitExpression(init)) {
+    const nodeId2 = ctx.nextId("async_op");
+    const awaitedCode = extractAwaitedExpression(init);
+    ctx.addNode({
+      id: nodeId2,
+      nodeType: "custom_code" /* CUSTOM_CODE */,
+      category: "action" /* ACTION */,
+      label: inferLabel(awaitedCode, varName),
+      params: { code: awaitedCode, returnVariable: varName },
+      inputs: [{ id: "input", label: "Input", dataType: "any", required: false }],
+      outputs: [{ id: "result", label: "Result", dataType: "any" }]
+    }, line);
+    ctx.varDefs.set(varName, { nodeId: nodeId2, portId: "result", varName });
+    trackVariableUses(nodeId2, initText, ctx);
+    return nodeId2;
+  }
+  if (isSimpleDeclaration(init)) {
+    const nodeId2 = ctx.nextId("var");
+    const dataType = inferDataType(decl.getType().getText());
+    const isConst = decl.getVariableStatement()?.getDeclarationKind()?.toString() === "const";
+    ctx.addNode({
+      id: nodeId2,
+      nodeType: "declare" /* DECLARE */,
+      category: "variable" /* VARIABLE */,
+      label: varName,
+      params: {
+        name: varName,
+        dataType,
+        initialValue: initText,
+        isConst: isConst ?? true
+      },
+      inputs: [],
+      outputs: [{ id: "value", label: "Value", dataType }]
+    }, line);
+    ctx.varDefs.set(varName, { nodeId: nodeId2, portId: "value", varName });
+    trackVariableUses(nodeId2, initText, ctx);
+    return nodeId2;
+  }
+  const nodeId = ctx.nextId("transform");
+  ctx.addNode({
+    id: nodeId,
+    nodeType: "transform" /* TRANSFORM */,
+    category: "variable" /* VARIABLE */,
+    label: varName,
+    params: { expression: initText },
+    inputs: [{ id: "input", label: "Input", dataType: "any", required: true }],
+    outputs: [{ id: "output", label: "Output", dataType: "any" }]
+  }, line);
+  ctx.varDefs.set(varName, { nodeId, portId: "output", varName });
+  trackVariableUses(nodeId, initText, ctx);
+  return nodeId;
+}
+function processIfStatement(stmt, _prevNodeId, ctx, line) {
+  const nodeId = ctx.nextId("if");
+  const condition = stmt.getExpression().getText();
+  ctx.addNode({
+    id: nodeId,
+    nodeType: "if_else" /* IF_ELSE */,
+    category: "logic" /* LOGIC */,
+    label: `if (${truncate2(condition, 40)})`,
+    params: { condition },
+    inputs: [{ id: "input", label: "Input", dataType: "any", required: true }],
+    outputs: [
+      { id: "true", label: "True", dataType: "any" },
+      { id: "false", label: "False", dataType: "any" }
+    ]
+  }, line);
+  trackVariableUses(nodeId, condition, ctx);
+  const thenBlock = stmt.getThenStatement();
+  if (thenBlock.getKind() === import_ts_morph2.SyntaxKind.Block) {
+    walkBlock(thenBlock, nodeId, ctx, "true");
+  }
+  const elseStmt = stmt.getElseStatement();
+  if (elseStmt) {
+    if (elseStmt.getKind() === import_ts_morph2.SyntaxKind.Block) {
+      walkBlock(elseStmt, nodeId, ctx, "false");
+    } else if (elseStmt.getKind() === import_ts_morph2.SyntaxKind.IfStatement) {
+      const nestedId = processIfStatement(elseStmt, nodeId, ctx, elseStmt.getStartLineNumber());
+      if (!ctx.controlFlowChildren.has(nodeId)) {
+        ctx.controlFlowChildren.set(nodeId, []);
+      }
+      ctx.controlFlowChildren.get(nodeId).push({ portId: "false", nodeId: nestedId });
+    }
+  }
+  if (!elseStmt) {
+    ctx.auditData.push({
+      nodeId,
+      severity: "info",
+      message: "If statement has no else branch \u2014 consider handling the negative case",
+      line
+    });
+  }
+  return nodeId;
+}
+function processForOfStatement(stmt, _prevNodeId, ctx, line) {
+  const nodeId = ctx.nextId("loop");
+  const initText = stmt.getInitializer().getText();
+  const itemVar = initText.replace(/^(const|let|var)\s+/, "");
+  const iterableExpr = stmt.getExpression().getText();
+  ctx.addNode({
+    id: nodeId,
+    nodeType: "for_loop" /* FOR_LOOP */,
+    category: "logic" /* LOGIC */,
+    label: `for (${itemVar} of ${truncate2(iterableExpr, 30)})`,
+    params: {
+      iterableExpression: iterableExpr,
+      itemVariable: itemVar
+    },
+    inputs: [{ id: "iterable", label: "Iterable", dataType: "array", required: true }],
+    outputs: [
+      { id: "item", label: "Item", dataType: "any" },
+      { id: "result", label: "Result", dataType: "array" }
+    ]
+  }, line);
+  trackVariableUses(nodeId, iterableExpr, ctx);
+  const body = stmt.getStatement();
+  if (body.getKind() === import_ts_morph2.SyntaxKind.Block) {
+    walkBlock(body, nodeId, ctx, "item");
+  }
+  return nodeId;
+}
+function processForInStatement(stmt, _prevNodeId, ctx, line) {
+  const nodeId = ctx.nextId("loop");
+  const initText = stmt.getInitializer().getText();
+  const itemVar = initText.replace(/^(const|let|var)\s+/, "");
+  const iterableExpr = stmt.getExpression().getText();
+  ctx.addNode({
+    id: nodeId,
+    nodeType: "for_loop" /* FOR_LOOP */,
+    category: "logic" /* LOGIC */,
+    label: `for (${itemVar} in ${truncate2(iterableExpr, 30)})`,
+    params: {
+      iterableExpression: `Object.keys(${iterableExpr})`,
+      itemVariable: itemVar
+    },
+    inputs: [{ id: "iterable", label: "Iterable", dataType: "array", required: true }],
+    outputs: [
+      { id: "item", label: "Item", dataType: "any" },
+      { id: "result", label: "Result", dataType: "array" }
+    ]
+  }, line);
+  trackVariableUses(nodeId, iterableExpr, ctx);
+  const body = stmt.getStatement();
+  if (body.getKind() === import_ts_morph2.SyntaxKind.Block) {
+    walkBlock(body, nodeId, ctx, "item");
+  }
+  return nodeId;
+}
+function processForStatement(stmt, _prevNodeId, ctx, line) {
+  const nodeId = ctx.nextId("loop");
+  const fullText = stmt.getText().split("{")[0].trim();
+  ctx.addNode({
+    id: nodeId,
+    nodeType: "for_loop" /* FOR_LOOP */,
+    category: "logic" /* LOGIC */,
+    label: truncate2(fullText, 50),
+    params: {
+      iterableExpression: fullText,
+      itemVariable: "i"
+    },
+    inputs: [{ id: "iterable", label: "Iterable", dataType: "array", required: true }],
+    outputs: [
+      { id: "item", label: "Item", dataType: "any" },
+      { id: "result", label: "Result", dataType: "array" }
+    ]
+  }, line);
+  const body = stmt.getStatement();
+  if (body.getKind() === import_ts_morph2.SyntaxKind.Block) {
+    walkBlock(body, nodeId, ctx, "item");
+  }
+  return nodeId;
+}
+function processTryStatement(stmt, _prevNodeId, ctx, line) {
+  const nodeId = ctx.nextId("trycatch");
+  const catchClause = stmt.getCatchClause();
+  const errorVar = catchClause?.getVariableDeclaration()?.getName() ?? "error";
+  ctx.addNode({
+    id: nodeId,
+    nodeType: "try_catch" /* TRY_CATCH */,
+    category: "logic" /* LOGIC */,
+    label: "Try / Catch",
+    params: { errorVariable: errorVar },
+    inputs: [{ id: "input", label: "Input", dataType: "any", required: true }],
+    outputs: [
+      { id: "success", label: "Success", dataType: "any" },
+      { id: "error", label: "Error", dataType: "object" }
+    ]
+  }, line);
+  const tryBlock = stmt.getTryBlock();
+  walkBlock(tryBlock, nodeId, ctx, "success");
+  if (catchClause) {
+    const catchBlock = catchClause.getBlock();
+    walkBlock(catchBlock, nodeId, ctx, "error");
+  }
+  return nodeId;
+}
+function processReturnStatement(stmt, _prevNodeId, ctx, line) {
+  const nodeId = ctx.nextId("response");
+  const returnExpr = stmt.getExpression();
+  const returnText = returnExpr?.getText() ?? "";
+  const isHttpResponse = returnText.includes("NextResponse") || returnText.includes("Response(") || returnText.includes(".json(") || returnText.includes("res.status") || returnText.includes("res.json");
+  if (isHttpResponse) {
+    const statusMatch = returnText.match(/status[:\s(]+(\d{3})/);
+    const bodyMatch = returnText.match(/\.json\((.+?)(?:,|\))/s);
+    ctx.addNode({
+      id: nodeId,
+      nodeType: "return_response" /* RETURN_RESPONSE */,
+      category: "output" /* OUTPUT */,
+      label: `Response ${statusMatch?.[1] ?? "200"}`,
+      params: {
+        statusCode: statusMatch ? parseInt(statusMatch[1]) : 200,
+        bodyExpression: bodyMatch?.[1]?.trim() ?? returnText
+      },
+      inputs: [{ id: "data", label: "Data", dataType: "any", required: true }],
+      outputs: []
+    }, line);
+  } else {
+    ctx.addNode({
+      id: nodeId,
+      nodeType: "return_response" /* RETURN_RESPONSE */,
+      category: "output" /* OUTPUT */,
+      label: "Return",
+      params: {
+        statusCode: 200,
+        bodyExpression: returnText || "undefined"
+      },
+      inputs: [{ id: "data", label: "Data", dataType: "any", required: true }],
+      outputs: []
+    }, line);
+  }
+  trackVariableUses(nodeId, returnText, ctx);
+  return nodeId;
+}
+function processExpressionStatement(stmt, _prevNodeId, ctx, line) {
+  const expr = stmt.getExpression();
+  const exprText = expr.getText();
+  if (isFetchCall(expr)) {
+    const nodeId = ctx.nextId("fetch");
+    const node = parseFetchNode(nodeId, exprText, void 0);
+    ctx.addNode(node, line);
+    return nodeId;
+  }
+  if (hasAwaitExpression(expr)) {
+    const nodeId = ctx.nextId("async_op");
+    const awaitedCode = extractAwaitedExpression(expr);
+    ctx.addNode({
+      id: nodeId,
+      nodeType: "custom_code" /* CUSTOM_CODE */,
+      category: "action" /* ACTION */,
+      label: inferLabel(awaitedCode, void 0),
+      params: { code: awaitedCode },
+      inputs: [{ id: "input", label: "Input", dataType: "any", required: false }],
+      outputs: [{ id: "result", label: "Result", dataType: "any" }]
+    }, line);
+    trackVariableUses(nodeId, exprText, ctx);
+    return nodeId;
+  }
+  const flowStateMatch = exprText.match(/flowState\['([^']+)'\]\s*=\s*(.+)/s);
+  if (flowStateMatch) {
+    return null;
+  }
+  if (exprText.includes("res.status") || exprText.includes("res.json")) {
+    const nodeId = ctx.nextId("response");
+    const statusMatch = exprText.match(/status\((\d+)\)/);
+    ctx.addNode({
+      id: nodeId,
+      nodeType: "return_response" /* RETURN_RESPONSE */,
+      category: "output" /* OUTPUT */,
+      label: `Response ${statusMatch?.[1] ?? "200"}`,
+      params: {
+        statusCode: statusMatch ? parseInt(statusMatch[1]) : 200,
+        bodyExpression: exprText
+      },
+      inputs: [{ id: "data", label: "Data", dataType: "any", required: true }],
+      outputs: []
+    }, line);
+    trackVariableUses(nodeId, exprText, ctx);
+    return nodeId;
+  }
+  return null;
+}
+function buildEdges(ctx) {
+  let edgeCounter = 0;
+  const addEdge = (source, sourcePort, target, targetPort) => {
+    const exists = ctx.edgeList.some(
+      (e) => e.sourceNodeId === source && e.targetNodeId === target && e.sourcePortId === sourcePort
+    );
+    if (exists) return;
+    ctx.edgeList.push({
+      id: `e${++edgeCounter}`,
+      sourceNodeId: source,
+      sourcePortId: sourcePort,
+      targetNodeId: target,
+      targetPortId: targetPort
+    });
+  };
+  const connectedTargets = /* @__PURE__ */ new Set();
+  for (const [nodeId, uses] of ctx.varUses) {
+    for (const use of uses) {
+      const def = ctx.varDefs.get(use.varName);
+      if (def && def.nodeId !== nodeId) {
+        addEdge(def.nodeId, def.portId, nodeId, use.portId);
+        connectedTargets.add(nodeId);
+      }
+    }
+  }
+  for (const [parentId, children] of ctx.controlFlowChildren) {
+    for (const child of children) {
+      addEdge(parentId, child.portId, child.nodeId, "input");
+      connectedTargets.add(child.nodeId);
+    }
+  }
+  for (const [nodeId, predId] of ctx.seqPredecessors) {
+    if (connectedTargets.has(nodeId)) continue;
+    const predNode = ctx.nodes.get(predId);
+    if (!predNode) continue;
+    const sourcePort = predNode.outputs[0]?.id ?? "output";
+    addEdge(predId, sourcePort, nodeId, "input");
+  }
+}
+function computeAuditHints(ctx) {
+  const hints = [...ctx.auditData];
+  for (const [nodeId, node] of ctx.nodes) {
+    const line = ctx.nodeLines.get(nodeId);
+    if (node.nodeType === "custom_code" /* CUSTOM_CODE */ || node.nodeType === "fetch_api" /* FETCH_API */) {
+      const isInsideTryCatch = Array.from(ctx.controlFlowChildren.entries()).some(
+        ([parentId, children]) => {
+          const parent = ctx.nodes.get(parentId);
+          return parent?.nodeType === "try_catch" /* TRY_CATCH */ && children.some((c) => c.nodeId === nodeId);
+        }
+      );
+      let ancestorId = ctx.seqPredecessors.get(nodeId);
+      let foundTryCatch = isInsideTryCatch;
+      while (ancestorId && !foundTryCatch) {
+        const ancestor = ctx.nodes.get(ancestorId);
+        if (ancestor?.nodeType === "try_catch" /* TRY_CATCH */) foundTryCatch = true;
+        for (const [parentId, children] of ctx.controlFlowChildren) {
+          const parent = ctx.nodes.get(parentId);
+          if (parent?.nodeType === "try_catch" /* TRY_CATCH */ && children.some((c) => c.nodeId === nodeId)) {
+            foundTryCatch = true;
+          }
+        }
+        ancestorId = ctx.seqPredecessors.get(ancestorId);
+      }
+      if (!foundTryCatch) {
+        hints.push({
+          nodeId,
+          severity: "warning",
+          message: `Async operation "${node.label}" has no error handling (missing try/catch)`,
+          line
+        });
+      }
+    }
+    if (node.nodeType === "fetch_api" /* FETCH_API */) {
+      hints.push({
+        nodeId,
+        severity: "info",
+        message: "Consider checking response.ok or response.status after fetch",
+        line
+      });
+    }
+  }
+  return hints;
+}
+function isFetchCall(node) {
+  const text = node.getText();
+  return text.includes("fetch(") && (text.includes("await") || node.getKind() === import_ts_morph2.SyntaxKind.AwaitExpression);
+}
+function hasAwaitExpression(node) {
+  if (node.getKind() === import_ts_morph2.SyntaxKind.AwaitExpression) return true;
+  return node.getText().startsWith("await ");
+}
+function extractAwaitedExpression(node) {
+  const text = node.getText();
+  if (text.startsWith("await ")) return text.slice(6);
+  return text;
+}
+function isSimpleDeclaration(node) {
+  const text = node.getText();
+  return !text.includes("await") && !text.includes("fetch(") && (node.getKind() === import_ts_morph2.SyntaxKind.StringLiteral || node.getKind() === import_ts_morph2.SyntaxKind.NumericLiteral || node.getKind() === import_ts_morph2.SyntaxKind.TrueKeyword || node.getKind() === import_ts_morph2.SyntaxKind.FalseKeyword || node.getKind() === import_ts_morph2.SyntaxKind.NullKeyword || node.getKind() === import_ts_morph2.SyntaxKind.ArrayLiteralExpression || node.getKind() === import_ts_morph2.SyntaxKind.ObjectLiteralExpression || node.getKind() === import_ts_morph2.SyntaxKind.NewExpression);
+}
+function parseFetchNode(nodeId, text, varName) {
+  const urlMatch = text.match(/fetch\(([^,)]+)/);
+  let url = urlMatch?.[1]?.trim() ?? '""';
+  url = url.replace(/^[`"']|[`"']$/g, "");
+  const methodMatch = text.match(/method:\s*["'](\w+)["']/);
+  const method = methodMatch?.[1]?.toUpperCase() ?? "GET";
+  const headerMatch = text.match(/headers:\s*(\{[^}]+\})/);
+  let headers;
+  if (headerMatch) {
+    headers = {};
+    const headerPairs = headerMatch[1].matchAll(/"([^"]+)":\s*"([^"]+)"/g);
+    for (const pair of headerPairs) {
+      headers[pair[1]] = pair[2];
+    }
+  }
+  return {
+    id: nodeId,
+    nodeType: "fetch_api" /* FETCH_API */,
+    category: "action" /* ACTION */,
+    label: `Fetch ${truncate2(url, 30) || varName || "API"}`,
+    params: {
+      url,
+      method,
+      headers,
+      parseJson: text.includes(".json()")
+    },
+    inputs: [{ id: "input", label: "Input", dataType: "any", required: false }],
+    outputs: [
+      { id: "response", label: "Response", dataType: "object" },
+      { id: "data", label: "Data", dataType: "any" }
+    ]
+  };
+}
+function inferRoutePath(sourceFile) {
+  const filePath = sourceFile.getFilePath();
+  const appRouterMatch = filePath.match(/\/app\/api\/(.+?)\/route\.(ts|js)/);
+  if (appRouterMatch) return `/api/${appRouterMatch[1]}`;
+  const pagesMatch = filePath.match(/\/pages\/api\/(.+?)\.(ts|js)/);
+  if (pagesMatch) return `/api/${pagesMatch[1]}`;
+  const fullText = sourceFile.getFullText();
+  const routeMatch = fullText.match(/\/api\/\S+/);
+  if (routeMatch) return routeMatch[0];
+  return "/api/handler";
+}
+function inferDataType(tsType) {
+  if (tsType.includes("string")) return "string";
+  if (tsType.includes("number")) return "number";
+  if (tsType.includes("boolean")) return "boolean";
+  if (tsType.includes("[]") || tsType.includes("Array")) return "array";
+  if (tsType.includes("{") || tsType.includes("Record") || tsType.includes("object")) return "object";
+  return "any";
+}
+function inferLabel(code, varName) {
+  const callMatch = code.match(/^(\w+(?:\.\w+)*)\(/);
+  if (callMatch) return callMatch[1];
+  if (varName) return varName;
+  return truncate2(code, 30);
+}
+function trackVariableUses(nodeId, expression, ctx) {
+  const identifiers = expression.match(/\b([a-zA-Z_]\w*)\b/g);
+  if (!identifiers) return;
+  const uses = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const ident of identifiers) {
+    if (SKIP_IDENTIFIERS.has(ident)) continue;
+    if (seen.has(ident)) continue;
+    seen.add(ident);
+    if (ctx.varDefs.has(ident)) {
+      uses.push({ nodeId, portId: "input", varName: ident });
+    }
+  }
+  if (uses.length > 0) {
+    const existing = ctx.varUses.get(nodeId) ?? [];
+    ctx.varUses.set(nodeId, [...existing, ...uses]);
+  }
+}
+var SKIP_IDENTIFIERS = /* @__PURE__ */ new Set([
+  // JS keywords
+  "const",
+  "let",
+  "var",
+  "function",
+  "return",
+  "if",
+  "else",
+  "for",
+  "while",
+  "do",
+  "switch",
+  "case",
+  "break",
+  "continue",
+  "throw",
+  "try",
+  "catch",
+  "finally",
+  "new",
+  "delete",
+  "typeof",
+  "void",
+  "in",
+  "of",
+  "instanceof",
+  "this",
+  "super",
+  "class",
+  "extends",
+  "import",
+  "export",
+  "default",
+  "from",
+  "as",
+  "async",
+  "await",
+  "yield",
+  "true",
+  "false",
+  "null",
+  "undefined",
+  // Common globals
+  "console",
+  "JSON",
+  "Math",
+  "Date",
+  "Error",
+  "Promise",
+  "Array",
+  "Object",
+  "String",
+  "Number",
+  "Boolean",
+  "Map",
+  "Set",
+  "RegExp",
+  "Symbol",
+  "Buffer",
+  "process",
+  "setTimeout",
+  "setInterval",
+  "clearTimeout",
+  "clearInterval",
+  "fetch",
+  "Response",
+  "Request",
+  "Headers",
+  "URL",
+  "URLSearchParams",
+  "NextResponse",
+  "NextRequest",
+  // Common methods
+  "log",
+  "error",
+  "warn",
+  "stringify",
+  "parse",
+  "json",
+  "text",
+  "toString",
+  "map",
+  "filter",
+  "reduce",
+  "forEach",
+  "find",
+  "some",
+  "every",
+  "includes",
+  "push",
+  "pop",
+  "shift",
+  "unshift",
+  "slice",
+  "splice",
+  "concat",
+  "join",
+  "keys",
+  "values",
+  "entries",
+  "assign",
+  "freeze",
+  "status",
+  "ok",
+  "headers",
+  "body",
+  "method",
+  "url",
+  "length",
+  "trim",
+  "split",
+  "replace",
+  "match",
+  "test",
+  "exec",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "then",
+  "catch",
+  "finally"
+]);
+function truncate2(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 3) + "...";
+}
+
+// src/lib/compiler/runtime-tracer.ts
+function traceError(error, sourceMap, ir, editorUrl = "http://localhost:3001") {
+  const results = [];
+  if (!error.stack) return results;
+  const generatedFile = sourceMap.generatedFile;
+  const lineRegex = new RegExp(
+    `(?:${escapeRegex2(generatedFile)}|generated\\.ts):(\\d+)`,
+    "g"
+  );
+  let match;
+  const seenNodes = /* @__PURE__ */ new Set();
+  while ((match = lineRegex.exec(error.stack)) !== null) {
+    const lineNum = parseInt(match[1], 10);
+    const trace = traceLineToNode(sourceMap, lineNum);
+    if (trace && !seenNodes.has(trace.nodeId)) {
+      seenNodes.add(trace.nodeId);
+      const node = ir?.nodes.find((n) => n.id === trace.nodeId);
+      results.push({
+        nodeId: trace.nodeId,
+        nodeLabel: node?.label ?? trace.nodeId,
+        nodeType: node?.nodeType ?? "unknown",
+        startLine: trace.startLine,
+        endLine: trace.endLine,
+        deepLink: `${editorUrl}?highlight=${encodeURIComponent(trace.nodeId)}`
+      });
+    }
+  }
+  return results;
+}
+function formatTraceResults(error, traces, generatedFile) {
+  if (traces.length === 0) {
+    return `\u274C ${error.message}
+   (no source map match)`;
+  }
+  const lines = [`\u274C Runtime Error: ${error.message}`];
+  for (const t of traces) {
+    lines.push(
+      `   \u2192 Flow Node: [${t.nodeId}] "${t.nodeLabel}" (${t.nodeType})`,
+      `   \u2192 Lines: ${t.startLine}-${t.endLine} in ${generatedFile}`,
+      `   \u2192 \u{1F517} ${t.deepLink}`
+    );
+  }
+  return lines.join("\n");
+}
+function withFlowTrace(handler, options) {
+  const {
+    editorUrl = "http://localhost:3001",
+    sourceMap,
+    ir,
+    log = true
+  } = options;
+  if (!sourceMap) return handler;
+  const wrapped = async (...args) => {
+    try {
+      return await handler(...args);
+    } catch (err) {
+      if (err instanceof Error) {
+        const traces = traceError(err, sourceMap, ir, editorUrl);
+        if (log && traces.length > 0) {
+          console.error(
+            formatTraceResults(err, traces, sourceMap.generatedFile)
+          );
+        }
+      }
+      throw err;
+    }
+  };
+  return wrapped;
+}
+function installFlowTracer(options) {
+  const { sourceMap, ir, editorUrl = "http://localhost:3001", log = true } = options;
+  const handleError = (err) => {
+    if (!(err instanceof Error)) return;
+    const traces = traceError(err, sourceMap, ir, editorUrl);
+    if (log && traces.length > 0) {
+      console.error(
+        formatTraceResults(err, traces, sourceMap.generatedFile)
+      );
+    }
+  };
+  process.on("uncaughtException", handleError);
+  process.on("unhandledRejection", handleError);
+  return () => {
+    process.removeListener("uncaughtException", handleError);
+    process.removeListener("unhandledRejection", handleError);
+  };
+}
+function escapeRegex2(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/lib/node-registry.ts
+var NodeRegistry = class {
+  definitions = /* @__PURE__ */ new Map();
+  /** Register a single node definition */
+  register(def) {
+    this.definitions.set(def.nodeType, def);
+  }
+  /** Batch register */
+  registerAll(defs) {
+    for (const def of defs) {
+      this.register(def);
+    }
+  }
+  /** Get a single node definition */
+  get(nodeType) {
+    return this.definitions.get(nodeType);
+  }
+  /** Get all node definitions */
+  getAll() {
+    return [...this.definitions.values()];
+  }
+  /** Get node definitions by category */
+  getByCategory(category) {
+    return this.getAll().filter((d) => d.category === category);
+  }
+  /** Get all registered nodeType strings */
+  getRegisteredTypes() {
+    return [...this.definitions.keys()];
+  }
+  /** Check if registered */
+  has(nodeType) {
+    return this.definitions.has(nodeType);
+  }
+  /** Remove (for testing or hot reload) */
+  unregister(nodeType) {
+    return this.definitions.delete(nodeType);
+  }
+  /** Clear all (for testing) */
+  clear() {
+    this.definitions.clear();
+  }
+  // ── Convenience methods: backward-compatible with old API ──
+  /** Get node default ports (backward-compatible with getDefaultPorts) */
+  getDefaultPorts(nodeType) {
+    const def = this.definitions.get(nodeType);
+    return def?.defaultPorts ?? { inputs: [], outputs: [] };
+  }
+  /** Get node default parameters (backward-compatible with getDefaultParams) */
+  getDefaultParams(nodeType) {
+    const def = this.definitions.get(nodeType);
+    return def?.defaultParams ?? {};
+  }
+  /** Get node default label (backward-compatible with getDefaultLabel) */
+  getDefaultLabel(nodeType) {
+    const def = this.definitions.get(nodeType);
+    return def?.label ?? "Unknown";
+  }
+  /** Infer category from node type (backward-compatible with getCategoryForType) */
+  getCategoryForType(nodeType) {
+    const def = this.definitions.get(nodeType);
+    return def?.category ?? "action" /* ACTION */;
+  }
+  /**
+   * Group nodes by group (for NodeLibrary UI)
+   * Return format is compatible with the original NodeLibrary.tsx nodeTemplates
+   */
+  getGroupedDefinitions() {
+    const defaultGroups = {
+      ["trigger" /* TRIGGER */]: { icon: "\u26A1", color: "text-emerald-400", name: "Triggers" },
+      ["action" /* ACTION */]: { icon: "\u{1F527}", color: "text-blue-400", name: "Actions" },
+      ["logic" /* LOGIC */]: { icon: "\u{1F500}", color: "text-amber-400", name: "Logic Control" },
+      ["variable" /* VARIABLE */]: { icon: "\u{1F4E6}", color: "text-purple-400", name: "Variables" },
+      ["output" /* OUTPUT */]: { icon: "\u{1F4E4}", color: "text-rose-400", name: "Output" }
+    };
+    const groups = {};
+    const sorted = this.getAll().sort((a, b) => (a.order ?? 100) - (b.order ?? 100));
+    for (const def of sorted) {
+      const groupInfo = defaultGroups[def.category];
+      const groupName = def.group ?? groupInfo?.name ?? def.category;
+      if (!groups[groupName]) {
+        groups[groupName] = {
+          icon: groupInfo?.icon ?? "\u{1F4E6}",
+          color: groupInfo?.color ?? "text-gray-400",
+          templates: []
+        };
+      }
+      groups[groupName].templates.push({
+        nodeType: def.nodeType,
+        label: def.label,
+        icon: def.icon,
+        category: def.category
+      });
+    }
+    return groups;
+  }
+};
+var nodeRegistry = new NodeRegistry();
+var builtinNodeDefinitions = [
+  // ── Triggers ──
+  {
+    nodeType: "http_webhook" /* HTTP_WEBHOOK */,
+    category: "trigger" /* TRIGGER */,
+    label: "HTTP Webhook",
+    icon: "\u{1F310}",
+    description: "Listen for HTTP requests",
+    order: 1,
+    defaultPorts: {
+      inputs: [],
+      outputs: [
+        { id: "request", label: "Request", dataType: "object" },
+        { id: "body", label: "Body", dataType: "object" },
+        { id: "query", label: "Query", dataType: "object" }
+      ]
+    },
+    defaultParams: { method: "POST", routePath: "/api/endpoint", parseBody: true }
+  },
+  {
+    nodeType: "cron_job" /* CRON_JOB */,
+    category: "trigger" /* TRIGGER */,
+    label: "Cron Job",
+    icon: "\u23F0",
+    description: "Scheduled cron trigger",
+    order: 2,
+    defaultPorts: {
+      inputs: [],
+      outputs: [{ id: "output", label: "Output", dataType: "any" }]
+    },
+    defaultParams: { schedule: "0 * * * *", functionName: "cronHandler" }
+  },
+  {
+    nodeType: "manual" /* MANUAL */,
+    category: "trigger" /* TRIGGER */,
+    label: "Manual Trigger",
+    icon: "\u{1F464}",
+    description: "Manual trigger",
+    order: 3,
+    defaultPorts: {
+      inputs: [],
+      outputs: [{ id: "output", label: "Output", dataType: "any" }]
+    },
+    defaultParams: { functionName: "handler", args: [] }
+  },
+  // ── Actions ──
+  {
+    nodeType: "fetch_api" /* FETCH_API */,
+    category: "action" /* ACTION */,
+    label: "Fetch API",
+    icon: "\u{1F4E1}",
+    description: "Call external HTTP API",
+    order: 10,
+    defaultPorts: {
+      inputs: [{ id: "input", label: "Input", dataType: "any", required: false }],
+      outputs: [
+        { id: "response", label: "Response", dataType: "object" },
+        { id: "data", label: "Data", dataType: "any" }
+      ]
+    },
+    defaultParams: { url: "https://api.example.com", method: "GET", parseJson: true }
+  },
+  {
+    nodeType: "sql_query" /* SQL_QUERY */,
+    category: "action" /* ACTION */,
+    label: "SQL Query",
+    icon: "\u{1F5C4}\uFE0F",
+    description: "Execute SQL query",
+    order: 11,
+    defaultPorts: {
+      inputs: [{ id: "input", label: "Input", dataType: "any", required: false }],
+      outputs: [{ id: "result", label: "Result", dataType: "array" }]
+    },
+    defaultParams: { orm: "drizzle", query: "SELECT * FROM users", params: [] }
+  },
+  {
+    nodeType: "redis_cache" /* REDIS_CACHE */,
+    category: "action" /* ACTION */,
+    label: "Redis Cache",
+    icon: "\u{1F4BE}",
+    description: "Access Redis cache",
+    order: 12,
+    defaultPorts: {
+      inputs: [{ id: "input", label: "Input", dataType: "any", required: false }],
+      outputs: [{ id: "value", label: "Value", dataType: "any" }]
+    },
+    defaultParams: { operation: "get", key: "cache_key" }
+  },
+  {
+    nodeType: "custom_code" /* CUSTOM_CODE */,
+    category: "action" /* ACTION */,
+    label: "Custom Code",
+    icon: "\u{1F4BB}",
+    description: "Custom TypeScript code",
+    order: 13,
+    defaultPorts: {
+      inputs: [{ id: "input", label: "Input", dataType: "any", required: false }],
+      outputs: [{ id: "result", label: "Result", dataType: "any" }]
+    },
+    defaultParams: { code: "// your code here", returnVariable: "result" }
+  },
+  {
+    nodeType: "call_subflow" /* CALL_SUBFLOW */,
+    category: "action" /* ACTION */,
+    label: "Call Subflow",
+    icon: "\u{1F517}",
+    description: "Call subflow",
+    order: 14,
+    defaultPorts: {
+      inputs: [{ id: "input", label: "Input", dataType: "any", required: false }],
+      outputs: [{ id: "result", label: "Result", dataType: "any" }]
+    },
+    defaultParams: { flowPath: "./sub-flow", functionName: "subHandler", inputMapping: {} }
+  },
+  // ── Logic ──
+  {
+    nodeType: "if_else" /* IF_ELSE */,
+    category: "logic" /* LOGIC */,
+    label: "If / Else",
+    icon: "\u{1F500}",
+    description: "Conditional branch",
+    order: 20,
+    defaultPorts: {
+      inputs: [{ id: "input", label: "Input", dataType: "any", required: true }],
+      outputs: [
+        { id: "true", label: "True", dataType: "any" },
+        { id: "false", label: "False", dataType: "any" }
+      ]
+    },
+    defaultParams: { condition: "data !== null" }
+  },
+  {
+    nodeType: "for_loop" /* FOR_LOOP */,
+    category: "logic" /* LOGIC */,
+    label: "For Loop",
+    icon: "\u{1F501}",
+    description: "Iterate array",
+    order: 21,
+    defaultPorts: {
+      inputs: [{ id: "iterable", label: "Iterable", dataType: "array", required: true }],
+      outputs: [
+        { id: "item", label: "Item", dataType: "any" },
+        { id: "result", label: "Result", dataType: "array" }
+      ]
+    },
+    defaultParams: { iterableExpression: "items", itemVariable: "item" }
+  },
+  {
+    nodeType: "try_catch" /* TRY_CATCH */,
+    category: "logic" /* LOGIC */,
+    label: "Try / Catch",
+    icon: "\u{1F6E1}\uFE0F",
+    description: "Error handling wrapper",
+    order: 22,
+    defaultPorts: {
+      inputs: [{ id: "input", label: "Input", dataType: "any", required: true }],
+      outputs: [
+        { id: "success", label: "Success", dataType: "any" },
+        { id: "error", label: "Error", dataType: "object" }
+      ]
+    },
+    defaultParams: { errorVariable: "error" }
+  },
+  {
+    nodeType: "promise_all" /* PROMISE_ALL */,
+    category: "logic" /* LOGIC */,
+    label: "Promise.all",
+    icon: "\u26A1",
+    description: "Execute multiple async tasks in parallel",
+    order: 23,
+    defaultPorts: {
+      inputs: [
+        { id: "task1", label: "Task 1", dataType: "any", required: true },
+        { id: "task2", label: "Task 2", dataType: "any", required: true }
+      ],
+      outputs: [{ id: "results", label: "Results", dataType: "array" }]
+    },
+    defaultParams: {}
+  },
+  // ── Variables ──
+  {
+    nodeType: "declare" /* DECLARE */,
+    category: "variable" /* VARIABLE */,
+    label: "Declare Variable",
+    icon: "\u{1F4E6}",
+    description: "Declare variable",
+    order: 30,
+    defaultPorts: {
+      inputs: [],
+      outputs: [{ id: "value", label: "Value", dataType: "any" }]
+    },
+    defaultParams: { name: "myVar", dataType: "string", isConst: true, initialValue: "''" }
+  },
+  {
+    nodeType: "transform" /* TRANSFORM */,
+    category: "variable" /* VARIABLE */,
+    label: "Transform",
+    icon: "\u{1F504}",
+    description: "Transform data",
+    order: 31,
+    defaultPorts: {
+      inputs: [{ id: "input", label: "Input", dataType: "any", required: true }],
+      outputs: [{ id: "output", label: "Output", dataType: "any" }]
+    },
+    defaultParams: { expression: "input.map(x => x)" }
+  },
+  // ── Output ──
+  {
+    nodeType: "return_response" /* RETURN_RESPONSE */,
+    category: "output" /* OUTPUT */,
+    label: "Return Response",
+    icon: "\u{1F4E4}",
+    description: "Return HTTP response",
+    order: 40,
+    defaultPorts: {
+      inputs: [{ id: "data", label: "Data", dataType: "any", required: true }],
+      outputs: []
+    },
+    defaultParams: { statusCode: 200, bodyExpression: "{{$input}}" }
+  }
+];
+nodeRegistry.registerAll(builtinNodeDefinitions);
+
+// src/lib/storage/split-storage.ts
+var import_yaml = require("yaml");
+function splitIR(ir) {
+  const meta = {
+    version: ir.version,
+    name: ir.meta.name,
+    description: ir.meta.description,
+    createdAt: ir.meta.createdAt,
+    updatedAt: ir.meta.updatedAt,
+    nodeOrder: ir.nodes.map((n) => n.id)
+  };
+  const metaYaml = addHeader("Flow2Code Meta", (0, import_yaml.stringify)(meta, { lineWidth: 120 }));
+  const edgesData = ir.edges.map((e) => ({
+    id: e.id,
+    source: `${e.sourceNodeId}:${e.sourcePortId}`,
+    target: `${e.targetNodeId}:${e.targetPortId}`
+  }));
+  const edgesYaml = addHeader(
+    "Flow2Code Edges",
+    (0, import_yaml.stringify)(edgesData, { lineWidth: 120 })
+  );
+  const nodes = /* @__PURE__ */ new Map();
+  for (const node of ir.nodes) {
+    const filename = `${sanitizeFilename(node.id)}.yaml`;
+    const nodeData = {
+      id: node.id,
+      nodeType: node.nodeType,
+      category: node.category,
+      label: node.label,
+      params: node.params,
+      inputs: node.inputs,
+      outputs: node.outputs
+    };
+    nodes.set(filename, addHeader(`Node: ${node.label}`, (0, import_yaml.stringify)(nodeData, { lineWidth: 120 })));
+  }
+  return { meta: metaYaml, edges: edgesYaml, nodes };
+}
+function mergeIR(files) {
+  const meta = (0, import_yaml.parse)(files.meta);
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const [_filename, yaml] of files.nodes) {
+    const node = (0, import_yaml.parse)(yaml);
+    nodeMap.set(node.id, node);
+  }
+  const orderedNodes = [];
+  const seen = /* @__PURE__ */ new Set();
+  if (meta.nodeOrder) {
+    for (const id of meta.nodeOrder) {
+      const node = nodeMap.get(id);
+      if (node) {
+        orderedNodes.push(node);
+        seen.add(id);
+      }
+    }
+  }
+  for (const [id, node] of nodeMap) {
+    if (!seen.has(id)) {
+      orderedNodes.push(node);
+    }
+  }
+  const edgesRaw = (0, import_yaml.parse)(files.edges);
+  const edges = (edgesRaw ?? []).map((e) => {
+    const [sourceNodeId, sourcePortId] = e.source.split(":");
+    const [targetNodeId, targetPortId] = e.target.split(":");
+    return {
+      id: e.id,
+      sourceNodeId,
+      sourcePortId,
+      targetNodeId,
+      targetPortId
+    };
+  });
+  return {
+    version: meta.version,
+    meta: {
+      name: meta.name,
+      description: meta.description,
+      createdAt: meta.createdAt,
+      updatedAt: meta.updatedAt
+    },
+    nodes: orderedNodes,
+    edges
+  };
+}
+function addHeader(title, content) {
+  return `# ${title}
+# Generated by Flow2Code
+
+${content}`;
+}
+function sanitizeFilename(id) {
+  return id.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+
+// src/lib/storage/flow-project.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+function detectFormat(inputPath) {
+  if (inputPath.endsWith(".flow.json") && (0, import_node_fs.existsSync)(inputPath)) {
+    return { resolvedPath: inputPath, format: "json" };
+  }
+  if ((0, import_node_fs.existsSync)(inputPath) && (0, import_node_fs.statSync)(inputPath).isDirectory()) {
+    if ((0, import_node_fs.existsSync)((0, import_node_path.join)(inputPath, "meta.yaml"))) {
+      return { resolvedPath: inputPath, format: "split" };
+    }
+  }
+  const jsonPath = inputPath.endsWith(".json") ? inputPath : `${inputPath}.flow.json`;
+  if ((0, import_node_fs.existsSync)(jsonPath)) {
+    return { resolvedPath: jsonPath, format: "json" };
+  }
+  if ((0, import_node_fs.existsSync)(inputPath) && (0, import_node_fs.statSync)(inputPath).isDirectory()) {
+    return { resolvedPath: inputPath, format: "split" };
+  }
+  return { resolvedPath: inputPath, format: "split" };
+}
+function loadFlowProject(inputPath) {
+  const { resolvedPath, format } = detectFormat(inputPath);
+  if (format === "json") {
+    if (!(0, import_node_fs.existsSync)(resolvedPath)) {
+      throw new Error(`Flow file not found: ${resolvedPath}`);
+    }
+    const raw = (0, import_node_fs.readFileSync)(resolvedPath, "utf-8");
+    const ir2 = JSON.parse(raw);
+    return { path: resolvedPath, format, ir: ir2 };
+  }
+  if (!(0, import_node_fs.existsSync)(resolvedPath)) {
+    throw new Error(`Flow directory not found: ${resolvedPath}`);
+  }
+  const metaPath = (0, import_node_path.join)(resolvedPath, "meta.yaml");
+  if (!(0, import_node_fs.existsSync)(metaPath)) {
+    throw new Error(`meta.yaml not found in ${resolvedPath} \u2014 not a valid Flow directory`);
+  }
+  const meta = (0, import_node_fs.readFileSync)(metaPath, "utf-8");
+  const edgesPath = (0, import_node_path.join)(resolvedPath, "edges.yaml");
+  const edges = (0, import_node_fs.existsSync)(edgesPath) ? (0, import_node_fs.readFileSync)(edgesPath, "utf-8") : "";
+  const nodesDir = (0, import_node_path.join)(resolvedPath, "nodes");
+  const nodes = /* @__PURE__ */ new Map();
+  if ((0, import_node_fs.existsSync)(nodesDir)) {
+    const nodeFiles = (0, import_node_fs.readdirSync)(nodesDir).filter((f) => f.endsWith(".yaml"));
+    for (const file of nodeFiles) {
+      nodes.set(file, (0, import_node_fs.readFileSync)((0, import_node_path.join)(nodesDir, file), "utf-8"));
+    }
+  }
+  const ir = mergeIR({ meta, edges, nodes });
+  return { path: resolvedPath, format, ir };
+}
+function saveFlowProject(ir, outputPath, options = {}) {
+  const { format = "split", cleanOrphanNodes = true } = options;
+  if (format === "json") {
+    const jsonPath = outputPath.endsWith(".flow.json") ? outputPath : `${outputPath}.flow.json`;
+    const dir = (0, import_node_path.dirname)(jsonPath);
+    if (!(0, import_node_fs.existsSync)(dir)) {
+      (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+    }
+    (0, import_node_fs.writeFileSync)(jsonPath, JSON.stringify(ir, null, 2), "utf-8");
+    return [jsonPath];
+  }
+  const dirPath = outputPath.endsWith(".flow.json") ? outputPath.replace(/\.flow\.json$/, "") : outputPath;
+  (0, import_node_fs.mkdirSync)(dirPath, { recursive: true });
+  const nodesDir = (0, import_node_path.join)(dirPath, "nodes");
+  (0, import_node_fs.mkdirSync)(nodesDir, { recursive: true });
+  const files = splitIR(ir);
+  const written = [];
+  const metaPath = (0, import_node_path.join)(dirPath, "meta.yaml");
+  (0, import_node_fs.writeFileSync)(metaPath, files.meta, "utf-8");
+  written.push(metaPath);
+  const edgesPath = (0, import_node_path.join)(dirPath, "edges.yaml");
+  (0, import_node_fs.writeFileSync)(edgesPath, files.edges, "utf-8");
+  written.push(edgesPath);
+  const newNodeFiles = /* @__PURE__ */ new Set();
+  for (const [filename, content] of files.nodes) {
+    const nodePath = (0, import_node_path.join)(nodesDir, filename);
+    (0, import_node_fs.writeFileSync)(nodePath, content, "utf-8");
+    written.push(nodePath);
+    newNodeFiles.add(filename);
+  }
+  if (cleanOrphanNodes && (0, import_node_fs.existsSync)(nodesDir)) {
+    const existing = (0, import_node_fs.readdirSync)(nodesDir).filter((f) => f.endsWith(".yaml"));
+    for (const file of existing) {
+      if (!newNodeFiles.has(file)) {
+        (0, import_node_fs.rmSync)((0, import_node_path.join)(nodesDir, file));
+      }
+    }
+  }
+  return written;
+}
+function migrateToSplit(jsonPath) {
+  if (!(0, import_node_fs.existsSync)(jsonPath)) {
+    throw new Error(`File not found: ${jsonPath}`);
+  }
+  const raw = (0, import_node_fs.readFileSync)(jsonPath, "utf-8");
+  const ir = JSON.parse(raw);
+  const dirPath = jsonPath.replace(/\.flow\.json$/, "");
+  return saveFlowProject(ir, dirPath, { format: "split" });
+}
+
+// src/lib/diff/semantic-diff.ts
+function semanticDiff(before, after) {
+  const changes = [];
+  diffMeta(before, after, changes);
+  diffNodes(before.nodes, after.nodes, changes);
+  diffEdges(before.edges, after.edges, changes);
+  const stats = {
+    added: changes.filter((c) => c.type === "added").length,
+    removed: changes.filter((c) => c.type === "removed").length,
+    modified: changes.filter((c) => c.type === "modified").length,
+    total: changes.length
+  };
+  return { changes, stats };
+}
+function diffMeta(before, after, changes) {
+  const details = [];
+  if (before.meta.name !== after.meta.name) {
+    details.push({
+      field: "meta.name",
+      before: before.meta.name,
+      after: after.meta.name
+    });
+  }
+  if (before.meta.description !== after.meta.description) {
+    details.push({
+      field: "meta.description",
+      before: before.meta.description,
+      after: after.meta.description
+    });
+  }
+  if (before.version !== after.version) {
+    details.push({
+      field: "version",
+      before: before.version,
+      after: after.version
+    });
+  }
+  if (details.length > 0) {
+    changes.push({
+      type: "modified",
+      category: "meta",
+      id: "meta",
+      description: `Workflow meta changed: ${details.map((d) => d.field).join(", ")}`,
+      details
+    });
+  }
+}
+function diffNodes(beforeNodes, afterNodes, changes) {
+  const beforeMap = new Map(
+    beforeNodes.map((n) => [n.id, n])
+  );
+  const afterMap = new Map(
+    afterNodes.map((n) => [n.id, n])
+  );
+  for (const [id, node] of afterMap) {
+    if (!beforeMap.has(id)) {
+      changes.push({
+        type: "added",
+        category: "node",
+        id,
+        description: `Added node: "${node.label}" (${node.nodeType}, ${node.category})`
+      });
+    }
+  }
+  for (const [id, node] of beforeMap) {
+    if (!afterMap.has(id)) {
+      changes.push({
+        type: "removed",
+        category: "node",
+        id,
+        description: `Removed node: "${node.label}" (${node.nodeType}, ${node.category})`
+      });
+    }
+  }
+  for (const [id, beforeNode] of beforeMap) {
+    const afterNode = afterMap.get(id);
+    if (!afterNode) continue;
+    const details = diffNodeFields(beforeNode, afterNode);
+    if (details.length > 0) {
+      changes.push({
+        type: "modified",
+        category: "node",
+        id,
+        description: `Modified node: "${beforeNode.label}" \u2014 ${summarizeFieldChanges(details)}`,
+        details
+      });
+    }
+  }
+}
+function diffNodeFields(before, after) {
+  const diffs = [];
+  if (before.label !== after.label) {
+    diffs.push({ field: "label", before: before.label, after: after.label });
+  }
+  if (before.nodeType !== after.nodeType) {
+    diffs.push({
+      field: "nodeType",
+      before: before.nodeType,
+      after: after.nodeType
+    });
+  }
+  if (before.category !== after.category) {
+    diffs.push({
+      field: "category",
+      before: before.category,
+      after: after.category
+    });
+  }
+  const paramDiffs = deepDiff(
+    before.params,
+    after.params,
+    "params"
+  );
+  diffs.push(...paramDiffs);
+  return diffs;
+}
+function diffEdges(beforeEdges, afterEdges, changes) {
+  const beforeMap = new Map(beforeEdges.map((e) => [e.id, e]));
+  const afterMap = new Map(afterEdges.map((e) => [e.id, e]));
+  for (const [id, edge] of afterMap) {
+    if (!beforeMap.has(id)) {
+      changes.push({
+        type: "added",
+        category: "edge",
+        id,
+        description: `Added edge: ${edge.sourceNodeId}:${edge.sourcePortId} \u2192 ${edge.targetNodeId}:${edge.targetPortId}`
+      });
+    }
+  }
+  for (const [id, edge] of beforeMap) {
+    if (!afterMap.has(id)) {
+      changes.push({
+        type: "removed",
+        category: "edge",
+        id,
+        description: `Removed edge: ${edge.sourceNodeId}:${edge.sourcePortId} \u2192 ${edge.targetNodeId}:${edge.targetPortId}`
+      });
+    }
+  }
+  for (const [id, beforeEdge] of beforeMap) {
+    const afterEdge = afterMap.get(id);
+    if (!afterEdge) continue;
+    const details = [];
+    if (beforeEdge.sourceNodeId !== afterEdge.sourceNodeId) {
+      details.push({
+        field: "sourceNodeId",
+        before: beforeEdge.sourceNodeId,
+        after: afterEdge.sourceNodeId
+      });
+    }
+    if (beforeEdge.sourcePortId !== afterEdge.sourcePortId) {
+      details.push({
+        field: "sourcePortId",
+        before: beforeEdge.sourcePortId,
+        after: afterEdge.sourcePortId
+      });
+    }
+    if (beforeEdge.targetNodeId !== afterEdge.targetNodeId) {
+      details.push({
+        field: "targetNodeId",
+        before: beforeEdge.targetNodeId,
+        after: afterEdge.targetNodeId
+      });
+    }
+    if (beforeEdge.targetPortId !== afterEdge.targetPortId) {
+      details.push({
+        field: "targetPortId",
+        before: beforeEdge.targetPortId,
+        after: afterEdge.targetPortId
+      });
+    }
+    if (details.length > 0) {
+      changes.push({
+        type: "modified",
+        category: "edge",
+        id,
+        description: `Modified edge: ${beforeEdge.sourceNodeId} \u2192 ${beforeEdge.targetNodeId} \u2014 ${summarizeFieldChanges(details)}`,
+        details
+      });
+    }
+  }
+}
+function deepDiff(before, after, prefix) {
+  const diffs = [];
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)]);
+  for (const key of allKeys) {
+    const path = `${prefix}.${key}`;
+    const bVal = before[key];
+    const aVal = after[key];
+    if (bVal === void 0 && aVal !== void 0) {
+      diffs.push({ field: path, before: void 0, after: aVal });
+    } else if (bVal !== void 0 && aVal === void 0) {
+      diffs.push({ field: path, before: bVal, after: void 0 });
+    } else if (typeof bVal === "object" && typeof aVal === "object" && bVal !== null && aVal !== null && !Array.isArray(bVal) && !Array.isArray(aVal)) {
+      diffs.push(
+        ...deepDiff(
+          bVal,
+          aVal,
+          path
+        )
+      );
+    } else if (JSON.stringify(bVal) !== JSON.stringify(aVal)) {
+      diffs.push({ field: path, before: bVal, after: aVal });
+    }
+  }
+  return diffs;
+}
+function summarizeFieldChanges(details) {
+  if (details.length === 1) {
+    const d = details[0];
+    return `${d.field} changed from "${String(d.before)}" to "${String(d.after)}"`;
+  }
+  return `${details.length} field(s) changed (${details.map((d) => d.field).join(", ")})`;
+}
+function formatDiff(summary) {
+  const lines = [];
+  const { changes, stats } = summary;
+  if (stats.total === 0) {
+    return "\u2705 No differences";
+  }
+  lines.push(
+    `\u{1F4CA} Diff summary: +${stats.added} added, -${stats.removed} removed, \u270F\uFE0F ${stats.modified} modified`
+  );
+  lines.push("");
+  const metaChanges = changes.filter((c) => c.category === "meta");
+  const nodeChanges = changes.filter((c) => c.category === "node");
+  const edgeChanges = changes.filter((c) => c.category === "edge");
+  if (metaChanges.length > 0) {
+    lines.push("\u2500\u2500 Meta \u2500\u2500");
+    for (const change of metaChanges) {
+      lines.push(`  ${getChangeIcon(change.type)} ${change.description}`);
+      formatDetails(change.details, lines);
+    }
+    lines.push("");
+  }
+  if (nodeChanges.length > 0) {
+    lines.push("\u2500\u2500 Nodes \u2500\u2500");
+    for (const change of nodeChanges) {
+      lines.push(`  ${getChangeIcon(change.type)} ${change.description}`);
+      formatDetails(change.details, lines);
+    }
+    lines.push("");
+  }
+  if (edgeChanges.length > 0) {
+    lines.push("\u2500\u2500 Edges \u2500\u2500");
+    for (const change of edgeChanges) {
+      lines.push(`  ${getChangeIcon(change.type)} ${change.description}`);
+      formatDetails(change.details, lines);
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+function formatDetails(details, lines) {
+  if (!details || details.length === 0) return;
+  for (const d of details) {
+    const before = formatValue(d.before);
+    const after = formatValue(d.after);
+    lines.push(`      ${d.field}: ${before} \u2192 ${after}`);
+  }
+}
+function formatValue(value) {
+  if (value === void 0) return "(unset)";
+  if (value === null) return "null";
+  if (typeof value === "string") return `"${value}"`;
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function getChangeIcon(type) {
+  switch (type) {
+    case "added":
+      return "\u{1F7E2}";
+    case "removed":
+      return "\u{1F534}";
+    case "modified":
+      return "\u{1F7E1}";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActionType,
+  CURRENT_IR_VERSION,
+  LogicType,
+  NodeCategory,
+  NodeRegistry,
+  OutputType,
+  TriggerType,
+  VariableType,
+  builtinPlugins,
+  clearPlugins,
+  compile,
+  createPluginRegistry,
+  decompile,
+  detectFormat,
+  formatDiff,
+  formatSecurityReport,
+  formatTraceResults,
+  getAllPlugins,
+  getAvailablePlatforms,
+  getPlatform,
+  getPlugin,
+  hasPlugin,
+  inferFlowStateTypes,
+  installFlowTracer,
+  loadFlowProject,
+  mergeIR,
+  migrateToSplit,
+  nodeRegistry,
+  parseExpression,
+  registerPlatform,
+  registerPlugin,
+  registerPlugins,
+  saveFlowProject,
+  semanticDiff,
+  splitIR,
+  topologicalSort,
+  traceError,
+  traceLineToNode,
+  validate,
+  validateFlowIR,
+  validateIRSecurity,
+  withFlowTrace
+});
+//# sourceMappingURL=compiler.cjs.map