@bobtail.software/b-durable 1.0.5 → 1.0.6

package/dist/compiler/cli.mjs

@@ -1,721 +1,59 @@
 #!/usr/bin/env node
-
-// 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 = `{
+import z from"path";import{existsSync as q,mkdirSync as G,rmSync as X}from"fs";import h from"path";import*as R from"prettier";import{Node as p,Project as Y,SyntaxKind as b,ts as W,VariableDeclarationKind as K}from"ts-morph";var J="bDurable",F=W.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope|W.TypeFormatFlags.NoTruncation;async function Q(e){let t=e.getFilePath(),s=e.getFullText(),n=await R.resolveConfig(t),o=await R.format(s,{...n,parser:"typescript"});e.replaceWithText(o)}async function _(e){console.log("Iniciando compilador de workflows duraderos...");let{inputDir:t,outputDir:s,packageName:n}=e,o=new Y({tsConfigFilePath:h.resolve(process.cwd(),"tsconfig.json")}),i=o.addSourceFilesAtPaths(`${t}/**/*.ts`);q(s)&&(console.log(`Limpiando directorio de salida: ${s}`),X(s,{recursive:!0,force:!0})),G(s,{recursive:!0});let f=o.createDirectory(s);console.log(`Encontrados ${i.length} archivos de workflow para procesar.`);let a=[],c=[];for(let u of i){console.log(`
+Procesando archivo: ${u.getBaseName()}`);let r=u.getDescendantsOfKind(b.CallExpression).filter(g=>g.getExpression().getText()===J);if(r.length!==0)for(let g of r){let l=g.getParentIfKind(b.VariableDeclaration);if(!l)continue;let d=l.getName();console.log(`  -> Transformando workflow: ${d}`);let[m]=g.getArguments();if(!p.isObjectLiteralExpression(m))continue;let y=m.getProperty("workflow");if(!y||!p.isPropertyAssignment(y))continue;let x=y.getInitializer();if(!x||!p.isArrowFunction(x))continue;let N=u.getBaseName().replace(/\.ts$/,".compiled.mts"),A=h.join(f.getPath(),N),D=o.createSourceFile(A,"",{overwrite:!0});c.push(D),Z(d,x,g,D,n),console.log(`  -> Archivo generado: ${h.relative(process.cwd(),A)}`);let w=N;a.push({name:d,importPath:`./${w}`})}}if(a.length>0){let u=h.join(f.getPath(),"index.mts"),r=o.createSourceFile(u,"",{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 l of a)r.addImportDeclaration({moduleSpecifier:l.importPath,namedImports:[l.name]});r.addExportDeclaration({namedExports:a.map(l=>l.name)}),r.addStatements(`
+`),r.addVariableStatement({declarationKind:K.Const,declarations:[{name:"durableFunctions",type:"Map<string, DurableFunction<any, any, any, any>>",initializer:"new Map()"}]});let g=a.map(l=>`durableFunctions.set(${l.name}.name, ${l.name});`);r.addStatements(g),r.addStatements(`
+`),r.addExportAssignment({isExportEquals:!1,expression:"durableFunctions"}),console.log(`
+-> Archivo de \xEDndice generado: ${h.basename(u)}`)}console.log(`
+Formateando archivos generados con Prettier...`);for(let u of c)await Q(u);await o.save(),console.log(`
+Compilaci\xF3n completada exitosamente.`)}function Z(e,t,s,n,o){let i=t.getBody();if(!p.isBlock(i))throw new Error(`El cuerpo del workflow '${e}' debe ser un bloque {}.`);let[f]=s.getArguments();if(!p.isObjectLiteralExpression(f))throw new Error("El argumento de bDurable debe ser un objeto.");let a=f.getProperty("version");if(!a||!p.isPropertyAssignment(a))throw new Error(`El workflow '${e}' debe tener una propiedad 'version'.`);let c=a.getInitializer();if(!c||!p.isStringLiteral(c))throw new Error(`La versi\xF3n del workflow '${e}' debe ser un string literal.`);let{clauses:u}=T(i.getStatements(),{step:0,persistedVariables:new Map}),r=t.getReturnType();r.getSymbol()?.getName()==="Promise"&&r.isObject()&&(r=r.getTypeArguments()[0]||r);let g=r.getText(void 0,F),l=new Set,d=t.getSourceFile(),m=s.getTypeArguments(),y=m.length>0?m[0].getText():"unknown",x=m.length>2?m[2].getText():"Record<string, never>",k=m.length>3?m[3].getText():"Record<string, never>";d.getImportDeclarations().forEach(S=>{if(S.getModuleSpecifierValue()===o)return;let E=S.getModuleSpecifierValue();if(E.includes(".workflow")){let $=h.parse(E),P=h.join($.dir,$.base+".compiled.mts");!P.startsWith(".")&&!h.isAbsolute(P)&&(P="./"+P),E=P.replace(/\\/g,"/")}else E.startsWith(".")&&h.extname(E)===""&&(E+=".mjs");let O=[],V=[];S.getNamedImports().forEach($=>{let P=$.getName(),M=$.getAliasNode()?.getText(),j=M?`${P} as ${M}`:P,L=($.getNameNode().getSymbol()?.getAliasedSymbol()??$.getNameNode().getSymbol())?.getDeclarations()??[],H=L.some(v=>p.isEnumDeclaration(v));$.isTypeOnly()||!H&&L.every(v=>p.isInterfaceDeclaration(v)||p.isTypeAliasDeclaration(v))?V.push(j):O.push(j)}),O.length>0&&n.addImportDeclaration({moduleSpecifier:E,namedImports:O}),V.length>0&&n.addImportDeclaration({isTypeOnly:!0,moduleSpecifier:E,namedImports:V});let B=S.getDefaultImport();B&&n.addImportDeclaration({moduleSpecifier:E,defaultImport:B.getText()})}),d.getInterfaces().forEach(S=>{l.add(S.getText().startsWith("export")?S.getText():`export ${S.getText()}`)}),d.getTypeAliases().forEach(S=>{l.add(S.getText().startsWith("export")?S.getText():`export ${S.getText()}`)});let[N]=t.getParameters(),A="";if(N){let S=N.getNameNode().getText();S!=="input"&&(A=`const ${S} = input;`)}n.addImportDeclaration({isTypeOnly:!0,moduleSpecifier:o,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 D=c.getLiteralValue(),w=`{
         __isDurable: true,
-        name: '${workflowName}',
-        async execute(context: WorkflowContext<${paramType}>): Promise<Instruction<${returnType}>> {
+        name: '${e}',
+        version: '${D}',
+        async execute(context: WorkflowContext<${y}>): Promise<Instruction<${g}>> {
             const { input, state, result, log, workflowId } = context;
-            ${paramAssignment}
+            ${A}
 			while (true) {
 				switch (context.step) {
-					${caseClauses.join("\n")}
+					${u.join(`
+`)}
 					default:
 						throw new Error(\`Paso desconocido: \${context.step}\`);
 				}
 			}
         }
-    }`;
-  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}
+    }`;n.addVariableStatement({isExported:!0,declarationKind:K.Const,declarations:[{name:e,type:`DurableFunction<${y}, ${g}, ${x}, ${k}>`,initializer:w}]}),n.organizeImports()}function T(e,t){if(e.length===0){let m=[];if(t.pendingStateAssignment){let y=`case ${t.step}: {
+${t.pendingStateAssignment}
 return { type: 'COMPLETE', result: undefined };
-}`;
-      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};
+}`;m.push(y)}return{clauses:m,nextStep:t.step+1}}let{syncBlock:s,durableStatement:n,nextStatements:o}=ie(e),{rewrittenSyncStatements:i,newlyPersistedVariables:f}=ne(s,n?[n,...o]:[],t.persistedVariables);t.pendingStateAssignment&&i.unshift(t.pendingStateAssignment);let a=new Map([...t.persistedVariables,...f]);if(!n){let m=i.join(`
+`),x=s.length>0&&p.isReturnStatement(s[s.length-1])?"":`
+return { type: 'COMPLETE', result: undefined };`;return{clauses:[`case ${t.step}: {
+${m}${x}
+}`],nextStep:t.step+1}}if(p.isIfStatement(n))return ee(n,o,{...t,persistedVariables:a},i);if(p.isTryStatement(n))return te(n,o,{...t,persistedVariables:a},i);let{instruction:c,nextPendingStateAssignment:u}=re(n,a);i.push(c);let r=i.join(`
+`),g=`case ${t.step}: {
+${r}
+}`,l={step:t.step+1,persistedVariables:a,pendingStateAssignment:u},d=T(o,l);return{clauses:[g,...d.clauses],nextStep:d.nextStep}}function ee(e,t,s,n){let o=I(e.getExpression(),s.persistedVariables),i=e.getThenStatement(),f=p.isBlock(i)?i.getStatements():[i],a=T(f,{step:s.step+1,persistedVariables:new Map(s.persistedVariables)}),c,u=e.getElseStatement();if(u){let y=p.isBlock(u)?u.getStatements():[u];c=T(y,{step:a.nextStep,persistedVariables:new Map(s.persistedVariables)})}let r=c?c.nextStep:a.nextStep,g=T(t,{step:r,persistedVariables:s.persistedVariables}),l=n.join(`
+`),d=a.nextStep;return{clauses:[`
+        case ${s.step}: {
+            ${l}
+            if (${o}) {
+                context.step = ${s.step+1};
             } else {
-                ${elseStatement ? `context.step = ${jumpToElseStep};` : `context.step = ${nextStepAfterIf};`}
+                ${u?`context.step = ${d};`:`context.step = ${r};`}
             }
 			break;
         }
-    `;
-  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")}
+    `,...a.clauses,...c?c.clauses:[],...g.clauses],nextStep:g.nextStep}}function te(e,t,s,n){let{step:o,persistedVariables:i}=s,f=e.getTryBlock(),a=e.getCatchClause(),c=e.getFinallyBlock(),u=T(f.getStatements(),{step:o+1,persistedVariables:new Map(i)}),r,g,l=u.nextStep;if(a){let w=a.getBlock(),S=a.getVariableDeclaration();S&&(g=S.getName()),r=T(w.getStatements(),{step:l,persistedVariables:new Map(i)})}let d,m=r?r.nextStep:l;c&&(d=T(c.getStatements(),{step:m,persistedVariables:new Map(i)}));let y=d?d.nextStep:m,x=T(t,{step:y,persistedVariables:i}),k=`{ catchStep: ${a?l:"undefined"}, finallyStep: ${c?m:"undefined"} }`,N=`
+        case ${o}: {
+            ${n.join(`
+`)}
             state.tryCatchStack = state.tryCatchStack || [];
-            state.tryCatchStack.push(${handler});
-            context.step = ${step + 1}; // Salta al inicio del bloque try
+            state.tryCatchStack.push(${k});
+            context.step = ${o+1}; // Salta al inicio del bloque try
             break;
         }
-    `;
-  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);
-});
+    `,A=u.clauses.pop()||"",D=c?m:y;if(u.clauses.push(A.replace(/return { type: 'COMPLETE'.* };/,`context.step = ${D}; break;`)),r){if(g){let S=r.clauses[0]||`case ${l}: {}`;r.clauses[0]=S.replace("{",`{
+const ${g} = result as any;`)}let w=r.clauses.pop()||"";r.clauses.push(w.replace(/return { type: 'COMPLETE'.* };/,`context.step = ${D}; break;`))}if(d){let w=d.clauses.pop()||"";d.clauses.push(w.replace(/return { type: 'COMPLETE'.* };/,`state.tryCatchStack?.pop(); context.step = ${y}; break;`))}return{clauses:[N,...u.clauses,...r?r.clauses:[],...d?d.clauses:[],...x.clauses],nextStep:x.nextStep}}function ne(e,t,s){let n=[],o=new Map,i=oe(t),f=new Map(s);for(let a of e){let c=!1;if(p.isVariableStatement(a))for(let u of a.getDeclarations()){let r=u.getInitializer();if(!r)continue;let g=se(u),l=g.filter(d=>i.has(d.name));if(l.length>0){let d=I(r,s);for(let{name:m,type:y}of l){o.set(m,{type:y}),f.set(m,{type:y});let x=g.length>1?`${d}.${m}`:d;n.push(`state.${m} = ${x};`)}l.length===g.length&&(c=!0)}}c||n.push(I(a,f))}return{rewrittenSyncStatements:n,newlyPersistedVariables:o}}function se(e){let t=e.getNameNode(),s=[];if(p.isIdentifier(t)){let n=e.getType().getText(e,F);s.push({name:t.getText(),type:n})}else if(p.isObjectBindingPattern(t))for(let n of t.getElements()){let o=n.getName(),i=n.getType().getText(n,F);s.push({name:o,type:i})}return s}function re(e,t){if(p.isReturnStatement(e))return{instruction:`return { type: 'COMPLETE', result: ${e.getExpression()?I(e.getExpressionOrThrow(),t):"undefined"} };`,nextPendingStateAssignment:void 0};let s,n=e.getFirstDescendantByKind(b.VariableDeclaration);if(n){let i=n.getName(),f=n.getType().getText(n,F);t.set(i,{type:f}),s=`state.${i} = result;`}let o=e.getFirstDescendantByKind(b.AwaitExpression);if(o){let i=o.getExpression();if(p.isCallExpression(i))return{instruction:`return ${ae(i,t)};`,nextPendingStateAssignment:s}}return{instruction:I(e,t),nextPendingStateAssignment:s}}function oe(e){let t=new Set;for(let s of e)s.getDescendantsOfKind(b.Identifier).forEach(n=>{t.add(n.getText())});return t}function I(e,t){let s=e.getProject().createSourceFile(`temp_rewrite_${Math.random()}.ts`,`const temp = ${e.getText()};`,{overwrite:!0}),n=s.getVariableDeclarationOrThrow("temp").getInitializerOrThrow(),o=[n,...n.getDescendants()].reverse();for(let c of o)if(p.isIdentifier(c)&&!c.wasForgotten()&&t.has(c.getText())){let u=c.getText(),r=c.getParent(),g=p.isVariableDeclaration(r)&&r.getNameNode()===c,l=p.isPropertyAccessExpression(r)&&r.getNameNode()===c||p.isPropertyAssignment(r)&&r.getNameNode()===c,d=p.isBindingElement(r)&&r.getNameNode()===c;if(!g&&!l&&!d){let m=t.get(u);c.replaceWithText(`(state.${u} as ${m.type})`)}}let i=s.getFullText().trim();s.forget();let f="const temp = ",a=i;return a.startsWith(f)&&(a=a.substring(f.length)),a.endsWith(";")&&(a=a.slice(0,-1)),a}function ae(e,t){let s=e.getExpression(),n,o=!1;p.isPropertyAccessExpression(s)?(s.getExpression().getText()==="context"&&(o=!0),n=s.getName()):n=s.getText();let i=e.getArguments().map(r=>I(r,t)).join(", ");if(o)switch(n){case"bSleep":return`{ type: 'SCHEDULE_SLEEP', duration: ${i} }`;case"bWaitForEvent":return`{ type: 'WAIT_FOR_EVENT', eventName: ${i} }`;case"bExecute":{let[r,g]=e.getArguments(),l=r.getText(),d=g?I(g,t):"undefined";return`{ type: 'EXECUTE_SUBWORKFLOW', workflowName: ${l}.name, input: ${d} }`}case"bSignal":{let[r,g]=e.getArguments().map(l=>I(l,t));return`{ type: 'SEND_SIGNAL', signalName: ${r}, payload: ${g} }`}default:throw new Error(`Funci\xF3n de contexto durable desconocida: '${n}'.`)}let f=s.getSymbol();if(!f)throw new Error(`S\xEDmbolo no encontrado para '${n}'.`);let a=f.getDeclarations()[0]?.asKind(b.ImportSpecifier);if(!a)throw new Error(`'${n}' debe ser importada.`);let c=a.getImportDeclaration().getModuleSpecifierSourceFileOrThrow();return`{ type: 'SCHEDULE_TASK', modulePath: '${h.relative(process.cwd(),c.getFilePath()).replace(/\\/g,"/")}', exportName: '${n}', args: [${i}] }`}function C(e){for(let t of e.getDescendantsOfKind(b.AwaitExpression)){let s=t.getExpressionIfKind(b.CallExpression);if(s){let n=s.getExpression();if(p.isPropertyAccessExpression(n)){let o=n.getName();if(n.getExpression().getText()==="context"&&(o==="bSleep"||o==="bWaitForEvent"||o==="bExecute"||o==="bSignal")||n.getSymbol()?.getDeclarations()[0]?.isKind(b.ImportSpecifier))return!0}else if(n.getSymbol()?.getDeclarations()[0]?.isKind(b.ImportSpecifier))return!0}}if(p.isTryStatement(e)&&(C(e.getTryBlock())||e.getCatchClause()&&C(e.getCatchClause().getBlock())||e.getFinallyBlock()&&C(e.getFinallyBlock())))return!0;if(p.isIfStatement(e)){let t=C(e.getThenStatement()),s=e.getElseStatement()?C(e.getElseStatement()):!1;return t||s}return p.isBlock(e)?e.getStatements().some(C):!1}function ie(e){for(let t=0;t<e.length;t++){let s=e[t];if(p.isReturnStatement(s)||C(s)||p.isTryStatement(s))return{syncBlock:e.slice(0,t),durableStatement:s,nextStatements:e.slice(t+1)}}return{syncBlock:e,durableStatement:null,nextStatements:[]}}var U=e=>{let t=process.argv.indexOf(e);if(t!==-1&&process.argv.length>t+1)return process.argv[t+1]};async function ce(){let e=U("--in"),t=U("--out");(!e||!t)&&(console.error("Uso: b-durable-compiler --in <directorio_entrada> --out <directorio_salida>"),process.exit(1));let s=z.resolve(process.cwd(),e),n=z.resolve(process.cwd(),t);await _({inputDir:s,outputDir:n,packageName:"@bobtail.software/b-durable"})}ce().catch(e=>{console.error("Error durante la compilaci\xF3n:",e),process.exit(1)});