@bobtail.software/b-durable 1.0.3 → 1.0.5

package/dist/compiler/cli.mjs

@@ -1,53 +1,721 @@
 #!/usr/bin/env node
-import j from"path";import{existsSync as Z,mkdirSync as V,rmSync as ee}from"fs";import y from"path";import{Node as g,Project as te,SyntaxKind as $,VariableDeclarationKind as W}from"ts-morph";var ne="bDurable";async function K(e){console.log("Iniciando compilador de workflows duraderos...");let{inputDir:t,outputDir:n,packageName:o}=e,r=new te({tsConfigFilePath:y.resolve(process.cwd(),"tsconfig.json")}),a=r.addSourceFilesAtPaths(`${t}/**/*.ts`);Z(n)&&(console.log(`Limpiando directorio de salida: ${n}`),ee(n,{recursive:!0,force:!0})),V(n,{recursive:!0});let u=r.createDirectory(n);console.log(`Encontrados ${a.length} archivos de workflow para procesar.`);let i=[];for(let c of a){console.log(`
-Procesando archivo: ${c.getBaseName()}`);let s=c.getDescendantsOfKind($.CallExpression).filter(d=>d.getExpression().getText()===ne);if(s.length!==0)for(let d of s){let l=d.getParentIfKind($.VariableDeclaration);if(!l)continue;let x=l.getName();console.log(`  -> Transformando workflow: ${x}`);let[p]=d.getArguments();if(!g.isArrowFunction(p))continue;let m=c.getBaseName().replace(/\.ts$/,".compiled.mts"),f=y.join(u.getPath(),m),T=r.createSourceFile(f,"",{overwrite:!0});oe(x,p,r,o,T),console.log(`  -> Archivo generado: ${y.relative(process.cwd(),f)}`);let S=m;i.push({name:x,importPath:`./${S}`})}}if(i.length>0){let c=y.join(u.getPath(),"index.mts"),s=r.createSourceFile(c,"",{overwrite:!0});s.addStatements(`// Este archivo fue generado autom\xE1ticamente. NO EDITAR MANUALMENTE.
-`),s.addImportDeclaration({isTypeOnly:!0,moduleSpecifier:o,namedImports:["DurableFunction"]});for(let l of i)s.addImportDeclaration({moduleSpecifier:l.importPath,namedImports:[l.name]});s.addExportDeclaration({namedExports:i.map(l=>l.name)}),s.addStatements(`
-`),s.addVariableStatement({declarationKind:W.Const,declarations:[{name:"durableFunctions",type:"Map<string, DurableFunction<any, any>>",initializer:"new Map()"}]});let d=i.map(l=>`durableFunctions.set(${l.name}.name, ${l.name});`);s.addStatements(d),s.addStatements(`
-`),s.addExportAssignment({isExportEquals:!1,expression:"durableFunctions"}),console.log(`
--> Archivo de \xEDndice generado: ${y.basename(c)}`)}await r.save(),console.log(`
-Compilaci\xF3n completada exitosamente.`)}function oe(e,t,n,o,r){let a=t.getBody();if(!g.isBlock(a))throw new Error(`El cuerpo del workflow '${e}' debe ser un bloque {}.`);let u=new Map,{clauses:i}=F(a.getStatements(),0,u,n,o,""),[c]=t.getParameters(),s=t.getParameters()[1],l=s&&s.getName()==="context"?"const { log, workflowId } = context;":"",x=`Awaited<${t.getReturnType().getText()}>`,p=new Set,E="{}",m="unknown",f=t.getSourceFile();if(f.getInterfaces().forEach(S=>{p.add(S.getFullText())}),f.getTypeAliases().forEach(S=>{p.add(S.getFullText())}),c){E=c.getNameNode().getText();let S=c.getTypeNode();S&&(m=S.getText())}r.addImportDeclaration({isTypeOnly:!0,moduleSpecifier:o,namedImports:["DurableFunction","WorkflowContext","Instruction"]}),p.size>0&&(r.addStatements(`
-`),r.addStatements(Array.from(p))),r.addStatements(`
-// Este archivo fue generado autom\xE1ticamente. NO EDITAR MANUALMENTE.
-`);let T=`{
+
+// 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<${m}>): Promise<Instruction<${x}>> {
-            const { input, state, result } = context;
-            ${l}
-            const ${E} = input;
-            switch (context.step) {
-                ${i.join(`
-`)}
-                default:
-                    throw new Error(\`Paso desconocido: \${context.step}\`);
+        name: '${workflowName}',
+        async execute(context: WorkflowContext<${paramType}>): Promise<Instruction<${returnType}>> {
+            const { input, state, result, log, workflowId } = context;
+            ${paramAssignment}
+			while (true) {
+				switch (context.step) {
+					${caseClauses.join("\n")}
+					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}
+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};
+            } else {
+                ${elseStatement ? `context.step = ${jumpToElseStep};` : `context.step = ${nextStepAfterIf};`}
             }
+			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")}
+            state.tryCatchStack = state.tryCatchStack || [];
+            state.tryCatchStack.push(${handler});
+            context.step = ${step + 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;
         }
-    }`;r.addVariableStatement({isExported:!0,declarationKind:W.Const,declarations:[{name:e,type:`DurableFunction<${m}, ${x}>`,initializer:T}]})}function F(e,t,n,o,r,a){if(e.length===0)return{clauses:[],nextStep:t};let{syncBlock:u,durableStatement:i,nextStatements:c}=A(e),s=a+u.map(m=>h(m,n,o)).join(`
-`);if(!i)return{clauses:[`case ${t}: {
-${s}
-  return { type: 'COMPLETE', result: undefined };
-}`],nextStep:t+1};let d="",l=i.getFirstDescendantByKind($.VariableDeclaration);if(l){let m=l.getName(),f=l.getTypeNode()?.getText()??l.getInitializerOrThrow().getType().getText();n.set(m,{type:f}),d=`state.${m} = result;`}if(g.isIfStatement(i)){let m=h(i.getExpression(),n,o),f=`__branch_step_${t}`,T=L(i.getThenStatement()),S=i.getElseStatement(),I=S?L(S):[],{syncBlock:z,durableStatement:B,nextStatements:H}=A(T),{syncBlock:q,durableStatement:k,nextStatements:X}=A(I),G=z.map(D=>h(D,n,o)).join(`
-`),J=B?v(B,n,o,r):'return { type: "COMPLETE", result: undefined };',M=`if (${m}) {
-            ${G}
-            state.${f} = 0;
-            ${J}
-        }`;if(I.length>0){let D=q.map(N=>h(N,n,o)).join(`
-`),C=k?v(k,n,o,r):'return { type: "COMPLETE", result: undefined };';M+=` else {
-                ${D}
-                state.${f} = 1;
-                ${C}
-            }`}let Q=`case ${t}: {
-${s}
-  ${M}
-}`,O=F(H,t+1,new Map(n),o,r,d),_=F(X,t+1,new Map(n),o,r,d),P=[];if(O.clauses.length>0||_.clauses.length>0){let D=O.clauses.map(w=>w.replace(/^case \d+:\s*{/,"")).map(w=>w.replace(/}\s*$/,"")).join(`
-`),C=_.clauses.map(w=>w.replace(/^case \d+:\s*{/,"")).map(w=>w.replace(/}\s*$/,"")).join(`
-`),N=`case ${t+1}: {
-                if (state.${f} === 0) {
-                    ${D}
-                } else {
-                    ${C}
-                }
-            }`;P.push(N)}let Y=t+1+(P.length>0?1:0),R=F(c,Y,n,o,r,"");return{clauses:[Q,...P,...R.clauses],nextStep:R.nextStep}}let x=v(i,n,o,r),p=`case ${t}: {
-${s}
-  ${x}
-}`,E=F(c,t+1,n,o,r,d);return{clauses:[p,...E.clauses],nextStep:E.nextStep}}function b(e){if(e.getDescendantsOfKind($.AwaitExpression).length>0)return!0;if(g.isIfStatement(e)){let t=b(e.getThenStatement()),n=e.getElseStatement()?b(e.getElseStatement()):!1;return t||n}return g.isBlock(e)?e.getStatements().some(b):!1}function L(e){return g.isBlock(e)?e.getStatements():[e]}function A(e){for(let t=0;t<e.length;t++){let n=e[t];if(g.isReturnStatement(n)||b(n))return{syncBlock:e.slice(0,t),durableStatement:n,nextStatements:e.slice(t+1)}}return{syncBlock:e,durableStatement:null,nextStatements:[]}}function v(e,t,n,o){if(g.isReturnStatement(e))return`return { type: 'COMPLETE', result: ${e.getExpression()?h(e.getExpressionOrThrow(),t,n):"undefined"} };`;let r=e.getFirstDescendantByKind($.AwaitExpression);if(r){let a=r.getExpression();if(g.isCallExpression(a))return`return ${re(a,t,n,o)};`}throw new Error(`No se pudo generar una instrucci\xF3n para el statement: ${e.getText()}`)}function re(e,t,n,o){let r=e.getExpression(),a=r.getText(),u=e.getArguments().map(d=>h(d,t,n)).join(", "),i=r.getSymbol();if(!i)throw new Error(`S\xEDmbolo no encontrado para '${a}'.`);let c=i.getDeclarations()[0]?.asKind($.ImportSpecifier);if(!c)throw new Error(`'${a}' debe ser importada.`);if(c.getImportDeclaration().getModuleSpecifierValue()===o){if(a==="bSleep")return`{ type: 'SCHEDULE_SLEEP', duration: ${u} }`;if(a==="bWaitForEvent")return`{ type: 'WAIT_FOR_EVENT', eventName: ${u} }`;if(a==="bExecute"){let[d,l]=e.getArguments(),x=d.getText(),p=h(l,t,n);return`{ type: 'EXECUTE_SUBWORKFLOW', workflowName: '${x}', input: ${p} }`}throw new Error(`Funci\xF3n desconocida '${a}' importada desde '${o}'.`)}else{let d=c.getImportDeclaration().getModuleSpecifierSourceFileOrThrow();return`{ type: 'SCHEDULE_TASK', modulePath: '${y.relative(process.cwd(),d.getFilePath()).replace(/\\/g,"/")}', exportName: '${a}', args: [${u}] }`}}function h(e,t,n){let o=e.getProject().createSourceFile("temp_rewrite.ts",e.getText(),{overwrite:!0}).getChildAtIndex(0),r=[o,...o.getDescendants()];for(let u of r.reverse())if(g.isIdentifier(u)&&!u.wasForgotten()){let i=u.getText();if(t.has(i)){let c=t.get(i);if(c){let s=u.getParent();if(s&&g.isPropertyAccessExpression(s)&&s.getNameNode()===u||s&&g.isPropertyAssignment(s)&&s.getNameNode()===u)continue;u.replaceWithText(`(state.${i} as ${c.type})`)}}}let a=o.getSourceFile().getFullText();return o.getSourceFile().forget(),a}var U=e=>{let t=process.argv.indexOf(e);if(t!==-1&&process.argv.length>t+1)return process.argv[t+1]};async function se(){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 n=j.resolve(process.cwd(),e),o=j.resolve(process.cwd(),t);await K({inputDir:n,outputDir:o,packageName:"@bobtail.software/b-durable"})}se().catch(e=>{console.error("Error durante la compilaci\xF3n:",e),process.exit(1)});
+      }
+    }
+  }
+  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);
+});