@timo9378/flow2code 0.1.0

package/dist/server.js

@@ -0,0 +1,3042 @@
+#!/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 } from "path";
+import { fileURLToPath } from "url";
+import { existsSync as existsSync2 } from "fs";
+
+// src/lib/compiler/compiler.ts
+import { Project } from "ts-morph";
+
+// src/lib/ir/types.ts
+var 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 };
+  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();
+}
+
+// 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 getPlugin(nodeType) {
+  return globalRegistry.get(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 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
+  };
+}
+
+// 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/openapi/converter.ts
+function convertOpenAPIToFlowIR(jsonInput) {
+  idCounter = 0;
+  const errors = [];
+  let spec;
+  try {
+    spec = typeof jsonInput === "string" ? JSON.parse(jsonInput) : jsonInput;
+  } catch (e) {
+    return {
+      success: false,
+      flows: [],
+      errors: [`JSON parse failed: ${e instanceof Error ? e.message : String(e)}`],
+      summary: { totalPaths: 0, totalOperations: 0, tags: [] }
+    };
+  }
+  if (!spec.openapi || !spec.paths) {
+    return {
+      success: false,
+      flows: [],
+      errors: ["Not a valid OpenAPI spec: missing openapi or paths field"],
+      summary: { totalPaths: 0, totalOperations: 0, tags: [] }
+    };
+  }
+  const flows = [];
+  const allTags = /* @__PURE__ */ new Set();
+  let totalOps = 0;
+  const methods = ["get", "post", "put", "patch", "delete"];
+  for (const [path, pathItem] of Object.entries(spec.paths)) {
+    for (const method of methods) {
+      const operation = pathItem[method];
+      if (!operation) continue;
+      totalOps++;
+      operation.tags?.forEach((t) => allTags.add(t));
+      try {
+        const flow = convertSingleOperation(
+          path,
+          method.toUpperCase(),
+          operation,
+          spec
+        );
+        flows.push(flow);
+      } catch (e) {
+        errors.push(
+          `${method.toUpperCase()} ${path}: ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+    }
+  }
+  return {
+    success: errors.length === 0,
+    flows,
+    errors,
+    summary: {
+      totalPaths: Object.keys(spec.paths).length,
+      totalOperations: totalOps,
+      tags: [...allTags].sort()
+    }
+  };
+}
+var idCounter = 0;
+function nextId(prefix) {
+  return `${prefix}_${++idCounter}`;
+}
+function convertSingleOperation(path, method, operation, _spec) {
+  const nodes = [];
+  const edges = [];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const isBodyMethod = ["POST", "PUT", "PATCH"].includes(method);
+  const hasRequestBody = isBodyMethod && !!operation.requestBody;
+  const hasQueryParams = operation.parameters?.some((p) => p.in === "query");
+  const hasPathParams = operation.parameters?.some((p) => p.in === "path");
+  const triggerId = nextId("trigger");
+  const queryParamsDef = operation.parameters?.filter((p) => p.in === "query").map((p) => ({
+    name: p.name,
+    type: mapOpenAPIType(p.schema?.type),
+    required: p.required ?? false
+  }));
+  const triggerNode = {
+    id: triggerId,
+    nodeType: "http_webhook" /* HTTP_WEBHOOK */,
+    category: "trigger" /* TRIGGER */,
+    label: `${method} ${path}`,
+    params: {
+      method,
+      routePath: convertPathToNextJS(path),
+      parseBody: hasRequestBody,
+      ...queryParamsDef && queryParamsDef.length > 0 ? { queryParams: queryParamsDef } : {}
+    },
+    inputs: [],
+    outputs: buildTriggerOutputs(method, hasRequestBody, hasQueryParams)
+  };
+  nodes.push(triggerNode);
+  let prevNodeId = triggerId;
+  if (hasPathParams) {
+    const transformId = nextId("transform");
+    const pathParams = operation.parameters.filter((p) => p.in === "path");
+    const transformNode = {
+      id: transformId,
+      nodeType: "transform",
+      category: "variable" /* VARIABLE */,
+      label: "Extract Path Params",
+      params: {
+        expression: `{ ${pathParams.map((p) => `${p.name}: {{$trigger}}.query.${p.name}`).join(", ")} }`
+      },
+      inputs: [
+        { id: "input", label: "Input", dataType: "any", required: true }
+      ],
+      outputs: [{ id: "result", label: "Result", dataType: "object" }]
+    };
+    nodes.push(transformNode);
+    edges.push({
+      id: nextId("edge"),
+      sourceNodeId: prevNodeId,
+      sourcePortId: "request",
+      targetNodeId: transformId,
+      targetPortId: "input"
+    });
+    prevNodeId = transformId;
+  }
+  const responseId = nextId("response");
+  const successStatus = getSuccessStatus(operation);
+  const responseNode = {
+    id: responseId,
+    nodeType: "return_response" /* RETURN_RESPONSE */,
+    category: "output" /* OUTPUT */,
+    label: operation.summary || `Return ${successStatus}`,
+    params: {
+      statusCode: successStatus,
+      bodyExpression: "{{$input}}",
+      headers: { "Content-Type": "application/json" }
+    },
+    inputs: [
+      { id: "data", label: "Data", dataType: "any", required: true }
+    ],
+    outputs: []
+  };
+  nodes.push(responseNode);
+  edges.push({
+    id: nextId("edge"),
+    sourceNodeId: prevNodeId,
+    sourcePortId: prevNodeId === triggerId ? "request" : "result",
+    targetNodeId: responseId,
+    targetPortId: "data"
+  });
+  return {
+    version: "1.0.0",
+    meta: {
+      name: operation.operationId || `${method} ${path}`,
+      description: operation.description || operation.summary || "",
+      createdAt: now,
+      updatedAt: now
+    },
+    nodes,
+    edges
+  };
+}
+function buildTriggerOutputs(method, hasBody, hasQuery) {
+  const outputs = [
+    { id: "request", label: "Request", dataType: "object" }
+  ];
+  if (hasBody) {
+    outputs.push({ id: "body", label: "Body", dataType: "object" });
+  }
+  if (hasQuery) {
+    outputs.push({ id: "query", label: "Query", dataType: "object" });
+  }
+  return outputs;
+}
+function getSuccessStatus(operation) {
+  if (!operation.responses) return 200;
+  const statusCodes = Object.keys(operation.responses);
+  const success = statusCodes.find((s) => s.startsWith("2"));
+  return success ? parseInt(success, 10) : 200;
+}
+function convertPathToNextJS(path) {
+  const apiPath = path.startsWith("/api") ? path : `/api${path}`;
+  return apiPath.replace(/\{(\w+)\}/g, "[$1]");
+}
+function mapOpenAPIType(type) {
+  switch (type) {
+    case "integer":
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "array":
+      return "array";
+    case "object":
+      return "object";
+    case "string":
+    default:
+      return "string";
+  }
+}
+
+// src/lib/ai/prompt.ts
+var FLOW_IR_SYSTEM_PROMPT = `You are Flow2Code AI, a specialist in generating FlowIR JSON for a visual API builder.
+
+## Your Task
+Given a user's natural language description of an API endpoint or workflow, generate a valid FlowIR JSON object.
+
+## FlowIR Schema
+
+### Top-level structure:
+\`\`\`json
+{
+  "version": "1.0.0",
+  "meta": {
+    "name": "string",
+    "description": "string (optional)",
+    "createdAt": "ISO 8601 date string",
+    "updatedAt": "ISO 8601 date string"
+  },
+  "nodes": [ ... ],
+  "edges": [ ... ]
+}
+\`\`\`
+
+### Node structure:
+\`\`\`json
+{
+  "id": "unique_string (e.g. trigger_1, fetch_1, response_1)",
+  "nodeType": "one of the NodeType enums below",
+  "category": "trigger | action | logic | variable | output",
+  "label": "human readable label",
+  "params": { ... type-specific params ... },
+  "inputs": [{ "id": "string", "label": "string", "dataType": "string|number|boolean|object|array|any|void|Response", "required": boolean }],
+  "outputs": [{ "id": "string", "label": "string", "dataType": "string|number|boolean|object|array|any|void|Response" }]
+}
+\`\`\`
+
+### Edge structure:
+\`\`\`json
+{
+  "id": "unique_string (e.g. e1, e2)",
+  "sourceNodeId": "node id",
+  "sourcePortId": "output port id",
+  "targetNodeId": "node id",
+  "targetPortId": "input port id"
+}
+\`\`\`
+
+### Available Node Types:
+
+#### Triggers (category: "trigger") \u2014 exactly ONE required per flow:
+1. **http_webhook** \u2014 params: { method: "GET"|"POST"|"PUT"|"PATCH"|"DELETE", routePath: "/api/...", parseBody: boolean }
+   - outputs: [{ id: "request", label: "Request", dataType: "object" }, { id: "body", label: "Body", dataType: "object" }, { id: "query", label: "Query", dataType: "object" }]
+   - inputs: none
+   
+2. **cron_job** \u2014 params: { schedule: "cron expression", functionName: "string" }
+   - outputs: [{ id: "output", label: "Output", dataType: "any" }]
+   
+3. **manual** \u2014 params: { functionName: "string", args: [{ name: "string", type: "FlowDataType" }] }
+   - outputs: [{ id: "output", label: "Output", dataType: "any" }]
+
+#### Actions (category: "action"):
+4. **fetch_api** \u2014 params: { url: "string (supports \${ENV_VAR})", method: "GET"|"POST"|"PUT"|"PATCH"|"DELETE", headers?: {}, body?: "string", parseJson: boolean }
+   - inputs: [{ id: "input", label: "Input", dataType: "any", required: false }]
+   - outputs: [{ id: "response", label: "Response", dataType: "object" }, { id: "data", label: "Data", dataType: "any" }]
+   
+5. **sql_query** \u2014 params: { orm: "drizzle"|"prisma"|"raw", query: "SQL string", params?: [] }
+   - inputs: [{ id: "input", label: "Input", dataType: "any", required: false }]
+   - outputs: [{ id: "result", label: "Result", dataType: "array" }]
+   
+6. **redis_cache** \u2014 params: { operation: "get"|"set"|"del", key: "string", value?: "string", ttl?: number }
+   - inputs: [{ id: "input", label: "Input", dataType: "any", required: false }]
+   - outputs: [{ id: "value", label: "Value", dataType: "any" }]
+   
+7. **custom_code** \u2014 params: { code: "TypeScript code", returnVariable?: "string" }
+   - inputs: [{ id: "input", label: "Input", dataType: "any", required: false }]
+   - outputs: [{ id: "result", label: "Result", dataType: "any" }]
+
+#### Logic (category: "logic"):
+8. **if_else** \u2014 params: { condition: "TypeScript expression" }
+   - inputs: [{ id: "input", label: "Input", dataType: "any", required: true }]
+   - outputs: [{ id: "true", label: "True", dataType: "any" }, { id: "false", label: "False", dataType: "any" }]
+   
+9. **for_loop** \u2014 params: { iterableExpression: "string", itemVariable: "string", indexVariable?: "string" }
+   - inputs: [{ id: "iterable", label: "Iterable", dataType: "array", required: true }]
+   - outputs: [{ id: "item", label: "Item", dataType: "any" }, { id: "result", label: "Result", dataType: "array" }]
+   
+10. **try_catch** \u2014 params: { errorVariable: "string" }
+    - inputs: [{ id: "input", label: "Input", dataType: "any", required: true }]
+    - outputs: [{ id: "success", label: "Success", dataType: "any" }, { id: "error", label: "Error", dataType: "object" }]
+    
+11. **promise_all** \u2014 params: {}
+    - 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" }]
+
+#### Variables (category: "variable"):
+12. **declare** \u2014 params: { name: "string", dataType: "FlowDataType", initialValue?: "expression", isConst: boolean }
+    - outputs: [{ id: "value", label: "Value", dataType: "any" }]
+    
+13. **transform** \u2014 params: { expression: "TypeScript expression" }
+    - inputs: [{ id: "input", label: "Input", dataType: "any", required: true }]
+    - outputs: [{ id: "output", label: "Output", dataType: "any" }]
+
+#### Output (category: "output"):
+14. **return_response** \u2014 params: { statusCode: number, bodyExpression: "JS expression string", headers?: {} }
+    - inputs: [{ id: "data", label: "Data", dataType: "any", required: true }]
+
+## Variable Reference System
+- Nodes access previous node's output via: flowState['nodeId']
+- In params like condition or bodyExpression, use: flowState['nodeId'] directly
+- For environment variables in URLs, use: \${ENV_VAR_NAME}
+
+## Rules
+1. There must be EXACTLY ONE trigger node
+2. All node IDs must be unique
+3. Edges must reference valid node IDs and port IDs
+4. No cycles allowed in the graph
+5. STRICT RULE: Every non-trigger node MUST be connected via an edge. For parallel execution branches, you MUST create separate edges connecting the trigger's output to EACH parallel node's input. Do NOT leave any node orphaned!
+6. Use descriptive labels for nodes
+7. Generate sensible default values
+8. For HTTP APIs that receive data, use parseBody: true with POST/PUT/PATCH methods
+9. Always end HTTP flows with a return_response node
+10. Use meaningful nodeId naming like "trigger_1", "fetch_users", "check_auth", "response_ok"
+
+## Output
+Return ONLY valid JSON (no markdown, no explanation). The JSON must conform to the FlowIR schema above.
+`;
+
+// src/server/handlers.ts
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from "fs";
+import { join, dirname, resolve } from "path";
+function handleCompile(body, projectRoot) {
+  try {
+    const ir = body.ir;
+    const shouldWrite = body.write !== false;
+    if (!ir) {
+      return { status: 400, body: { success: false, error: "Missing 'ir' in request body" } };
+    }
+    const result = compile(ir);
+    if (!result.success) {
+      return {
+        status: 400,
+        body: { success: false, error: result.errors?.join("\n") }
+      };
+    }
+    let writtenPath = null;
+    if (shouldWrite && result.filePath && result.code) {
+      const fullPath = resolve(join(projectRoot, result.filePath));
+      if (!fullPath.startsWith(resolve(projectRoot))) {
+        return {
+          status: 400,
+          body: { success: false, error: "Output path escapes project root" }
+        };
+      }
+      const dir = dirname(fullPath);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+      writeFileSync(fullPath, result.code, "utf-8");
+      writtenPath = fullPath;
+      if (result.sourceMap) {
+        const mapPath = fullPath.replace(/\.ts$/, ".flow.map.json");
+        writeFileSync(mapPath, JSON.stringify(result.sourceMap, null, 2), "utf-8");
+      }
+      if (result.dependencies && result.dependencies.all.length > 0) {
+        const pkgPath = join(projectRoot, "package.json");
+        if (existsSync(pkgPath)) {
+          try {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            const installed = /* @__PURE__ */ new Set([
+              ...Object.keys(pkg.dependencies ?? {}),
+              ...Object.keys(pkg.devDependencies ?? {})
+            ]);
+            result.dependencies.missing = result.dependencies.all.filter(
+              (d) => !installed.has(d)
+            );
+          } catch {
+          }
+        }
+      }
+    }
+    return {
+      status: 200,
+      body: {
+        success: true,
+        code: result.code,
+        filePath: result.filePath,
+        writtenTo: writtenPath,
+        dependencies: result.dependencies,
+        sourceMap: result.sourceMap
+      }
+    };
+  } catch (err) {
+    return {
+      status: 500,
+      body: {
+        success: false,
+        error: `Server error: ${err instanceof Error ? err.message : String(err)}`
+      }
+    };
+  }
+}
+async function handleGenerate(body) {
+  try {
+    const { prompt } = body;
+    if (!prompt || typeof prompt !== "string") {
+      return { status: 400, body: { success: false, error: "Missing required 'prompt' string" } };
+    }
+    const apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+      return { status: 500, body: { success: false, error: "OPENAI_API_KEY environment variable is not set" } };
+    }
+    const baseUrl = process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1";
+    const model = process.env.OPENAI_MODEL ?? "gpt-4o-mini";
+    const response = await fetch(`${baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        model,
+        messages: [
+          { role: "system", content: FLOW_IR_SYSTEM_PROMPT },
+          { role: "user", content: prompt }
+        ],
+        temperature: 0.2,
+        response_format: { type: "json_object" }
+      })
+    });
+    if (!response.ok) {
+      const errText = await response.text();
+      return { status: 502, body: { success: false, error: `LLM API error (${response.status}): ${errText}` } };
+    }
+    const data = await response.json();
+    const content = data.choices?.[0]?.message?.content;
+    if (!content) {
+      return { status: 502, body: { success: false, error: "LLM returned empty content" } };
+    }
+    let jsonStr = content;
+    const codeBlockMatch = content.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/);
+    if (codeBlockMatch) jsonStr = codeBlockMatch[1];
+    let ir;
+    try {
+      ir = JSON.parse(jsonStr);
+    } catch {
+      return { status: 422, body: { success: false, error: "Failed to parse LLM JSON response", raw: content } };
+    }
+    const triggerNode = ir.nodes.find((n) => n.category === "trigger");
+    if (triggerNode) {
+      const triggerOutputPortId = triggerNode.outputs?.[0]?.id || "output";
+      const connectedTargetNodeIds = new Set(ir.edges.map((e) => e.targetNodeId));
+      const existingEdgeIds = new Set(ir.edges.map((e) => e.id));
+      let healedCount = 0;
+      ir.nodes.forEach((node) => {
+        if (node.id !== triggerNode.id && !connectedTargetNodeIds.has(node.id) && node.inputs && node.inputs.length > 0) {
+          let edgeId;
+          do {
+            edgeId = `healed_e_${crypto.randomUUID().slice(0, 8)}`;
+          } while (existingEdgeIds.has(edgeId));
+          existingEdgeIds.add(edgeId);
+          ir.edges.push({
+            id: edgeId,
+            sourceNodeId: triggerNode.id,
+            sourcePortId: triggerNode.nodeType === "http_webhook" ? "request" : triggerOutputPortId,
+            targetNodeId: node.id,
+            targetPortId: node.inputs[0].id
+          });
+          healedCount++;
+        }
+      });
+      if (healedCount > 0) {
+        console.warn(`[AutoHeal] Connected ${healedCount} orphaned nodes to trigger.`);
+      }
+    }
+    const validation = validateFlowIR(ir);
+    if (!validation.valid) {
+      return {
+        status: 422,
+        body: { success: false, error: "LLM-generated IR failed validation", validationErrors: validation.errors, raw: ir }
+      };
+    }
+    const security = validateIRSecurity(ir);
+    const securityReport = security.findings.length > 0 ? formatSecurityReport(security) : void 0;
+    return { status: 200, body: { success: true, ir, security: { safe: security.safe, findings: security.findings, report: securityReport } } };
+  } catch (err) {
+    return {
+      status: 500,
+      body: { success: false, error: `Server error: ${err instanceof Error ? err.message : String(err)}` }
+    };
+  }
+}
+function handleImportOpenAPI(body) {
+  try {
+    if (!body.spec) {
+      return { status: 400, body: { error: "Missing 'spec' field in request body" } };
+    }
+    const result = convertOpenAPIToFlowIR(body.spec);
+    let filteredFlows = result.flows;
+    if (body.filter?.paths && Array.isArray(body.filter.paths)) {
+      const paths = body.filter.paths;
+      filteredFlows = filteredFlows.filter(
+        (flow) => paths.some((p) => flow.meta.name.includes(p))
+      );
+    }
+    return {
+      status: 200,
+      body: {
+        success: result.success,
+        flows: filteredFlows,
+        summary: result.summary,
+        errors: result.errors
+      }
+    };
+  } catch (error) {
+    return {
+      status: 500,
+      body: { error: error instanceof Error ? error.message : "Internal Server Error" }
+    };
+  }
+}
+
+// src/server/index.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname2(__filename);
+function resolveStaticDir() {
+  const candidates = [
+    join2(__dirname, "..", "out"),
+    // dist/server.js → ../out (npm package structure)
+    join2(__dirname, "out"),
+    // dist/out/
+    join2(__dirname, "..", "..", "out"),
+    // src/server/index.ts → ../../out (dev)
+    join2(process.cwd(), "out")
+    // fallback: cwd/out
+  ];
+  for (const dir of candidates) {
+    if (existsSync2(join2(dir, "index.html"))) {
+      return dir;
+    }
+  }
+  return candidates[0];
+}
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".map": "application/json",
+  ".txt": "text/plain; charset=utf-8",
+  ".webp": "image/webp"
+};
+var isDev = process.env.NODE_ENV !== "production";
+function setCors(res) {
+  const origin = isDev ? "*" : process.env.CORS_ORIGIN || "";
+  if (!origin) return;
+  res.setHeader("Access-Control-Allow-Origin", origin);
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+}
+function setSecurityHeaders(res) {
+  const csp = isDev ? [
+    "default-src 'self'",
+    "script-src 'self' 'unsafe-inline' 'unsafe-eval'",
+    "style-src 'self' 'unsafe-inline'",
+    "img-src 'self' data: blob:",
+    "font-src 'self' data:",
+    "connect-src 'self' *",
+    "frame-ancestors 'self'",
+    "form-action 'self'",
+    "base-uri 'self'"
+  ].join("; ") : [
+    "default-src 'self'",
+    "script-src 'self'",
+    "style-src 'self' 'unsafe-inline'",
+    "img-src 'self' data: blob:",
+    "font-src 'self' data:",
+    "connect-src 'self'",
+    "frame-ancestors 'self'",
+    "form-action 'self'",
+    "base-uri 'self'"
+  ].join("; ");
+  res.setHeader("Content-Security-Policy", csp);
+  res.setHeader("X-Content-Type-Options", "nosniff");
+  res.setHeader("X-Frame-Options", "SAMEORIGIN");
+  res.setHeader("X-XSS-Protection", "1; mode=block");
+  res.setHeader("Referrer-Policy", "strict-origin-when-cross-origin");
+}
+function sendJson(res, status, body) {
+  res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
+  res.end(JSON.stringify(body));
+}
+var MAX_BODY_SIZE = 2 * 1024 * 1024;
+async function readBody(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    let totalSize = 0;
+    req.on("data", (chunk) => {
+      totalSize += chunk.length;
+      if (totalSize > MAX_BODY_SIZE) {
+        req.destroy();
+        reject(new Error(`Body too large (max ${MAX_BODY_SIZE / 1024 / 1024} MB)`));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve2(Buffer.concat(chunks).toString("utf-8")));
+    req.on("error", reject);
+  });
+}
+async function parseJsonBody(req) {
+  const raw = await readBody(req);
+  return JSON.parse(raw);
+}
+async function serveStatic(staticDir, pathname, res) {
+  let filePath = join2(staticDir, pathname === "/" ? "index.html" : pathname);
+  if (!extname(filePath)) {
+    filePath += ".html";
+  }
+  try {
+    const s = await stat(filePath);
+    if (!s.isFile()) return false;
+    const ext = extname(filePath).toLowerCase();
+    const contentType = MIME_TYPES[ext] || "application/octet-stream";
+    const content = await readFile(filePath);
+    res.writeHead(200, { "Content-Type": contentType });
+    res.end(content);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function handleRequest(req, res, staticDir, projectRoot) {
+  setCors(res);
+  setSecurityHeaders(res);
+  const { method } = req;
+  const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+  const pathname = url.pathname;
+  if (method === "OPTIONS") {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+  if (pathname.startsWith("/api/")) {
+    if (method !== "POST") {
+      sendJson(res, 405, { error: "Method Not Allowed" });
+      return;
+    }
+    let body;
+    try {
+      const contentType = req.headers["content-type"] || "";
+      if (!contentType.includes("application/json")) {
+        sendJson(res, 415, { error: "Content-Type must be application/json" });
+        return;
+      }
+      body = await parseJsonBody(req);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Invalid JSON body";
+      sendJson(res, 400, { error: msg });
+      return;
+    }
+    if (pathname === "/api/compile") {
+      const result = handleCompile(body, projectRoot);
+      sendJson(res, result.status, result.body);
+      return;
+    }
+    if (pathname === "/api/generate") {
+      const result = await handleGenerate(body);
+      sendJson(res, result.status, result.body);
+      return;
+    }
+    if (pathname === "/api/import-openapi") {
+      const result = handleImportOpenAPI(body);
+      sendJson(res, result.status, result.body);
+      return;
+    }
+    sendJson(res, 404, { error: `Unknown API route: ${pathname}` });
+    return;
+  }
+  const served = await serveStatic(staticDir, pathname, res);
+  if (served) return;
+  const indexPath = join2(staticDir, "index.html");
+  try {
+    const content = await readFile(indexPath, "utf-8");
+    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+    res.end(content);
+  } catch {
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("404 Not Found \u2014 UI has not been built yet, please run pnpm build:ui first");
+  }
+}
+function startServer(options = {}) {
+  const port = options.port ?? (Number(process.env.PORT) || 3100);
+  const host = options.host ?? "0.0.0.0";
+  const staticDir = options.staticDir ?? resolveStaticDir();
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const server = createServer((req, res) => {
+    handleRequest(req, res, staticDir, projectRoot).catch((err) => {
+      console.error("[flow2code] Internal error:", err);
+      res.writeHead(500, { "Content-Type": "text/plain" });
+      res.end("Internal Server Error");
+    });
+  });
+  server.listen(port, host, () => {
+    const url = `http://localhost:${port}`;
+    if (options.onReady) {
+      options.onReady(url);
+    } else {
+      console.log(`
+  \u{1F680} Flow2Code Dev Server`);
+      console.log(`  \u251C\u2500 Local:   ${url}`);
+      console.log(`  \u251C\u2500 API:     ${url}/api/compile`);
+      console.log(`  \u251C\u2500 Static:  ${staticDir}`);
+      console.log(`  \u2514\u2500 Project: ${projectRoot}
+`);
+    }
+  });
+  return server;
+}
+export {
+  handleCompile,
+  handleGenerate,
+  handleImportOpenAPI,
+  startServer
+};
+//# sourceMappingURL=server.js.map