@bobtail.software/b-durable 1.0.5 → 1.0.7

package/dist/compiler/cli.mjs

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