@bobtail.software/b-durable 1.0.4 → 1.0.5

package/dist/compiler/cli.mjs

@@ -1,58 +1,721 @@
 #!/usr/bin/env node
-import R from"path";import{existsSync as L,mkdirSync as K,rmSync as _}from"fs";import b from"path";import*as k from"prettier";import{Node as g,Project as z,SyntaxKind as E,ts as B,VariableDeclarationKind as M}from"ts-morph";var U="bDurable",A=B.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope|B.TypeFormatFlags.NoTruncation;async function H(e){let t=e.getFilePath(),s=e.getFullText(),n=await k.resolveConfig(t),a=await k.format(s,{...n,parser:"typescript"});e.replaceWithText(a)}async function O(e){console.log("Iniciando compilador de workflows duraderos...");let{inputDir:t,outputDir:s,packageName:n}=e,a=new z({tsConfigFilePath:b.resolve(process.cwd(),"tsconfig.json")}),i=a.addSourceFilesAtPaths(`${t}/**/*.ts`);L(s)&&(console.log(`Limpiando directorio de salida: ${s}`),_(s,{recursive:!0,force:!0})),K(s,{recursive:!0});let S=a.createDirectory(s);console.log(`Encontrados ${i.length} archivos de workflow para procesar.`);let o=[],c=[];for(let l of i){console.log(`
-Procesando archivo: ${l.getBaseName()}`);let r=l.getDescendantsOfKind(E.CallExpression).filter(d=>d.getExpression().getText()===U);if(r.length!==0)for(let d of r){let p=d.getParentIfKind(E.VariableDeclaration);if(!p)continue;let u=p.getName();console.log(`  -> Transformando workflow: ${u}`);let[f]=d.getArguments();if(!g.isObjectLiteralExpression(f))continue;let x=f.getProperty("workflow");if(!x||!g.isPropertyAssignment(x))continue;let m=x.getInitializer();if(!m||!g.isArrowFunction(m))continue;let P=l.getBaseName().replace(/\.ts$/,".compiled.mts"),$=b.join(S.getPath(),P),I=a.createSourceFile($,"",{overwrite:!0});c.push(I),q(u,m,d,I,n),console.log(`  -> Archivo generado: ${b.relative(process.cwd(),$)}`);let y=P;o.push({name:u,importPath:`./${y}`})}}if(o.length>0){let l=b.join(S.getPath(),"index.mts"),r=a.createSourceFile(l,"",{overwrite:!0});c.push(r),r.addStatements(`// Este archivo fue generado autom\xE1ticamente. NO EDITAR MANUALMENTE.
-`),r.addImportDeclaration({isTypeOnly:!0,moduleSpecifier:n,namedImports:["DurableFunction"]});for(let p of o)r.addImportDeclaration({moduleSpecifier:p.importPath,namedImports:[p.name]});r.addExportDeclaration({namedExports:o.map(p=>p.name)}),r.addStatements(`
-`),r.addVariableStatement({declarationKind:M.Const,declarations:[{name:"durableFunctions",type:"Map<string, DurableFunction<any, any>>",initializer:"new Map()"}]});let d=o.map(p=>`durableFunctions.set(${p.name}.name, ${p.name});`);r.addStatements(d),r.addStatements(`
-`),r.addExportAssignment({isExportEquals:!1,expression:"durableFunctions"}),console.log(`
--> Archivo de \xEDndice generado: ${b.basename(l)}`)}console.log(`
-Formateando archivos generados con Prettier...`);for(let l of c)await H(l);await a.save(),console.log(`
-Compilaci\xF3n completada exitosamente.`)}function q(e,t,s,n,a){let i=t.getBody();if(!g.isBlock(i))throw new Error(`El cuerpo del workflow '${e}' debe ser un bloque {}.`);let{clauses:S}=w(i.getStatements(),{step:0,persistedVariables:new Map}),o=t.getReturnType();o.getSymbol()?.getName()==="Promise"&&o.isObject()&&(o=o.getTypeArguments()[0]||o);let c=o.getText(void 0,A),l=new Set,r=t.getSourceFile(),d=s.getTypeArguments(),p=d.length>0?d[0].getText():"unknown";r.getImportDeclarations().forEach(m=>{if(m.getModuleSpecifierValue()===a)return;let h=m.getModuleSpecifierValue();if(h.includes(".workflow")){let y=b.parse(h),T=b.join(y.dir,y.base+".compiled.mts");!T.startsWith(".")&&!b.isAbsolute(T)&&(T="./"+T),h=T.replace(/\\/g,"/")}else h.startsWith(".")&&b.extname(h)===""&&(h+=".mjs");let P=[],$=[];m.getNamedImports().forEach(y=>{let T=y.getName(),F=y.getAliasNode()?.getText(),v=F?`${T} as ${F}`:T,V=(y.getNameNode().getSymbol()?.getAliasedSymbol()??y.getNameNode().getSymbol())?.getDeclarations()??[],j=V.some(D=>g.isEnumDeclaration(D));y.isTypeOnly()||!j&&V.every(D=>g.isInterfaceDeclaration(D)||g.isTypeAliasDeclaration(D))?$.push(v):P.push(v)}),P.length>0&&n.addImportDeclaration({moduleSpecifier:h,namedImports:P}),$.length>0&&n.addImportDeclaration({isTypeOnly:!0,moduleSpecifier:h,namedImports:$});let I=m.getDefaultImport();I&&n.addImportDeclaration({moduleSpecifier:h,defaultImport:I.getText()})}),r.getInterfaces().forEach(m=>{l.add(m.getText().startsWith("export")?m.getText():`export ${m.getText()}`)}),r.getTypeAliases().forEach(m=>{l.add(m.getText().startsWith("export")?m.getText():`export ${m.getText()}`)});let[u]=t.getParameters(),f="";if(u){let m=u.getNameNode().getText();m!=="input"&&(f=`const ${m} = input;`)}n.addImportDeclaration({isTypeOnly:!0,moduleSpecifier:a,namedImports:["DurableFunction","WorkflowContext","Instruction"]}),l.size>0&&(n.addStatements(`
-`),n.addStatements(Array.from(l))),n.addStatements(`
-// Este archivo fue generado autom\xE1ticamente. NO EDITAR MANUALMENTE.
-`);let x=`{
+
+// src/compiler/cli.ts
+import path2 from "path";
+
+// src/compiler/compile.ts
+import { existsSync, mkdirSync, rmSync } from "fs";
+import path from "path";
+import * as prettier from "prettier";
+import {
+  Node,
+  Project,
+  SyntaxKind,
+  ts,
+  VariableDeclarationKind
+} from "ts-morph";
+var DURABLE_WRAPPER_NAME = "bDurable";
+var TYPE_FORMAT_FLAGS = ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | ts.TypeFormatFlags.NoTruncation;
+async function formatSourceFileWithPrettier(sourceFile) {
+  const filePath = sourceFile.getFilePath();
+  const unformattedText = sourceFile.getFullText();
+  const prettierConfig = await prettier.resolveConfig(filePath);
+  const formattedText = await prettier.format(unformattedText, {
+    ...prettierConfig,
+    parser: "typescript"
+  });
+  sourceFile.replaceWithText(formattedText);
+}
+async function compileWorkflows(options) {
+  console.log("Iniciando compilador de workflows duraderos...");
+  const { inputDir, outputDir, packageName } = options;
+  const project = new Project({
+    tsConfigFilePath: path.resolve(process.cwd(), "tsconfig.json")
+  });
+  const sourceFiles = project.addSourceFilesAtPaths(`${inputDir}/**/*.ts`);
+  if (existsSync(outputDir)) {
+    console.log(`Limpiando directorio de salida: ${outputDir}`);
+    rmSync(outputDir, { recursive: true, force: true });
+  }
+  mkdirSync(outputDir, { recursive: true });
+  const compiledDir = project.createDirectory(outputDir);
+  console.log(`Encontrados ${sourceFiles.length} archivos de workflow para procesar.`);
+  const workflowRegistry = [];
+  const generatedFiles = [];
+  for (const sourceFile of sourceFiles) {
+    console.log(`
+Procesando archivo: ${sourceFile.getBaseName()}`);
+    const durableCalls = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).filter((call) => call.getExpression().getText() === DURABLE_WRAPPER_NAME);
+    if (durableCalls.length === 0) continue;
+    for (const call of durableCalls) {
+      const workflowVarDecl = call.getParentIfKind(SyntaxKind.VariableDeclaration);
+      if (!workflowVarDecl) continue;
+      const workflowName = workflowVarDecl.getName();
+      console.log(`  -> Transformando workflow: ${workflowName}`);
+      const [arg] = call.getArguments();
+      if (!Node.isObjectLiteralExpression(arg)) continue;
+      const workflowProperty = arg.getProperty("workflow");
+      if (!workflowProperty || !Node.isPropertyAssignment(workflowProperty)) continue;
+      const workflowFunc = workflowProperty.getInitializer();
+      if (!workflowFunc || !Node.isArrowFunction(workflowFunc)) continue;
+      const originalBaseName = sourceFile.getBaseName();
+      const compiledFileName = originalBaseName.replace(/\.ts$/, ".compiled.mts");
+      const newFilePath = path.join(compiledDir.getPath(), compiledFileName);
+      const newSourceFile = project.createSourceFile(newFilePath, "", {
+        overwrite: true
+      });
+      generatedFiles.push(newSourceFile);
+      transformWorkflowFunction(
+        workflowName,
+        workflowFunc,
+        call,
+        newSourceFile,
+        packageName
+      );
+      console.log(
+        `  -> Archivo generado: ${path.relative(process.cwd(), newFilePath)}`
+      );
+      const importPathName = compiledFileName;
+      workflowRegistry.push({ name: workflowName, importPath: `./${importPathName}` });
+    }
+  }
+  if (workflowRegistry.length > 0) {
+    const indexFilePath = path.join(compiledDir.getPath(), "index.mts");
+    const indexSourceFile = project.createSourceFile(indexFilePath, "", {
+      overwrite: true
+    });
+    generatedFiles.push(indexSourceFile);
+    indexSourceFile.addStatements(
+      "// Este archivo fue generado autom\xE1ticamente. NO EDITAR MANUALMENTE.\n"
+    );
+    indexSourceFile.addImportDeclaration({
+      isTypeOnly: true,
+      moduleSpecifier: packageName,
+      namedImports: ["DurableFunction"]
+    });
+    for (const wf of workflowRegistry) {
+      indexSourceFile.addImportDeclaration({
+        moduleSpecifier: wf.importPath,
+        namedImports: [wf.name]
+      });
+    }
+    indexSourceFile.addExportDeclaration({
+      namedExports: workflowRegistry.map((wf) => wf.name)
+    });
+    indexSourceFile.addStatements("\n");
+    indexSourceFile.addVariableStatement({
+      declarationKind: VariableDeclarationKind.Const,
+      declarations: [
+        {
+          name: "durableFunctions",
+          type: "Map<string, DurableFunction<any, any, any>>",
+          initializer: "new Map()"
+        }
+      ]
+    });
+    const setStatements = workflowRegistry.map(
+      (wf) => `durableFunctions.set(${wf.name}.name, ${wf.name});`
+    );
+    indexSourceFile.addStatements(setStatements);
+    indexSourceFile.addStatements("\n");
+    indexSourceFile.addExportAssignment({
+      isExportEquals: false,
+      expression: "durableFunctions"
+    });
+    console.log(`
+-> Archivo de \xEDndice generado: ${path.basename(indexFilePath)}`);
+  }
+  console.log("\nFormateando archivos generados con Prettier...");
+  for (const file of generatedFiles) {
+    await formatSourceFileWithPrettier(file);
+  }
+  await project.save();
+  console.log("\nCompilaci\xF3n completada exitosamente.");
+}
+function transformWorkflowFunction(workflowName, func, bDurableCall, targetSourceFile, packageName) {
+  const body = func.getBody();
+  if (!Node.isBlock(body)) {
+    throw new Error(`El cuerpo del workflow '${workflowName}' debe ser un bloque {}.`);
+  }
+  const { clauses: caseClauses } = processStatementsRecursive(body.getStatements(), {
+    step: 0,
+    persistedVariables: /* @__PURE__ */ new Map()
+  });
+  let returnTypeNode = func.getReturnType();
+  if (returnTypeNode.getSymbol()?.getName() === "Promise" && returnTypeNode.isObject()) {
+    returnTypeNode = returnTypeNode.getTypeArguments()[0] || returnTypeNode;
+  }
+  const returnType = returnTypeNode.getText(void 0, TYPE_FORMAT_FLAGS);
+  const dependencyStatements = /* @__PURE__ */ new Set();
+  const originalSourceFile = func.getSourceFile();
+  const typeArgs = bDurableCall.getTypeArguments();
+  const paramType = typeArgs.length > 0 ? typeArgs[0].getText() : "unknown";
+  const eventsType = typeArgs.length > 2 ? typeArgs[2].getText() : "Record<string, never>";
+  originalSourceFile.getImportDeclarations().forEach((importDecl) => {
+    if (importDecl.getModuleSpecifierValue() === packageName) return;
+    let moduleSpecifier = importDecl.getModuleSpecifierValue();
+    if (moduleSpecifier.includes(".workflow")) {
+      const parsedPath = path.parse(moduleSpecifier);
+      let joinedPath = path.join(parsedPath.dir, parsedPath.base + ".compiled.mts");
+      if (!joinedPath.startsWith(".") && !path.isAbsolute(joinedPath)) {
+        joinedPath = "./" + joinedPath;
+      }
+      moduleSpecifier = joinedPath.replace(/\\/g, "/");
+    } else if (moduleSpecifier.startsWith(".")) {
+      if (path.extname(moduleSpecifier) === "") {
+        moduleSpecifier += ".mjs";
+      }
+    }
+    const valueImports = [];
+    const typeImports = [];
+    importDecl.getNamedImports().forEach((specifier) => {
+      const name = specifier.getName();
+      const alias = specifier.getAliasNode()?.getText();
+      const importText = alias ? `${name} as ${alias}` : name;
+      const symbol = specifier.getNameNode().getSymbol()?.getAliasedSymbol() ?? specifier.getNameNode().getSymbol();
+      const declarations = symbol?.getDeclarations() ?? [];
+      const isEnum = declarations.some((d) => Node.isEnumDeclaration(d));
+      const isPurelyType = specifier.isTypeOnly() || !isEnum && declarations.every(
+        (d) => Node.isInterfaceDeclaration(d) || Node.isTypeAliasDeclaration(d)
+      );
+      if (isPurelyType) {
+        typeImports.push(importText);
+      } else {
+        valueImports.push(importText);
+      }
+    });
+    if (valueImports.length > 0) {
+      targetSourceFile.addImportDeclaration({
+        moduleSpecifier,
+        namedImports: valueImports
+      });
+    }
+    if (typeImports.length > 0) {
+      targetSourceFile.addImportDeclaration({
+        isTypeOnly: true,
+        moduleSpecifier,
+        namedImports: typeImports
+      });
+    }
+    const defaultImport = importDecl.getDefaultImport();
+    if (defaultImport) {
+      targetSourceFile.addImportDeclaration({
+        moduleSpecifier,
+        defaultImport: defaultImport.getText()
+      });
+    }
+  });
+  originalSourceFile.getInterfaces().forEach((iface) => {
+    dependencyStatements.add(
+      iface.getText().startsWith("export") ? iface.getText() : `export ${iface.getText()}`
+    );
+  });
+  originalSourceFile.getTypeAliases().forEach((typeAlias) => {
+    dependencyStatements.add(
+      typeAlias.getText().startsWith("export") ? typeAlias.getText() : `export ${typeAlias.getText()}`
+    );
+  });
+  const [params] = func.getParameters();
+  let paramAssignment = "";
+  if (params) {
+    const paramName = params.getNameNode().getText();
+    if (paramName !== "input") {
+      paramAssignment = `const ${paramName} = input;`;
+    }
+  }
+  targetSourceFile.addImportDeclaration({
+    isTypeOnly: true,
+    moduleSpecifier: packageName,
+    namedImports: ["DurableFunction", "WorkflowContext", "Instruction"]
+  });
+  if (dependencyStatements.size > 0) {
+    targetSourceFile.addStatements("\n");
+    targetSourceFile.addStatements(Array.from(dependencyStatements));
+  }
+  targetSourceFile.addStatements(
+    "\n// Este archivo fue generado autom\xE1ticamente. NO EDITAR MANUALMENTE.\n"
+  );
+  const initializerObjectString = `{
         __isDurable: true,
-        name: '${e}',
-        async execute(context: WorkflowContext<${p}>): Promise<Instruction<${c}>> {
+        name: '${workflowName}',
+        async execute(context: WorkflowContext<${paramType}>): Promise<Instruction<${returnType}>> {
             const { input, state, result, log, workflowId } = context;
-            ${f}
+            ${paramAssignment}
 			while (true) {
 				switch (context.step) {
-					${S.join(`
-`)}
+					${caseClauses.join("\n")}
 					default:
 						throw new Error(\`Paso desconocido: \${context.step}\`);
 				}
 			}
         }
-    }`;n.addVariableStatement({isExported:!0,declarationKind:M.Const,declarations:[{name:e,type:`DurableFunction<${p}, ${c}>`,initializer:x}]}),n.organizeImports()}function w(e,t){if(e.length===0){let f=[];if(t.pendingStateAssignment){let x=`case ${t.step}: {
-${t.pendingStateAssignment}
+    }`;
+  targetSourceFile.addVariableStatement({
+    isExported: true,
+    declarationKind: VariableDeclarationKind.Const,
+    declarations: [
+      {
+        name: workflowName,
+        type: `DurableFunction<${paramType}, ${returnType}, ${eventsType}>`,
+        initializer: initializerObjectString
+      }
+    ]
+  });
+  targetSourceFile.organizeImports();
+}
+function processStatementsRecursive(statements, initialState) {
+  if (statements.length === 0) {
+    const clauses = [];
+    if (initialState.pendingStateAssignment) {
+      const finalClause = `case ${initialState.step}: {
+${initialState.pendingStateAssignment}
 return { type: 'COMPLETE', result: undefined };
-}`;f.push(x)}return{clauses:f,nextStep:t.step+1}}let{syncBlock:s,durableStatement:n,nextStatements:a}=te(e),{rewrittenSyncStatements:i,newlyPersistedVariables:S}=Y(s,n?[n,...a]:[],t.persistedVariables);t.pendingStateAssignment&&i.unshift(t.pendingStateAssignment);let o=new Map([...t.persistedVariables,...S]);if(!n){let f=i.join(`
-`),m=s.length>0&&g.isReturnStatement(s[s.length-1])?"":`
-return { type: 'COMPLETE', result: undefined };`;return{clauses:[`case ${t.step}: {
-${f}${m}
-}`],nextStep:t.step+1}}if(g.isIfStatement(n))return G(n,a,{...t,persistedVariables:o},i);if(g.isTryStatement(n))return X(n,a,{...t,persistedVariables:o},i);let{instruction:c,nextPendingStateAssignment:l}=Q(n,o);i.push(c);let r=i.join(`
-`),d=`case ${t.step}: {
-${r}
-}`,p={step:t.step+1,persistedVariables:o,pendingStateAssignment:l},u=w(a,p);return{clauses:[d,...u.clauses],nextStep:u.nextStep}}function G(e,t,s,n){let a=C(e.getExpression(),s.persistedVariables),i=e.getThenStatement(),S=g.isBlock(i)?i.getStatements():[i],o=w(S,{step:s.step+1,persistedVariables:new Map(s.persistedVariables)}),c,l=e.getElseStatement();if(l){let x=g.isBlock(l)?l.getStatements():[l];c=w(x,{step:o.nextStep,persistedVariables:new Map(s.persistedVariables)})}let r=c?c.nextStep:o.nextStep,d=w(t,{step:r,persistedVariables:s.persistedVariables}),p=n.join(`
-`),u=o.nextStep;return{clauses:[`
-        case ${s.step}: {
-            ${p}
-            if (${a}) {
-                context.step = ${s.step+1};
+}`;
+      clauses.push(finalClause);
+    }
+    return { clauses, nextStep: initialState.step + 1 };
+  }
+  const { syncBlock, durableStatement, nextStatements } = splitAtNextDurableCall(statements);
+  const { rewrittenSyncStatements, newlyPersistedVariables } = processSyncBlock(
+    syncBlock,
+    durableStatement ? [durableStatement, ...nextStatements] : [],
+    initialState.persistedVariables
+  );
+  if (initialState.pendingStateAssignment) {
+    rewrittenSyncStatements.unshift(initialState.pendingStateAssignment);
+  }
+  const updatedPersistedVariables = new Map([
+    ...initialState.persistedVariables,
+    ...newlyPersistedVariables
+  ]);
+  if (!durableStatement) {
+    const syncCode2 = rewrittenSyncStatements.join("\n");
+    const lastStatementIsReturn = syncBlock.length > 0 && Node.isReturnStatement(syncBlock[syncBlock.length - 1]);
+    const finalInstruction = lastStatementIsReturn ? "" : `
+return { type: 'COMPLETE', result: undefined };`;
+    const clause = `case ${initialState.step}: {
+${syncCode2}${finalInstruction}
+}`;
+    return { clauses: [clause], nextStep: initialState.step + 1 };
+  }
+  if (Node.isIfStatement(durableStatement)) {
+    return processIfStatement(
+      durableStatement,
+      nextStatements,
+      {
+        ...initialState,
+        persistedVariables: updatedPersistedVariables
+      },
+      rewrittenSyncStatements
+    );
+  }
+  if (Node.isTryStatement(durableStatement)) {
+    return processTryStatement(
+      durableStatement,
+      nextStatements,
+      { ...initialState, persistedVariables: updatedPersistedVariables },
+      rewrittenSyncStatements
+    );
+  }
+  const { instruction, nextPendingStateAssignment } = generateDurableInstruction(
+    durableStatement,
+    updatedPersistedVariables
+  );
+  rewrittenSyncStatements.push(instruction);
+  const syncCode = rewrittenSyncStatements.join("\n");
+  const currentClause = `case ${initialState.step}: {
+${syncCode}
+}`;
+  const nextState = {
+    step: initialState.step + 1,
+    persistedVariables: updatedPersistedVariables,
+    pendingStateAssignment: nextPendingStateAssignment
+  };
+  const restResult = processStatementsRecursive(nextStatements, nextState);
+  return {
+    clauses: [currentClause, ...restResult.clauses],
+    nextStep: restResult.nextStep
+  };
+}
+function processIfStatement(ifStatement, followingStatements, currentState, rewrittenSyncStatements) {
+  const condition = rewriteNode(ifStatement.getExpression(), currentState.persistedVariables);
+  const thenBlock = ifStatement.getThenStatement();
+  const thenStatements = Node.isBlock(thenBlock) ? thenBlock.getStatements() : [thenBlock];
+  const thenResult = processStatementsRecursive(thenStatements, {
+    step: currentState.step + 1,
+    persistedVariables: new Map(currentState.persistedVariables)
+    // Clona para aislamiento de ramas
+  });
+  let elseResult;
+  const elseStatement = ifStatement.getElseStatement();
+  if (elseStatement) {
+    const elseStatements = Node.isBlock(elseStatement) ? elseStatement.getStatements() : [elseStatement];
+    elseResult = processStatementsRecursive(elseStatements, {
+      step: thenResult.nextStep,
+      // La rama 'else' comienza donde termina la 'then'
+      persistedVariables: new Map(currentState.persistedVariables)
+    });
+  }
+  const nextStepAfterIf = elseResult ? elseResult.nextStep : thenResult.nextStep;
+  const afterIfResult = processStatementsRecursive(followingStatements, {
+    step: nextStepAfterIf,
+    persistedVariables: currentState.persistedVariables
+    // Usa el mapa original
+  });
+  const syncCode = rewrittenSyncStatements.join("\n");
+  const jumpToElseStep = thenResult.nextStep;
+  const ifClause = `
+        case ${currentState.step}: {
+            ${syncCode}
+            if (${condition}) {
+                context.step = ${currentState.step + 1};
             } else {
-                ${l?`context.step = ${u};`:`context.step = ${r};`}
+                ${elseStatement ? `context.step = ${jumpToElseStep};` : `context.step = ${nextStepAfterIf};`}
             }
 			break;
         }
-    `,...o.clauses,...c?c.clauses:[],...d.clauses],nextStep:d.nextStep}}function X(e,t,s,n){let{step:a,persistedVariables:i}=s,S=e.getTryBlock(),o=e.getCatchClause(),c=e.getFinallyBlock(),l=w(S.getStatements(),{step:a+1,persistedVariables:new Map(i)}),r,d,p=l.nextStep;if(o){let y=o.getBlock(),T=o.getVariableDeclaration();T&&(d=T.getName()),r=w(y.getStatements(),{step:p,persistedVariables:new Map(i)})}let u,f=r?r.nextStep:p;c&&(u=w(c.getStatements(),{step:f,persistedVariables:new Map(i)}));let x=u?u.nextStep:f,m=w(t,{step:x,persistedVariables:i}),h=`{ catchStep: ${o?p:"undefined"}, finallyStep: ${c?f:"undefined"} }`,P=`
-        case ${a}: {
-            ${n.join(`
-`)}
+    `;
+  return {
+    clauses: [
+      ifClause,
+      ...thenResult.clauses,
+      ...elseResult ? elseResult.clauses : [],
+      ...afterIfResult.clauses
+    ],
+    nextStep: afterIfResult.nextStep
+  };
+}
+function processTryStatement(tryStatement, followingStatements, currentState, rewrittenSyncStatements) {
+  const { step, persistedVariables } = currentState;
+  const tryBlock = tryStatement.getTryBlock();
+  const catchClause = tryStatement.getCatchClause();
+  const finallyBlock = tryStatement.getFinallyBlock();
+  const tryResult = processStatementsRecursive(tryBlock.getStatements(), {
+    step: step + 1,
+    // El bloque try comienza en el siguiente step
+    persistedVariables: new Map(persistedVariables)
+  });
+  let catchResult;
+  let catchVarName;
+  const catchStep = tryResult.nextStep;
+  if (catchClause) {
+    const catchBlock = catchClause.getBlock();
+    const varDeclaration = catchClause.getVariableDeclaration();
+    if (varDeclaration) {
+      catchVarName = varDeclaration.getName();
+    }
+    catchResult = processStatementsRecursive(catchBlock.getStatements(), {
+      step: catchStep,
+      persistedVariables: new Map(persistedVariables)
+    });
+  }
+  let finallyResult;
+  const finallyStep = catchResult ? catchResult.nextStep : catchStep;
+  if (finallyBlock) {
+    finallyResult = processStatementsRecursive(finallyBlock.getStatements(), {
+      step: finallyStep,
+      persistedVariables: new Map(persistedVariables)
+    });
+  }
+  const endStep = finallyResult ? finallyResult.nextStep : finallyStep;
+  const afterTryResult = processStatementsRecursive(followingStatements, {
+    step: endStep,
+    persistedVariables
+  });
+  const handler = `{ catchStep: ${catchClause ? catchStep : "undefined"}, finallyStep: ${finallyBlock ? finallyStep : "undefined"} }`;
+  const pushClause = `
+        case ${step}: {
+            ${rewrittenSyncStatements.join("\n")}
             state.tryCatchStack = state.tryCatchStack || [];
-            state.tryCatchStack.push(${h});
-            context.step = ${a+1}; // Salta al inicio del bloque try
+            state.tryCatchStack.push(${handler});
+            context.step = ${step + 1}; // Salta al inicio del bloque try
             break;
         }
-    `,$=l.clauses.pop()||"",I=c?f:x;if(l.clauses.push($.replace(/return { type: 'COMPLETE'.* };/,`context.step = ${I}; break;`)),r){if(d){let T=r.clauses[0]||`case ${p}: {}`;r.clauses[0]=T.replace("{",`{
-const ${d} = result as Error;`)}let y=r.clauses.pop()||"";r.clauses.push(y.replace(/return { type: 'COMPLETE'.* };/,`context.step = ${I}; break;`))}if(u){let y=u.clauses.pop()||"";u.clauses.push(y.replace(/return { type: 'COMPLETE'.* };/,`state.tryCatchStack?.pop(); context.step = ${x}; break;`))}return{clauses:[P,...l.clauses,...r?r.clauses:[],...u?u.clauses:[],...m.clauses],nextStep:m.nextStep}}function Y(e,t,s){let n=[],a=new Map,i=Z(t),S=new Map(s);for(let o of e){let c=!1;if(g.isVariableStatement(o))for(let l of o.getDeclarations()){let r=l.getInitializer();if(!r)continue;let d=J(l),p=d.filter(u=>i.has(u.name));if(p.length>0){let u=C(r,s);for(let{name:f,type:x}of p){a.set(f,{type:x}),S.set(f,{type:x});let m=d.length>1?`${u}.${f}`:u;n.push(`state.${f} = ${m};`)}p.length===d.length&&(c=!0)}}c||n.push(C(o,S))}return{rewrittenSyncStatements:n,newlyPersistedVariables:a}}function J(e){let t=e.getNameNode(),s=[];if(g.isIdentifier(t)){let n=e.getType().getText(e,A);s.push({name:t.getText(),type:n})}else if(g.isObjectBindingPattern(t))for(let n of t.getElements()){let a=n.getName(),i=n.getType().getText(n,A);s.push({name:a,type:i})}return s}function Q(e,t){if(g.isReturnStatement(e))return{instruction:`return { type: 'COMPLETE', result: ${e.getExpression()?C(e.getExpressionOrThrow(),t):"undefined"} };`,nextPendingStateAssignment:void 0};let s,n=e.getFirstDescendantByKind(E.VariableDeclaration);if(n){let i=n.getName(),S=n.getType().getText(n,A);t.set(i,{type:S}),s=`state.${i} = result;`}let a=e.getFirstDescendantByKind(E.AwaitExpression);if(a){let i=a.getExpression();if(g.isCallExpression(i))return{instruction:`return ${ee(i,t)};`,nextPendingStateAssignment:s}}return{instruction:C(e,t),nextPendingStateAssignment:s}}function Z(e){let t=new Set;for(let s of e)s.getDescendantsOfKind(E.Identifier).forEach(n=>{t.add(n.getText())});return t}function C(e,t){let s=e.getProject().createSourceFile(`temp_rewrite_${Math.random()}.ts`,`const temp = ${e.getText()};`,{overwrite:!0}),n=s.getVariableDeclarationOrThrow("temp").getInitializerOrThrow(),a=[n,...n.getDescendants()].reverse();for(let c of a)if(g.isIdentifier(c)&&!c.wasForgotten()&&t.has(c.getText())){let l=c.getText(),r=c.getParent(),d=g.isVariableDeclaration(r)&&r.getNameNode()===c,p=g.isPropertyAccessExpression(r)&&r.getNameNode()===c||g.isPropertyAssignment(r)&&r.getNameNode()===c,u=g.isBindingElement(r)&&r.getNameNode()===c;if(!d&&!p&&!u){let f=t.get(l);c.replaceWithText(`(state.${l} as ${f.type})`)}}let i=s.getFullText().trim();s.forget();let S="const temp = ",o=i;return o.startsWith(S)&&(o=o.substring(S.length)),o.endsWith(";")&&(o=o.slice(0,-1)),o}function ee(e,t){let s=e.getExpression(),n,a=!1;g.isPropertyAccessExpression(s)?(s.getExpression().getText()==="context"&&(a=!0),n=s.getName()):n=s.getText();let i=e.getArguments().map(r=>C(r,t)).join(", ");if(a){if(n==="bSleep")return`{ type: 'SCHEDULE_SLEEP', duration: ${i} }`;if(n==="bWaitForEvent")return`{ type: 'WAIT_FOR_EVENT', eventName: ${i} }`;if(n==="bExecute"){let[r,d]=e.getArguments(),p=r.getText(),u=d?C(d,t):"undefined";return`{ type: 'EXECUTE_SUBWORKFLOW', workflowName: ${p}.name, input: ${u} }`}throw new Error(`Funci\xF3n de contexto durable desconocida: '${n}'.`)}let S=s.getSymbol();if(!S)throw new Error(`S\xEDmbolo no encontrado para '${n}'.`);let o=S.getDeclarations()[0]?.asKind(E.ImportSpecifier);if(!o)throw new Error(`'${n}' debe ser importada.`);let c=o.getImportDeclaration().getModuleSpecifierSourceFileOrThrow();return`{ type: 'SCHEDULE_TASK', modulePath: '${b.relative(process.cwd(),c.getFilePath()).replace(/\\/g,"/")}', exportName: '${n}', args: [${i}] }`}function N(e){for(let t of e.getDescendantsOfKind(E.AwaitExpression)){let s=t.getExpressionIfKind(E.CallExpression);if(s){let n=s.getExpression();if(g.isPropertyAccessExpression(n)){let a=n.getName();if(n.getExpression().getText()==="context"&&(a==="bSleep"||a==="bWaitForEvent"||a==="bExecute")||n.getSymbol()?.getDeclarations()[0]?.isKind(E.ImportSpecifier))return!0}else if(n.getSymbol()?.getDeclarations()[0]?.isKind(E.ImportSpecifier))return!0}}if(g.isTryStatement(e)&&(N(e.getTryBlock())||e.getCatchClause()&&N(e.getCatchClause().getBlock())||e.getFinallyBlock()&&N(e.getFinallyBlock())))return!0;if(g.isIfStatement(e)){let t=N(e.getThenStatement()),s=e.getElseStatement()?N(e.getElseStatement()):!1;return t||s}return g.isBlock(e)?e.getStatements().some(N):!1}function te(e){for(let t=0;t<e.length;t++){let s=e[t];if(g.isReturnStatement(s)||N(s)||g.isTryStatement(s))return{syncBlock:e.slice(0,t),durableStatement:s,nextStatements:e.slice(t+1)}}return{syncBlock:e,durableStatement:null,nextStatements:[]}}var W=e=>{let t=process.argv.indexOf(e);if(t!==-1&&process.argv.length>t+1)return process.argv[t+1]};async function ne(){let e=W("--in"),t=W("--out");(!e||!t)&&(console.error("Uso: b-durable-compiler --in <directorio_entrada> --out <directorio_salida>"),process.exit(1));let s=R.resolve(process.cwd(),e),n=R.resolve(process.cwd(),t);await O({inputDir:s,outputDir:n,packageName:"@bobtail.software/b-durable"})}ne().catch(e=>{console.error("Error durante la compilaci\xF3n:",e),process.exit(1)});
+    `;
+  const lastTryClause = tryResult.clauses.pop() || "";
+  const jumpToAfterTryStep = finallyBlock ? finallyStep : endStep;
+  tryResult.clauses.push(
+    lastTryClause.replace(
+      /return { type: 'COMPLETE'.* };/,
+      `context.step = ${jumpToAfterTryStep}; break;`
+    )
+  );
+  if (catchResult) {
+    if (catchVarName) {
+      const firstCatchClause = catchResult.clauses[0] || `case ${catchStep}: {}`;
+      catchResult.clauses[0] = firstCatchClause.replace(
+        "{",
+        `{
+const ${catchVarName} = result as Error;`
+      );
+    }
+    const lastCatchClause = catchResult.clauses.pop() || "";
+    catchResult.clauses.push(
+      lastCatchClause.replace(
+        /return { type: 'COMPLETE'.* };/,
+        `context.step = ${jumpToAfterTryStep}; break;`
+      )
+    );
+  }
+  if (finallyResult) {
+    const lastFinallyClause = finallyResult.clauses.pop() || "";
+    finallyResult.clauses.push(
+      lastFinallyClause.replace(
+        /return { type: 'COMPLETE'.* };/,
+        `state.tryCatchStack?.pop(); context.step = ${endStep}; break;`
+      )
+    );
+  }
+  return {
+    clauses: [
+      pushClause,
+      ...tryResult.clauses,
+      ...catchResult ? catchResult.clauses : [],
+      ...finallyResult ? finallyResult.clauses : [],
+      ...afterTryResult.clauses
+    ],
+    nextStep: afterTryResult.nextStep
+  };
+}
+function processSyncBlock(syncBlock, followingStatements, persistedVariables) {
+  const rewrittenSyncStatements = [];
+  const newlyPersistedVariables = /* @__PURE__ */ new Map();
+  const usedLaterIdentifiers = findUsedIdentifiers(followingStatements);
+  const currentPersistedVars = new Map(persistedVariables);
+  for (const statement of syncBlock) {
+    let handledAsStatePersistence = false;
+    if (Node.isVariableStatement(statement)) {
+      for (const decl of statement.getDeclarations()) {
+        const initializer = decl.getInitializer();
+        if (!initializer) continue;
+        const varInfos = getVarInfoFromDeclaration(decl);
+        const varsToPersist = varInfos.filter(
+          (v) => usedLaterIdentifiers.has(v.name)
+        );
+        if (varsToPersist.length > 0) {
+          const rewrittenInitializer = rewriteNode(
+            initializer,
+            persistedVariables
+          );
+          for (const { name, type } of varsToPersist) {
+            newlyPersistedVariables.set(name, { type });
+            currentPersistedVars.set(name, { type });
+            const assignmentRightHand = varInfos.length > 1 ? `${rewrittenInitializer}.${name}` : rewrittenInitializer;
+            rewrittenSyncStatements.push(
+              `state.${name} = ${assignmentRightHand};`
+            );
+          }
+          if (varsToPersist.length === varInfos.length) {
+            handledAsStatePersistence = true;
+          }
+        }
+      }
+    }
+    if (!handledAsStatePersistence) {
+      rewrittenSyncStatements.push(rewriteNode(statement, currentPersistedVars));
+    }
+  }
+  return { rewrittenSyncStatements, newlyPersistedVariables };
+}
+function getVarInfoFromDeclaration(decl) {
+  const nameNode = decl.getNameNode();
+  const result = [];
+  if (Node.isIdentifier(nameNode)) {
+    const type = decl.getType().getText(decl, TYPE_FORMAT_FLAGS);
+    result.push({ name: nameNode.getText(), type });
+  } else if (Node.isObjectBindingPattern(nameNode)) {
+    for (const element of nameNode.getElements()) {
+      const name = element.getName();
+      const type = element.getType().getText(element, TYPE_FORMAT_FLAGS);
+      result.push({ name, type });
+    }
+  }
+  return result;
+}
+function generateDurableInstruction(statement, persistedVariables) {
+  if (Node.isReturnStatement(statement)) {
+    const returnExpr = statement.getExpression() ? rewriteNode(statement.getExpressionOrThrow(), persistedVariables) : "undefined";
+    return {
+      instruction: `return { type: 'COMPLETE', result: ${returnExpr} };`,
+      nextPendingStateAssignment: void 0
+    };
+  }
+  let nextPendingStateAssignment = void 0;
+  const varDecl = statement.getFirstDescendantByKind(SyntaxKind.VariableDeclaration);
+  if (varDecl) {
+    const varName = varDecl.getName();
+    const varType = varDecl.getType().getText(varDecl, TYPE_FORMAT_FLAGS);
+    persistedVariables.set(varName, { type: varType });
+    nextPendingStateAssignment = `state.${varName} = result;`;
+  }
+  const awaitExpression = statement.getFirstDescendantByKind(SyntaxKind.AwaitExpression);
+  if (awaitExpression) {
+    const callExpr = awaitExpression.getExpression();
+    if (Node.isCallExpression(callExpr)) {
+      return {
+        instruction: `return ${createInstructionForCall(callExpr, persistedVariables)};`,
+        nextPendingStateAssignment
+      };
+    }
+  }
+  return {
+    instruction: rewriteNode(statement, persistedVariables),
+    nextPendingStateAssignment
+  };
+}
+function findUsedIdentifiers(nodes) {
+  const identifiers = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    node.getDescendantsOfKind(SyntaxKind.Identifier).forEach((ident) => {
+      identifiers.add(ident.getText());
+    });
+  }
+  return identifiers;
+}
+function rewriteNode(node, persistedVariables) {
+  const tempSourceFile = node.getProject().createSourceFile(
+    `temp_rewrite_${Math.random()}.ts`,
+    `const temp = ${node.getText()};`,
+    // Se envuelve para asegurar que sea un AST válido
+    { overwrite: true }
+  );
+  const nodeClone = tempSourceFile.getVariableDeclarationOrThrow("temp").getInitializerOrThrow();
+  const descendants = [nodeClone, ...nodeClone.getDescendants()].reverse();
+  for (const currentNode of descendants) {
+    if (Node.isIdentifier(currentNode) && !currentNode.wasForgotten() && persistedVariables.has(currentNode.getText())) {
+      const varName = currentNode.getText();
+      const parent = currentNode.getParent();
+      const isDeclaration = Node.isVariableDeclaration(parent) && parent.getNameNode() === currentNode;
+      const isProperty = Node.isPropertyAccessExpression(parent) && parent.getNameNode() === currentNode || Node.isPropertyAssignment(parent) && parent.getNameNode() === currentNode;
+      const isBindingElement = Node.isBindingElement(parent) && parent.getNameNode() === currentNode;
+      if (!isDeclaration && !isProperty && !isBindingElement) {
+        const typeInfo = persistedVariables.get(varName);
+        currentNode.replaceWithText(`(state.${varName} as ${typeInfo.type})`);
+      }
+    }
+  }
+  const fullText = tempSourceFile.getFullText().trim();
+  tempSourceFile.forget();
+  const prefix = "const temp = ";
+  let newText = fullText;
+  if (newText.startsWith(prefix)) {
+    newText = newText.substring(prefix.length);
+  }
+  if (newText.endsWith(";")) {
+    newText = newText.slice(0, -1);
+  }
+  return newText;
+}
+function createInstructionForCall(callExpr, persistedVariables) {
+  const identifier = callExpr.getExpression();
+  let functionName;
+  let isContextCall = false;
+  if (Node.isPropertyAccessExpression(identifier)) {
+    const expr = identifier.getExpression();
+    if (expr.getText() === "context") {
+      isContextCall = true;
+    }
+    functionName = identifier.getName();
+  } else {
+    functionName = identifier.getText();
+  }
+  const args = callExpr.getArguments().map((arg) => rewriteNode(arg, persistedVariables)).join(", ");
+  if (isContextCall) {
+    if (functionName === "bSleep") {
+      return `{ type: 'SCHEDULE_SLEEP', duration: ${args} }`;
+    }
+    if (functionName === "bWaitForEvent") {
+      return `{ type: 'WAIT_FOR_EVENT', eventName: ${args} }`;
+    }
+    if (functionName === "bExecute") {
+      const [workflowArg, inputArg] = callExpr.getArguments();
+      const subWorkflowName = workflowArg.getText();
+      const subWorkflowInput = inputArg ? rewriteNode(inputArg, persistedVariables) : "undefined";
+      return `{ type: 'EXECUTE_SUBWORKFLOW', workflowName: ${subWorkflowName}.name, input: ${subWorkflowInput} }`;
+    }
+    throw new Error(`Funci\xF3n de contexto durable desconocida: '${functionName}'.`);
+  }
+  const symbol = identifier.getSymbol();
+  if (!symbol) throw new Error(`S\xEDmbolo no encontrado para '${functionName}'.`);
+  const importSpecifier = symbol.getDeclarations()[0]?.asKind(SyntaxKind.ImportSpecifier);
+  if (!importSpecifier) throw new Error(`'${functionName}' debe ser importada.`);
+  const sourceFile = importSpecifier.getImportDeclaration().getModuleSpecifierSourceFileOrThrow();
+  const relativeSourcePath = path.relative(process.cwd(), sourceFile.getFilePath()).replace(/\\/g, "/");
+  return `{ type: 'SCHEDULE_TASK', modulePath: '${relativeSourcePath}', exportName: '${functionName}', args: [${args}] }`;
+}
+function hasDurableCall(node) {
+  for (const awaitExpr of node.getDescendantsOfKind(SyntaxKind.AwaitExpression)) {
+    const callExpr = awaitExpr.getExpressionIfKind(SyntaxKind.CallExpression);
+    if (callExpr) {
+      const expression = callExpr.getExpression();
+      if (Node.isPropertyAccessExpression(expression)) {
+        const propName = expression.getName();
+        if (expression.getExpression().getText() === "context" && (propName === "bSleep" || propName === "bWaitForEvent" || propName === "bExecute") || expression.getSymbol()?.getDeclarations()[0]?.isKind(SyntaxKind.ImportSpecifier)) {
+          return true;
+        }
+      } else {
+        if (expression.getSymbol()?.getDeclarations()[0]?.isKind(SyntaxKind.ImportSpecifier)) {
+          return true;
+        }
+      }
+    }
+  }
+  if (Node.isTryStatement(node)) {
+    if (hasDurableCall(node.getTryBlock())) return true;
+    if (node.getCatchClause() && hasDurableCall(node.getCatchClause().getBlock()))
+      return true;
+    if (node.getFinallyBlock() && hasDurableCall(node.getFinallyBlock())) return true;
+  }
+  if (Node.isIfStatement(node)) {
+    const thenHas = hasDurableCall(node.getThenStatement());
+    const elseHas = node.getElseStatement() ? hasDurableCall(node.getElseStatement()) : false;
+    return thenHas || elseHas;
+  }
+  if (Node.isBlock(node)) {
+    return node.getStatements().some(hasDurableCall);
+  }
+  return false;
+}
+function splitAtNextDurableCall(statements) {
+  for (let i = 0; i < statements.length; i++) {
+    const statement = statements[i];
+    if (Node.isReturnStatement(statement) || hasDurableCall(statement) || Node.isTryStatement(statement)) {
+      return {
+        syncBlock: statements.slice(0, i),
+        durableStatement: statement,
+        nextStatements: statements.slice(i + 1)
+      };
+    }
+  }
+  return { syncBlock: statements, durableStatement: null, nextStatements: [] };
+}
+
+// src/compiler/cli.ts
+var getArg = (name) => {
+  const argIndex = process.argv.indexOf(name);
+  if (argIndex !== -1 && process.argv.length > argIndex + 1) {
+    return process.argv[argIndex + 1];
+  }
+  return void 0;
+};
+async function run() {
+  const inputDir = getArg("--in");
+  const outputDir = getArg("--out");
+  if (!inputDir || !outputDir) {
+    console.error(
+      "Uso: b-durable-compiler --in <directorio_entrada> --out <directorio_salida>"
+    );
+    process.exit(1);
+  }
+  const absInput = path2.resolve(process.cwd(), inputDir);
+  const absOutput = path2.resolve(process.cwd(), outputDir);
+  await compileWorkflows({
+    inputDir: absInput,
+    outputDir: absOutput,
+    packageName: "@bobtail.software/b-durable"
+  });
+}
+run().catch((error) => {
+  console.error("Error durante la compilaci\xF3n:", error);
+  process.exit(1);
+});