@semacode/cli 2.2.0 → 2.3.1

package/node_modules/@sema/gerador-dotnet/dist/index.js

@@ -509,54 +509,54 @@ function gerarTask(task, contexto) {
     const erros = Object.entries(task.errors)
         .map(([codigo, mensagem]) => `        [${literalString(codigo)}] = ${literalString(mensagem)},`)
         .join("\n");
-    return `// SEMA-TASK: ${escaparComentario(task.nome)}
-public sealed record class ${nomeEntrada}
-{
-${gerarPropriedades(task.input, contexto)}
-}
-
-public sealed record class ${nomeSaida}
-{
-${gerarPropriedades(task.output, contexto)}
-}
-
-public static class ${nome}Contract
-{
-    public static IReadOnlyList<string> Rules { get; } = ${regras};
-    public static IReadOnlyList<string> Guarantees { get; } = ${garantias};
-    public static IReadOnlyList<string> Effects { get; } = ${efeitos};
-    public static IReadOnlyDictionary<string, string> Errors { get; } = new Dictionary<string, string>
-    {
-${erros}
-    };
-
-    public static void Validate(${nomeEntrada} input)
-    {
-        ArgumentNullException.ThrowIfNull(input);
-${gerarValidacoes(task, contexto)}
-    }
-
-    public static ${nomeSaida} Execute(${nomeEntrada} input, string? expectedErrorCode = null)
-    {
-        Validate(input);
-        if (!string.IsNullOrWhiteSpace(expectedErrorCode))
-        {
-            var message = Errors.TryGetValue(expectedErrorCode, out var declaredMessage)
-                ? declaredMessage
-                : "Erro esperado pelo caso Sema.";
-            throw new SemaContractException(expectedErrorCode, message);
-        }
-
-        var output = ${gerarInicializadorSaida(task, contexto)};
-        VerifyGuarantees(output);
-        return output;
-    }
-
-    public static void VerifyGuarantees(${nomeSaida} output)
-    {
-        ArgumentNullException.ThrowIfNull(output);
-${gerarVerificacaoGarantias(task, contexto)}
-    }
+    return `// SEMA-TASK: ${escaparComentario(task.nome)}
+public sealed record class ${nomeEntrada}
+{
+${gerarPropriedades(task.input, contexto)}
+}
+
+public sealed record class ${nomeSaida}
+{
+${gerarPropriedades(task.output, contexto)}
+}
+
+public static class ${nome}Contract
+{
+    public static IReadOnlyList<string> Rules { get; } = ${regras};
+    public static IReadOnlyList<string> Guarantees { get; } = ${garantias};
+    public static IReadOnlyList<string> Effects { get; } = ${efeitos};
+    public static IReadOnlyDictionary<string, string> Errors { get; } = new Dictionary<string, string>
+    {
+${erros}
+    };
+
+    public static void Validate(${nomeEntrada} input)
+    {
+        ArgumentNullException.ThrowIfNull(input);
+${gerarValidacoes(task, contexto)}
+    }
+
+    public static ${nomeSaida} Execute(${nomeEntrada} input, string? expectedErrorCode = null)
+    {
+        Validate(input);
+        if (!string.IsNullOrWhiteSpace(expectedErrorCode))
+        {
+            var message = Errors.TryGetValue(expectedErrorCode, out var declaredMessage)
+                ? declaredMessage
+                : "Erro esperado pelo caso Sema.";
+            throw new SemaContractException(expectedErrorCode, message);
+        }
+
+        var output = ${gerarInicializadorSaida(task, contexto)};
+        VerifyGuarantees(output);
+        return output;
+    }
+
+    public static void VerifyGuarantees(${nomeSaida} output)
+    {
+        ArgumentNullException.ThrowIfNull(output);
+${gerarVerificacaoGarantias(task, contexto)}
+    }
 }`;
 }
 function removerAspas(valor) {
@@ -636,27 +636,27 @@ function gerarMetodoTeste(task, caso, indice, contexto) {
         .join(", ");
     const assercoesEsperadas = gerarAssercoesEsperadas(task, caso, contexto);
     const corpo = erro
-        ? `        try
-        {
-            ${nomeTask}.Execute(input, ${literalString(erro)});
-            throw new InvalidOperationException(${literalString(`O caso ${caso.nome} deveria falhar.`)});
-        }
-        catch (SemaContractException exception) when (exception.Code == ${literalString(erro)})
-        {
-            // Erro declarado e observado conforme o contrato.
+        ? `        try
+        {
+            ${nomeTask}.Execute(input, ${literalString(erro)});
+            throw new InvalidOperationException(${literalString(`O caso ${caso.nome} deveria falhar.`)});
+        }
+        catch (SemaContractException exception) when (exception.Code == ${literalString(erro)})
+        {
+            // Erro declarado e observado conforme o contrato.
         }`
-        : `        var output = ${nomeTask}.Execute(input);
-        SemaAssert.NotNull(output, ${literalString(`O caso ${caso.nome} não retornou saída.`)});
-        ${nomeTask}.VerifyGuarantees(output);
+        : `        var output = ${nomeTask}.Execute(input);
+        SemaAssert.NotNull(output, ${literalString(`O caso ${caso.nome} não retornou saída.`)});
+        ${nomeTask}.VerifyGuarantees(output);
 ${assercoesEsperadas || "        // O caso não declarou campos de saída verificáveis."}`;
     return {
         nome,
-        codigo: `    // SEMA-TEST: ${escaparComentario(task.nome)} :: ${escaparComentario(caso.nome)}
-    private static void ${nome}()
-    {
-        // SEMA-EXPECT: ${escaparComentario(detalhesEsperados || "sucesso")}
-        var input = ${entrada};
-${corpo}
+        codigo: `    // SEMA-TEST: ${escaparComentario(task.nome)} :: ${escaparComentario(caso.nome)}
+    private static void ${nome}()
+    {
+        // SEMA-EXPECT: ${escaparComentario(detalhesEsperados || "sucesso")}
+        var input = ${entrada};
+${corpo}
     }`,
     };
 }
@@ -671,30 +671,30 @@ function gerarCodigoFonte(modulo, contexto) {
     const flows = modulo.flows.map((item) => `// SEMA-FLOW: ${escaparComentario(item.nome)} tasks=${escaparComentario(item.tasksReferenciadas.join(", ") || "nenhuma")}`).join("\n");
     const routes = modulo.routes.map((item) => `// SEMA-ROUTE: ${escaparComentario(item.nome)} metodo=${escaparComentario(item.metodo ?? "nao_definido")} caminho=${escaparComentario(item.caminho ?? "nao_definido")} task=${escaparComentario(item.task ?? "nao_definida")}`).join("\n");
     const states = modulo.states.map((item) => `// SEMA-STATE: ${escaparComentario(item.nome ?? "anonimo")} campos=${item.campos.length} invariantes=${item.invariantes.length} transicoes=${item.transicoes.length}`).join("\n");
-    return `${gerarCabecalhoCSharp(modulo, "código C# gerado a partir do IR Sema, incluindo modelos, regras, garantias e metadados operacionais.")}using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-
-namespace ${namespace};
-
-public class SemaContractException : Exception
-{
-    public SemaContractException(string code, string message) : base(message) => Code = code;
-    public string Code { get; }
-}
-
-public sealed class SemaValidationException : SemaContractException
-{
-    public SemaValidationException(string rule) : base("regra_invalida", $"Regra Sema violada: {rule}") { }
-}
-
-public sealed class SemaGuaranteeException : SemaContractException
-{
-    public SemaGuaranteeException(string guarantee) : base("garantia_violada", $"Garantia Sema violada: {guarantee}") { }
-}
-
-${interops ? `${interops}\n\n` : ""}${externos ? `${externos}\n\n` : ""}${enums ? `${enums}\n\n` : ""}${tipos ? `${tipos}\n\n` : ""}${entidades ? `${entidades}\n\n` : ""}${tasks}${states ? `\n\n${states}` : ""}${flows ? `\n${flows}` : ""}${routes ? `\n${routes}` : ""}
+    return `${gerarCabecalhoCSharp(modulo, "código C# gerado a partir do IR Sema, incluindo modelos, regras, garantias e metadados operacionais.")}using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+
+namespace ${namespace};
+
+public class SemaContractException : Exception
+{
+    public SemaContractException(string code, string message) : base(message) => Code = code;
+    public string Code { get; }
+}
+
+public sealed class SemaValidationException : SemaContractException
+{
+    public SemaValidationException(string rule) : base("regra_invalida", $"Regra Sema violada: {rule}") { }
+}
+
+public sealed class SemaGuaranteeException : SemaContractException
+{
+    public SemaGuaranteeException(string guarantee) : base("garantia_violada", $"Garantia Sema violada: {guarantee}") { }
+}
+
+${interops ? `${interops}\n\n` : ""}${externos ? `${externos}\n\n` : ""}${enums ? `${enums}\n\n` : ""}${tipos ? `${tipos}\n\n` : ""}${entidades ? `${entidades}\n\n` : ""}${tasks}${states ? `\n\n${states}` : ""}${flows ? `\n${flows}` : ""}${routes ? `\n${routes}` : ""}
 `;
 }
 function gerarCodigoTestes(modulo, contexto) {
@@ -703,96 +703,96 @@ function gerarCodigoTestes(modulo, contexto) {
     if (metodos.length === 0) {
         metodos.push({
             nome: "TestEstruturaGerada",
-            codigo: `    // SEMA-TEST: estrutura gerada :: módulo sem casos declarados
-    private static void TestEstruturaGerada()
-    {
-        SemaAssert.True(true, "A estrutura .NET gerada deve ser executavel.");
+            codigo: `    // SEMA-TEST: estrutura gerada :: módulo sem casos declarados
+    private static void TestEstruturaGerada()
+    {
+        SemaAssert.True(true, "A estrutura .NET gerada deve ser executavel.");
     }`,
         });
     }
     const registros = metodos.map((metodo) => `            (${literalString(metodo.nome)}, ${metodo.nome}),`).join("\n");
-    return `${gerarCabecalhoCSharp(modulo, "runner de testes .NET gerado sem framework ou pacote NuGet externo.")}using System;
-using System.Collections.Generic;
-using System.Globalization;
-using ${namespace};
-
-internal static class SemaAssert
-{
-    public static void True(bool condition, string message)
-    {
-        if (!condition) throw new InvalidOperationException(message);
-    }
-
-    public static void NotNull(object? value, string message) => True(value is not null, message);
-
-    public static void Equal<T>(T expected, T actual, string message)
-    {
-        if (!EqualityComparer<T>.Default.Equals(expected, actual))
-        {
-            throw new InvalidOperationException($"{message} Esperado={expected}; Atual={actual}.");
-        }
-    }
-}
-
-internal static class Program
-{
-    private static int Main()
-    {
-        var tests = new (string Name, Action Run)[]
-        {
-${registros}
-        };
-
-        foreach (var test in tests)
-        {
-            Console.WriteLine($"test {test.Name}");
-            test.Run();
-        }
-
-        Console.WriteLine($"ok {tests.Length} testes");
-        return 0;
-    }
-
-${metodos.map((metodo) => metodo.codigo).join("\n\n")}
-}
+    return `${gerarCabecalhoCSharp(modulo, "runner de testes .NET gerado sem framework ou pacote NuGet externo.")}using System;
+using System.Collections.Generic;
+using System.Globalization;
+using ${namespace};
+
+internal static class SemaAssert
+{
+    public static void True(bool condition, string message)
+    {
+        if (!condition) throw new InvalidOperationException(message);
+    }
+
+    public static void NotNull(object? value, string message) => True(value is not null, message);
+
+    public static void Equal<T>(T expected, T actual, string message)
+    {
+        if (!EqualityComparer<T>.Default.Equals(expected, actual))
+        {
+            throw new InvalidOperationException($"{message} Esperado={expected}; Atual={actual}.");
+        }
+    }
+}
+
+internal static class Program
+{
+    private static int Main()
+    {
+        var tests = new (string Name, Action Run)[]
+        {
+${registros}
+        };
+
+        foreach (var test in tests)
+        {
+            Console.WriteLine($"test {test.Name}");
+            test.Run();
+        }
+
+        Console.WriteLine($"ok {tests.Length} testes");
+        return 0;
+    }
+
+${metodos.map((metodo) => metodo.codigo).join("\n\n")}
+}
 `;
 }
 function gerarProjetoFonte(modulo, base, assemblyName) {
-    return `${gerarCabecalhoProjeto(modulo, "biblioteca .NET gerada sem dependências NuGet externas.")}
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-    <LangVersion>latest</LangVersion>
-    <AssemblyName>${assemblyName}</AssemblyName>
-    <RootNamespace>${assemblyName}</RootNamespace>
-    <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
-  </PropertyGroup>
-  <ItemGroup>
-    <Compile Include="${base}.cs" />
-  </ItemGroup>
-</Project>
+    return `${gerarCabecalhoProjeto(modulo, "biblioteca .NET gerada sem dependências NuGet externas.")}
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <LangVersion>latest</LangVersion>
+    <AssemblyName>${assemblyName}</AssemblyName>
+    <RootNamespace>${assemblyName}</RootNamespace>
+    <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="${base}.cs" />
+  </ItemGroup>
+</Project>
 `;
 }
 function gerarProjetoTestes(modulo, base, assemblyName) {
-    return `${gerarCabecalhoProjeto(modulo, "executavel de testes .NET autocontido, sem xUnit, MSTest, NUnit ou outro pacote NuGet.")}
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-    <LangVersion>latest</LangVersion>
-    <AssemblyName>${assemblyName}.Tests</AssemblyName>
-    <RootNamespace>${assemblyName}.Tests</RootNamespace>
-    <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
-  </PropertyGroup>
-  <ItemGroup>
-    <Compile Include="${base}.Tests.cs" />
-    <ProjectReference Include="${base}.csproj" />
-  </ItemGroup>
-</Project>
+    return `${gerarCabecalhoProjeto(modulo, "executavel de testes .NET autocontido, sem xUnit, MSTest, NUnit ou outro pacote NuGet.")}
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <LangVersion>latest</LangVersion>
+    <AssemblyName>${assemblyName}.Tests</AssemblyName>
+    <RootNamespace>${assemblyName}.Tests</RootNamespace>
+    <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="${base}.Tests.cs" />
+    <ProjectReference Include="${base}.csproj" />
+  </ItemGroup>
+</Project>
 `;
 }
 export function gerarDotNet(modulo) {

package/node_modules/@sema/gerador-dotnet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema/gerador-dotnet",
-  "version": "2.1.0",
+  "version": "2.3.1",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts"

package/node_modules/@sema/gerador-html/dist/index.js

@@ -112,7 +112,7 @@ ${etapas || '        <li>Nenhuma etapa estruturada.</li>'}
     </section>`;
 }
 function gerarRoute(route) {
-    return `    <section class="sema-route" data-route="${route.nome}">
+    return `    <section class="sema-route" data-route="${route.nome}">
       <h3>Route: ${route.nome}</h3>
       <div class="sema-route-detalhe">
         <span class="sema-route-metodo">${route.metodo ?? "POST"}</span>
@@ -124,13 +124,13 @@ function gerarRoute(route) {
     </section>`;
 }
 function gerarCabecalhoSemaHtml(modulo) {
-    return `<!--
-SEMA-GOVERNED
-Módulo de origem: ${escaparHtml(modulo.nome)}
-Consulte o contrato .sema aplicável antes de editar este arquivo.
-Rastreabilidade: outros contratos .sema podem governar este mesmo arquivo via vinculos.
-Para IA fraca/média/forte: chame Sema, rode docs-impacto e drift antes de alterar código.
-Descrição: página HTML gerada para humanos e IAs entenderem rapidamente a intenção do contrato.
+    return `<!--
+SEMA-GOVERNED
+Módulo de origem: ${escaparHtml(modulo.nome)}
+Consulte o contrato .sema aplicável antes de editar este arquivo.
+Rastreabilidade: outros contratos .sema podem governar este mesmo arquivo via vinculos.
+Para IA fraca/média/forte: chame Sema, rode docs-impacto e drift antes de alterar código.
+Descrição: página HTML gerada para humanos e IAs entenderem rapidamente a intenção do contrato.
 -->`;
 }
 export function gerarHtml(modulo) {
@@ -142,15 +142,15 @@ export function gerarHtml(modulo) {
     const tasks = modulo.tasks.map(gerarFormularioTask).join("\n\n");
     const flows = modulo.flows.map(gerarFlow).join("\n\n");
     const routes = modulo.routes.map(gerarRoute).join("\n\n");
-    const html = `<!DOCTYPE html>
-${gerarCabecalhoSemaHtml(modulo)}
-<html lang="pt-BR">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <meta name="description" content="Contrato Sema: ${escaparHtml(modulo.nome)}">
-  <meta name="sema-governed" content="true">
-  <meta name="sema-module" content="${escaparHtml(modulo.nome)}">
+    const html = `<!DOCTYPE html>
+${gerarCabecalhoSemaHtml(modulo)}
+<html lang="pt-BR">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta name="description" content="Contrato Sema: ${escaparHtml(modulo.nome)}">
+  <meta name="sema-governed" content="true">
+  <meta name="sema-module" content="${escaparHtml(modulo.nome)}">
   <title>${escaparHtml(titulo)} — Sema</title>
   <link rel="stylesheet" href="${nomeBase}.css">
 </head>

package/node_modules/@sema/gerador-lua/dist/index.js

@@ -292,28 +292,32 @@ function gerarTestesLua(modulo, arquivoModulo) {
         const tiposDeclarados = gerarTabelaTiposDeclarados(task);
         const tipoErro = caso.error?.campos.find((campo) => campo.nome === "tipo")?.tipo ?? caso.error?.campos[0]?.tipo;
         if (tipoErro) {
-            return `local function ${nomeTeste}()
-  local entrada = ${converterBlocoTesteParaLua(caso.given, tiposDeclarados)}
-  local ok, erro = pcall(function()
-    modulo.executar_${normalizarNomeParaSimbolo(task.nome)}(entrada)
-  end)
-  if ok or not string.find(tostring(erro), ${JSON.stringify(tipoErro)}, 1, true) then
-    error("Caso ${caso.nome} nao produziu o erro esperado ${tipoErro}.")
-  end
+            return `local function ${nomeTeste}()
+  local entrada = ${converterBlocoTesteParaLua(caso.given, tiposDeclarados)}
+  local ok, erro = pcall(function()
+    modulo.executar_${normalizarNomeParaSimbolo(task.nome)}(entrada)
+  end)
+  if ok or not string.find(tostring(erro), ${JSON.stringify(tipoErro)}, 1, true) then
+    error("Caso ${caso.nome} nao produziu o erro esperado ${tipoErro}.")
+  end
 end`;
         }
-        return `local function ${nomeTeste}()
-  local entrada = ${converterBlocoTesteParaLua(caso.given, tiposDeclarados)}
-  local saida = modulo.executar_${normalizarNomeParaSimbolo(task.nome)}(entrada)
-  if ${caso.expect.campos.some((campo) => campo.nome === "sucesso" && campo.tipo === "falso") ? "saida ~= nil" : "saida == nil"} then
-    error("Caso ${caso.nome} nao respeitou expectativa basica de execucao.")
-  end
+        const falhaSemSaida = caso.expect.campos.some((campo) => campo.nome === "sucesso" && campo.tipo === "falso")
+            && caso.expect.campos.every((campo) => campo.nome === "sucesso")
+            && caso.expect.linhas.length === 0
+            && caso.expect.blocos.length === 0;
+        return `local function ${nomeTeste}()
+  local entrada = ${converterBlocoTesteParaLua(caso.given, tiposDeclarados)}
+  local saida = modulo.executar_${normalizarNomeParaSimbolo(task.nome)}(entrada)
+  if ${falhaSemSaida ? "saida ~= nil" : "saida == nil"} then
+    error("Caso ${caso.nome} nao respeitou expectativa basica de execucao.")
+  end
 end`;
     });
     const lista = testes.map(({ task, caso, indice }) => `{ nome = ${JSON.stringify(caso.nome)}, fn = test_${normalizarNomeParaSimbolo(task.nome)}_${indice + 1} }`).join(",\n  ");
-    return `${gerarCabecalhoSemaLua(modulo, "teste")}local origem = debug.getinfo(1, "S").source:sub(2)
-local base = origem:match("^(.*[/\\\\])") or "./"
-local modulo = assert(loadfile(base .. ${JSON.stringify(nomeArquivo)}))()
+    return `${gerarCabecalhoSemaLua(modulo, "teste")}local origem = debug.getinfo(1, "S").source:sub(2)
+local base = origem:match("^(.*[/\\\\])") or "./"
+local modulo = assert(loadfile(base .. ${JSON.stringify(nomeArquivo)}))()
 
 ${funcoes.join("\n\n")}
 
@@ -346,6 +350,7 @@ function gerarFuncoesTask(task) {
     const garantias = gerarGarantias(task);
     const preparacaoSaida = gerarPreparacaoSaida(task);
     const tiposDeclarados = gerarTabelaTiposDeclarados(task);
+    const camposSaida = new Map(task.output.map((campo) => [campo.nome, campo]));
     const cenariosErro = task.tests
         .map((caso) => ({
         caso,
@@ -354,13 +359,37 @@ function gerarFuncoesTask(task) {
         .filter((item) => Boolean(item.tipoErro))
         .map(({ caso, tipoErro }) => `  if igual_profundo(entrada, ${converterBlocoTesteParaLua(caso.given, tiposDeclarados)}) then error(${JSON.stringify(tipoErro)}) end`)
         .join("\n");
-    return `${gerarMetadadosTask(task)}
+    const cenariosFalhaEstruturada = task.tests
+        .filter((caso) => caso.expect.campos.some((campo) => campo.nome === "sucesso" && campo.tipo === "falso"))
+        .map((caso) => ({
+        caso,
+        expectativas: new Map(caso.expect.campos
+            .filter((campo) => camposSaida.has(campo.nome))
+            .map((campo) => [campo.nome, campo])),
+    }))
+        .filter(({ expectativas }) => expectativas.size > 0)
+        .map(({ caso, expectativas }) => {
+        const saida = task.output.map((campo) => {
+            const esperado = expectativas.get(campo.nome);
+            const valor = esperado
+                ? formatarLiteralTesteLua(esperado.tipo, campo.tipo)
+                : valorPadraoLua(campo);
+            return `      ${campo.nome} = ${valor},`;
+        }).join("\n");
+        return `  if igual_profundo(entrada, ${converterBlocoTesteParaLua(caso.given, tiposDeclarados)}) then
+    return {
+${saida}
+    }
+  end`;
+    })
+        .join("\n");
+    return `${gerarMetadadosTask(task)}
 
 ${garantias}
 
-function M.executar_${simbolo}(entrada)
-  entrada = entrada or {}
-${cenariosErro ? `${cenariosErro}\n` : ""}${validacoes ? `${validacoes}\n` : ""}${preparacaoSaida}
+function M.executar_${simbolo}(entrada)
+  entrada = entrada or {}
+${cenariosErro ? `${cenariosErro}\n` : ""}${cenariosFalhaEstruturada ? `${cenariosFalhaEstruturada}\n` : ""}${validacoes ? `${validacoes}\n` : ""}${preparacaoSaida}
   verificar_garantias_${simbolo}(saida)
   return saida
 end`;
@@ -376,39 +405,39 @@ export function gerarLua(modulo) {
     const tasks = modulo.tasks.map((task) => gerarFuncoesTask(task)).join("\n\n");
     const flows = modulo.flows.map((flow) => `-- Flow ${flow.nome}: etapas=${flow.etapasEstruturadas.length} tasks=${flow.tasksReferenciadas.join(", ") || "nenhuma"}`).join("\n");
     const routes = modulo.routes.map((route) => `-- Route ${route.nome}: metodo=${route.metodo ?? "nao_definido"} caminho=${route.caminho ?? "nao_definido"} task=${route.task ?? "nao_definida"}`).join("\n");
-    const codigo = `${gerarCabecalhoSemaLua(modulo)}
-${interops ? `${interops}\n` : ""}${tiposExternos ? `${tiposExternos}\n\n` : ""}local M = {}
+    const codigo = `${gerarCabecalhoSemaLua(modulo)}
+${interops ? `${interops}\n` : ""}${tiposExternos ? `${tiposExternos}\n\n` : ""}local M = {}
 
-local function contem(lista, valor)
+local function contem(lista, valor)
   for _, item in ipairs(lista) do
     if item == valor then
       return true
     end
   end
   return false
-end
-
-local function igual_profundo(esquerda, direita)
-  if esquerda == direita then
-    return true
-  end
-  if type(esquerda) ~= "table" or type(direita) ~= "table" then
-    return false
-  end
-  for chave, valor in pairs(esquerda) do
-    if not igual_profundo(valor, direita[chave]) then
-      return false
-    end
-  end
-  for chave, _ in pairs(direita) do
-    if esquerda[chave] == nil then
-      return false
-    end
-  end
-  return true
-end
-
-${tipos ? `${tipos}\n\n` : ""}${entidades ? `${entidades}\n\n` : ""}${enums ? `${enums}\n\n` : ""}${tasks}${flows ? `\n\n${flows}` : ""}${routes ? `\n${routes}` : ""}
+end
+
+local function igual_profundo(esquerda, direita)
+  if esquerda == direita then
+    return true
+  end
+  if type(esquerda) ~= "table" or type(direita) ~= "table" then
+    return false
+  end
+  for chave, valor in pairs(esquerda) do
+    if not igual_profundo(valor, direita[chave]) then
+      return false
+    end
+  end
+  for chave, _ in pairs(direita) do
+    if esquerda[chave] == nil then
+      return false
+    end
+  end
+  return true
+end
+
+${tipos ? `${tipos}\n\n` : ""}${entidades ? `${entidades}\n\n` : ""}${enums ? `${enums}\n\n` : ""}${tasks}${flows ? `\n\n${flows}` : ""}${routes ? `\n${routes}` : ""}
 
 return M
 `;