@timo9378/flow2code 0.1.9 → 0.2.1

package/dist/server.js

@@ -1,20 +1,24 @@
 #!/usr/bin/env node
-
-// src/server/index.ts
-import { createServer } from "http";
-import { readFile, stat } from "fs/promises";
-import { join as join2, extname, dirname as dirname2, resolve as resolve2 } from "path";
-import { fileURLToPath } from "url";
-import { existsSync as existsSync2 } from "fs";
-
-// src/lib/compiler/compiler.ts
-import { Project } from "ts-morph";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/lib/ir/types.ts
-var CURRENT_IR_VERSION = "1.0.0";
+var CURRENT_IR_VERSION;
+var init_types = __esm({
+  "src/lib/ir/types.ts"() {
+    "use strict";
+    CURRENT_IR_VERSION = "1.0.0";
+  }
+});
 
 // src/lib/ir/migrations/engine.ts
-var migrations = [];
 function migrateIR(raw, targetVersion = CURRENT_IR_VERSION) {
   const applied = [];
   let current = { ...raw };
@@ -51,14 +55,30 @@ function migrateIR(raw, targetVersion = CURRENT_IR_VERSION) {
 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";
+var migrations, MigrationError;
+var init_engine = __esm({
+  "src/lib/ir/migrations/engine.ts"() {
+    "use strict";
+    init_types();
+    migrations = [];
+    MigrationError = class extends Error {
+      constructor(message, fromVersion, targetVersion) {
+        super(message);
+        this.fromVersion = fromVersion;
+        this.targetVersion = targetVersion;
+        this.name = "MigrationError";
+      }
+    };
   }
-};
+});
+
+// src/lib/ir/migrations/index.ts
+var init_migrations = __esm({
+  "src/lib/ir/migrations/index.ts"() {
+    "use strict";
+    init_engine();
+  }
+});
 
 // src/lib/ir/validator.ts
 function validateFlowIR(ir) {
@@ -185,14 +205,38 @@ function validateFlowIR(ir) {
       });
     }
   }
+  for (const edge of workingIR.edges) {
+    const sourceNode = workingNodeMap.get(edge.sourceNodeId);
+    const targetNode = workingNodeMap.get(edge.targetNodeId);
+    if (!sourceNode || !targetNode) continue;
+    const sourcePort = sourceNode.outputs?.find((p) => p.id === edge.sourcePortId);
+    const targetPort = targetNode.inputs?.find((p) => p.id === edge.targetPortId);
+    if (!sourcePort || !targetPort) continue;
+    if (!isTypeCompatible(sourcePort.dataType, targetPort.dataType)) {
+      errors.push({
+        code: "TYPE_MISMATCH",
+        message: `Type mismatch on edge "${edge.id}": output "${sourcePort.label}" (${sourcePort.dataType}) \u2192 input "${targetPort.label}" (${targetPort.dataType})`,
+        edgeId: edge.id,
+        severity: "warning"
+      });
+    }
+  }
   return {
-    valid: errors.length === 0,
+    valid: errors.filter((e) => e.severity !== "warning" && e.severity !== "info").length === 0,
     errors,
     migrated,
     migratedIR: migrated ? workingIR : void 0,
     migrationLog
   };
 }
+function isTypeCompatible(source, target) {
+  if (source === target) return true;
+  if (source === "any" || target === "any") return true;
+  if (target === "object" && source === "array") return true;
+  if (target === "string" && source === "number") return true;
+  if (target === "number" && source === "string") return true;
+  return false;
+}
 function detectCycles(nodes, edges) {
   const errors = [];
   const adjacency = /* @__PURE__ */ new Map();
@@ -238,6 +282,13 @@ function detectCycles(nodes, edges) {
   }
   return errors;
 }
+var init_validator = __esm({
+  "src/lib/ir/validator.ts"() {
+    "use strict";
+    init_types();
+    init_migrations();
+  }
+});
 
 // src/lib/ir/topological-sort.ts
 function buildGraph(nodes, edges) {
@@ -310,6 +361,11 @@ function topologicalSort(ir) {
     dependents
   };
 }
+var init_topological_sort = __esm({
+  "src/lib/ir/topological-sort.ts"() {
+    "use strict";
+  }
+});
 
 // src/lib/compiler/expression-parser.ts
 function parseExpression(expr, context) {
@@ -460,8 +516,6 @@ function resolveInputRef(path, context) {
     `Expression parser error: Node "${context.currentNodeId}" has no input connected`
   );
 }
-var _cachedTriggerIR = null;
-var _cachedTriggerId = null;
 function resolveTriggerRef(path, context) {
   if (_cachedTriggerIR !== context.ir) {
     _cachedTriggerIR = context.ir;
@@ -478,17 +532,24 @@ function resolveTriggerRef(path, context) {
   }
   return "undefined";
 }
-var ExpressionParseError = class extends Error {
-  constructor(message, expression, position) {
-    super(message);
-    this.expression = expression;
-    this.position = position;
-    this.name = "ExpressionParseError";
+var _cachedTriggerIR, _cachedTriggerId, ExpressionParseError;
+var init_expression_parser = __esm({
+  "src/lib/compiler/expression-parser.ts"() {
+    "use strict";
+    _cachedTriggerIR = null;
+    _cachedTriggerId = null;
+    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);
 }
@@ -501,519 +562,557 @@ function getPlatform(name) {
   }
   return factory();
 }
+var platformRegistry;
+var init_types2 = __esm({
+  "src/lib/compiler/platforms/types.ts"() {
+    "use strict";
+    platformRegistry = /* @__PURE__ */ new Map();
+  }
+});
 
 // 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 */: {
+var NextjsPlatform;
+var init_nextjs = __esm({
+  "src/lib/compiler/platforms/nextjs.ts"() {
+    "use strict";
+    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);
-        if (isGetOrDelete) {
-          writer.writeLine("const searchParams = req.nextUrl.searchParams;");
+        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(
-            "const query = Object.fromEntries(searchParams.entries());"
+            `throw new EarlyResponse(NextResponse.json(${bodyExpr}, { status: ${statusCode}, headers: ${JSON.stringify(headers)} }));`
           );
-          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};`);
+          writer.writeLine(
+            `throw new EarlyResponse(NextResponse.json(${bodyExpr}, { status: ${statusCode} }));`
+          );
         }
-        break;
       }
-      case "cron_job" /* CRON_JOB */: {
+      generateErrorResponse(writer) {
+        writer.write("if (error instanceof EarlyResponse) ").block(() => {
+          writer.writeLine("return error.response;");
+        });
+        writer.writeLine('console.error("Workflow failed:", error);');
         writer.writeLine(
-          `const ${varName} = { triggeredAt: new Date().toISOString() };`
+          'return NextResponse.json({ error: error instanceof Error ? error.message : "Internal Server Error" }, { status: 500 });'
         );
-        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};`);
+      getOutputFilePath(trigger) {
+        if (trigger.nodeType === "http_webhook" /* HTTP_WEBHOOK */) {
+          const params = trigger.params;
+          const routePath = params.routePath.replace(/^\//, "");
+          return `src/app/${routePath}/route.ts`;
         }
-        break;
+        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";
       }
-    }
-  }
-  // ── 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);
-    });
+      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)});`);
+var ExpressPlatform;
+var init_express = __esm({
+  "src/lib/compiler/platforms/express.ts"() {
+    "use strict";
+    ExpressPlatform = class {
+      name = "express";
+      generateImports(sourceFile, trigger, _context) {
+        if (trigger.nodeType === "http_webhook" /* HTTP_WEBHOOK */) {
+          sourceFile.addImportDeclaration({
+            namedImports: ["Request", "Response"],
+            moduleSpecifier: "express"
+          });
+        }
       }
-    }
-    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};`);
+      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}`);
         }
-        break;
       }
-      case "cron_job" /* CRON_JOB */: {
+      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(
-          `const ${varName} = { triggeredAt: new Date().toISOString() };`
+          'return res.status(500).json({ error: error instanceof Error ? error.message : "Internal Server Error" });'
         );
-        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};`);
+      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`;
         }
-        break;
+        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";
       }
-    }
-  }
-  // ── 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 */: {
+      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 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;");
+        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(() => {
-            writer.writeLine("body = await request.json();");
+            bodyGenerator(writer);
           });
-          writer.write(" catch ").block(() => {
-            writer.writeLine(
-              'return new Response(JSON.stringify({ error: "Invalid JSON body" }), { status: 400, headers: { "Content-Type": "application/json" } });'
-            );
+          writer.write(" catch (error) ").block(() => {
+            this.generateErrorResponse(writer);
           });
-          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};`);
+        });
+      }
+      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;
+var init_cloudflare = __esm({
+  "src/lib/compiler/platforms/cloudflare.ts"() {
+    "use strict";
+    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}`);
         }
-        break;
       }
-      case "cron_job" /* CRON_JOB */: {
+      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(
-          `const ${varName} = { triggeredAt: new Date().toISOString() };`
+          `throw new EarlyResponse(new Response(JSON.stringify(${bodyExpr})${headersObj}));`
         );
-        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};`);
+      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";
         }
-        break;
+        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";
       }
-    }
-  }
-  // ── 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(`
+      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);
+        });
+      }
+    };
   }
-  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());
+var init_platforms = __esm({
+  "src/lib/compiler/platforms/index.ts"() {
+    "use strict";
+    init_types2();
+    init_nextjs();
+    init_express();
+    init_cloudflare();
+    init_types2();
+    init_nextjs();
+    init_express();
+    init_cloudflare();
+    registerPlatform("nextjs", () => new NextjsPlatform());
+    registerPlatform("express", () => new ExpressPlatform());
+    registerPlatform("cloudflare", () => new CloudflarePlatform());
+  }
+});
 
 // src/lib/compiler/plugins/types.ts
 function createPluginRegistry() {
@@ -1039,10 +1138,16 @@ function createPluginRegistry() {
     }
   };
 }
-var globalRegistry = createPluginRegistry();
 function getPlugin(nodeType) {
   return globalRegistry.get(nodeType);
 }
+var globalRegistry;
+var init_types3 = __esm({
+  "src/lib/compiler/plugins/types.ts"() {
+    "use strict";
+    globalRegistry = createPluginRegistry();
+  }
+});
 
 // src/lib/compiler/plugins/builtin.ts
 function inferTypeFromExpression(expr) {
@@ -1117,459 +1222,473 @@ function inferTypeFromCode(code, returnVar) {
 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" },`
-        );
+var httpWebhookPlugin, cronJobPlugin, manualPlugin, fetchApiPlugin, sqlQueryPlugin, redisCachePlugin, DANGEROUS_CODE_PATTERNS, customCodePlugin, callSubflowPlugin, ifElsePlugin, forLoopPlugin, tryCatchPlugin, promiseAllPlugin, declarePlugin, transformPlugin, returnResponsePlugin, builtinPlugins;
+var init_builtin = __esm({
+  "src/lib/compiler/plugins/builtin.ts"() {
+    "use strict";
+    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 }";
+      }
+    };
+    cronJobPlugin = {
+      nodeType: "cron_job" /* CRON_JOB */,
+      generate: () => {
+      },
+      getOutputType: () => "{ triggeredAt: string }"
+    };
+    manualPlugin = {
+      nodeType: "manual" /* MANUAL */,
+      generate: () => {
+      },
+      getOutputType: () => "Record<string, unknown>"
+    };
+    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";
       }
-      if (hasBody) {
-        const bodyExpr = context.resolveExpression(params.body, node.id);
-        if (bodyExpr.trimStart().startsWith("JSON.stringify")) {
-          writer.writeLine(`  body: ${bodyExpr},`);
+    };
+    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[]"
+    };
+    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";
+      }
+    };
+    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" }
+    ];
+    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(`  body: JSON.stringify(${bodyExpr}),`);
+          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);
       }
-      writer.writeLine("});");
-      writer.blankLine();
-      writer.write("if (!response.ok) ").block(() => {
+    };
+    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(
-          `throw new Error(\`${node.label} failed: HTTP \${response.status} \${response.statusText}\`);`
+          `flowState['${node.id}'] = await ${params.functionName}({ ${args} });`
         );
-      });
-      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;`);
+      },
+      getOutputType(node) {
+        const params = node.params;
+        if (params.returnType) return params.returnType;
+        return `Awaited<ReturnType<typeof ${params.functionName}>>`;
       }
-    });
-    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}\`);`
+    };
+    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"
         );
-        writer.writeLine(`flowState['${node.id}'] = result;`);
-        break;
-      case "prisma":
-        writer.writeLine(`// Prisma Query`);
-        writer.writeLine(
-          `const result = await prisma.$queryRaw\`${params.query}\`;`
+        const falseEdges = context.ir.edges.filter(
+          (e) => e.sourceNodeId === node.id && e.sourcePortId === "false"
         );
-        writer.writeLine(`flowState['${node.id}'] = result;`);
-        break;
-      case "raw":
-      default:
-        writer.writeLine(`// Raw SQL Query`);
-        writer.writeLine(
-          `const result = await db.query(\`${params.query}\`);`
+        const conditionExpr = context.resolveExpression(
+          params.condition,
+          node.id
         );
-        writer.writeLine(`flowState['${node.id}'] = result;`);
-        break;
-    }
-  },
-  getRequiredPackages(node) {
-    const params = node.params;
-    const map = {
-      drizzle: ["drizzle-orm"],
-      prisma: ["@prisma/client"],
-      raw: []
+        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"
     };
-    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});`
+    forLoopPlugin = {
+      nodeType: "for_loop" /* FOR_LOOP */,
+      generate(node, writer, context) {
+        const params = node.params;
+        const iterableExpr = context.resolveExpression(
+          params.iterableExpression,
+          node.id
         );
-        break;
-      case "set":
-        if (params.ttl) {
-          writer.writeLine(
-            `await redis.set(${keyExpr}, ${params.value ?? "null"}, "EX", ${params.ttl});`
+        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.writeLine(
-            `await redis.set(${keyExpr}, ${params.value ?? "null"});`
+          writer.write(
+            `for (const ${params.itemVariable} of ${iterableExpr}) `
           );
         }
-        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);
+        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);
+            }
           }
-        }
-      });
-    }
-  },
-  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)} });`
+          context.popScope();
+          writer.writeLine(`${sanitizedId}_results.push(${params.itemVariable});`);
+        });
+        writer.writeLine(`flowState['${node.id}'] = ${sanitizedId}_results;`);
+      },
+      getOutputType: () => "unknown[]"
+    };
+    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"
         );
-      } else {
+        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 }"
+    };
+    promiseAllPlugin = {
+      nodeType: "promise_all" /* PROMISE_ALL */,
+      generate(node, writer) {
+        writer.writeLine(`// Promise.all handled by concurrent execution`);
         writer.writeLine(
-          `return NextResponse.json(${bodyExpr}, { status: ${params.statusCode} });`
+          `flowState['${node.id}'] = undefined; // populated by concurrent handler`
         );
+      },
+      getOutputType: () => "unknown[]"
+    };
+    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;
       }
-    }
-  },
-  getOutputType: () => "never"
-};
-var builtinPlugins = [
-  // Triggers
-  httpWebhookPlugin,
-  cronJobPlugin,
-  manualPlugin,
-  // Actions
-  fetchApiPlugin,
-  sqlQueryPlugin,
-  redisCachePlugin,
-  customCodePlugin,
-  callSubflowPlugin,
-  // Logic
-  ifElsePlugin,
-  forLoopPlugin,
-  tryCatchPlugin,
-  promiseAllPlugin,
-  // Variables
-  declarePlugin,
-  transformPlugin,
-  // Output
-  returnResponsePlugin
-];
+    };
+    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);
+      }
+    };
+    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"
+    };
+    builtinPlugins = [
+      // Triggers
+      httpWebhookPlugin,
+      cronJobPlugin,
+      manualPlugin,
+      // Actions
+      fetchApiPlugin,
+      sqlQueryPlugin,
+      redisCachePlugin,
+      customCodePlugin,
+      callSubflowPlugin,
+      // Logic
+      ifElsePlugin,
+      forLoopPlugin,
+      tryCatchPlugin,
+      promiseAllPlugin,
+      // Variables
+      declarePlugin,
+      transformPlugin,
+      // Output
+      returnResponsePlugin
+    ];
+  }
+});
+
+// src/lib/compiler/plugins/index.ts
+var init_plugins = __esm({
+  "src/lib/compiler/plugins/index.ts"() {
+    "use strict";
+    init_types3();
+  }
+});
 
 // src/lib/compiler/type-inference.ts
 function inferFlowStateTypes(ir, registry) {
@@ -1620,6 +1739,12 @@ function mapFlowDataTypeToTS(dataType) {
       return "unknown";
   }
 }
+var init_type_inference = __esm({
+  "src/lib/compiler/type-inference.ts"() {
+    "use strict";
+    init_types3();
+  }
+});
 
 // src/lib/compiler/symbol-table.ts
 function buildSymbolTable(ir) {
@@ -1665,75 +1790,89 @@ function labelToVarName(label) {
     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"
-]);
+var RESERVED_WORDS;
+var init_symbol_table = __esm({
+  "src/lib/compiler/symbol-table.ts"() {
+    "use strict";
+    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
+var compiler_exports = {};
+__export(compiler_exports, {
+  compile: () => compile,
+  compileWithPrettier: () => compileWithPrettier,
+  formatWithPrettier: () => formatWithPrettier,
+  traceLineToNode: () => traceLineToNode
+});
+import { Project } from "ts-morph";
 function compile(ir, options) {
   const pluginRegistry = createPluginRegistry();
   pluginRegistry.registerAll(builtinPlugins);
@@ -1811,7 +1950,7 @@ function compile(ir, options) {
     indentSize: 2,
     convertTabsToSpaces: true
   });
-  const code = sourceFile.getFullText();
+  let code = sourceFile.getFullText();
   const filePath = platform.getOutputFilePath(trigger);
   collectRequiredPackages(workingIR, context);
   const sourceMap = buildSourceMap(code, workingIR, filePath);
@@ -1828,6 +1967,28 @@ function compile(ir, options) {
     sourceMap
   };
 }
+async function formatWithPrettier(code, options) {
+  try {
+    const prettier = await import("prettier");
+    return await prettier.format(code, {
+      parser: "typescript",
+      printWidth: options?.printWidth ?? 100,
+      tabWidth: 2,
+      singleQuote: options?.singleQuote ?? true,
+      trailingComma: "all",
+      semi: true
+    });
+  } catch {
+    return code;
+  }
+}
+async function compileWithPrettier(ir, options) {
+  const result = compile(ir, options);
+  if (!result.success || !result.code) return result;
+  const formatted = await formatWithPrettier(result.code);
+  const sourceMap = result.sourceMap ? buildSourceMap(formatted, ir, result.filePath ?? "formatted.ts") : void 0;
+  return { ...result, code: formatted, sourceMap };
+}
 function generateCode(sourceFile, trigger, context) {
   const { platform } = context;
   platform.generateImports(sourceFile, trigger, {
@@ -1862,11 +2023,6 @@ function generateFunctionBody(writer, trigger, context) {
   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;
@@ -2221,8 +2377,58 @@ function buildSourceMap(code, ir, filePath) {
     mappings
   };
 }
+function traceLineToNode(sourceMap, line) {
+  const entries = Object.entries(sourceMap.mappings).map(([nodeId, range]) => ({ nodeId, ...range })).sort((a, b) => a.startLine - b.startLine);
+  let lo = 0;
+  let hi = entries.length - 1;
+  while (lo <= hi) {
+    const mid = lo + hi >>> 1;
+    const e = entries[mid];
+    if (line < e.startLine) {
+      hi = mid - 1;
+    } else if (line > e.endLine) {
+      lo = mid + 1;
+    } else {
+      return e;
+    }
+  }
+  return null;
+}
+var CONTROL_FLOW_PORT_MAP;
+var init_compiler = __esm({
+  "src/lib/compiler/compiler.ts"() {
+    "use strict";
+    init_validator();
+    init_topological_sort();
+    init_expression_parser();
+    init_platforms();
+    init_plugins();
+    init_builtin();
+    init_type_inference();
+    init_symbol_table();
+    registerPlatform("nextjs", () => new NextjsPlatform());
+    registerPlatform("express", () => new ExpressPlatform());
+    registerPlatform("cloudflare", () => new CloudflarePlatform());
+    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"])
+    };
+  }
+});
+
+// src/server/index.ts
+import { createServer } from "http";
+import { readFile, stat } from "fs/promises";
+import { join as join2, extname, dirname as dirname2, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+import { existsSync as existsSync2 } from "fs";
+
+// src/server/handlers.ts
+init_compiler();
 
 // src/lib/compiler/decompiler.ts
+init_types();
 import {
   Project as Project2,
   SyntaxKind
@@ -3052,6 +3258,9 @@ function truncate(str, maxLen) {
   return str.slice(0, maxLen - 3) + "...";
 }
 
+// src/server/handlers.ts
+init_validator();
+
 // src/lib/ir/security.ts
 var SECURITY_PATTERNS = [
   // ── Critical: Remote Code Execution / System Access ──
@@ -3509,7 +3718,7 @@ Return ONLY valid JSON (no markdown, no explanation). The JSON must conform to t
 // src/server/handlers.ts
 import { writeFileSync, mkdirSync, existsSync, readFileSync } from "fs";
 import { join, dirname, resolve } from "path";
-function handleCompile(body, projectRoot) {
+async function handleCompile(body, projectRoot) {
   try {
     const ir = body.ir;
     const shouldWrite = body.write !== false;
@@ -3523,8 +3732,16 @@ function handleCompile(body, projectRoot) {
         body: { success: false, error: result.errors?.join("\n") }
       };
     }
+    let finalCode = result.code;
+    if (finalCode) {
+      try {
+        const { formatWithPrettier: formatWithPrettier2 } = await Promise.resolve().then(() => (init_compiler(), compiler_exports));
+        finalCode = await formatWithPrettier2(finalCode);
+      } catch {
+      }
+    }
     let writtenPath = null;
-    if (shouldWrite && result.filePath && result.code) {
+    if (shouldWrite && result.filePath && finalCode) {
       const fullPath = resolve(join(projectRoot, result.filePath));
       const resolvedRoot = resolve(projectRoot);
       const sep = resolvedRoot.endsWith("/") || resolvedRoot.endsWith("\\") ? "" : process.platform === "win32" ? "\\" : "/";
@@ -3538,7 +3755,7 @@ function handleCompile(body, projectRoot) {
       if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
       }
-      writeFileSync(fullPath, result.code, "utf-8");
+      writeFileSync(fullPath, finalCode, "utf-8");
       writtenPath = fullPath;
       if (result.sourceMap) {
         const mapPath = fullPath.replace(/\.ts$/, ".flow.map.json");
@@ -3565,7 +3782,7 @@ function handleCompile(body, projectRoot) {
       status: 200,
       body: {
         success: true,
-        code: result.code,
+        code: finalCode,
         filePath: result.filePath,
         writtenTo: writtenPath,
         dependencies: result.dependencies,
@@ -3968,7 +4185,7 @@ async function handleRequest(req, res, staticDir, projectRoot) {
       return;
     }
     if (pathname === "/api/compile") {
-      const result = handleCompile(body, projectRoot);
+      const result = await handleCompile(body, projectRoot);
       sendJson(res, result.status, result.body);
       return;
     }