@semacode/cli 1.3.6 → 1.3.7

package/node_modules/@sema/nucleo/src/ir/conversor.ts

@@ -1,912 +0,0 @@
-import type { BlocoCasoTesteAst, BlocoGenericoAst, CampoAst, ModuloAst } from "../ast/tipos.js";
-import type { Diagnostico } from "../diagnosticos/index.js";
-import type { ContextoSemantico, ErroSemanticoTask } from "../semantico/analisador.js";
-import {
-  contratoDadosTemSensivel,
-  extrairContratoAudit,
-  extrairContratoAuth,
-  extrairContratoAuthz,
-  extrairContratoDados,
-  extrairContratoForbidden,
-  extrairContratoSegredos,
-  efeitoEhPrivilegiado,
-} from "../semantico/seguranca.js";
-import { parsearEfeitoSemantico, parsearEtapaFlow, parsearExpressaoSemantica, parsearTransicaoEstado } from "../semantico/estruturas.js";
-import type {
-  IrBlocoDeclarativo,
-  IrCampo,
-  IrCasoTeste,
-  IrAudit,
-  IrAuth,
-  IrAuthz,
-  IrDados,
-  IrEntity,
-  IrErroOperacional,
-  IrExecucao,
-  IrForbidden,
-  IrFlow,
-  IrImplementacaoTask,
-  IrModulo,
-  IrResumoAgente,
-  IrRoute,
-  IrRoutePublica,
-  IrSegredos,
-  IrState,
-  IrSuperficie,
-  IrTask,
-  IrType,
-  IrVinculo,
-  NivelConfiancaSemantica,
-  NivelRiscoSemantico,
-  PerfilCompatibilidade,
-  TipoSuperficieIr,
-} from "./modelos.js";
-
-const TIPOS_PRIMITIVOS = new Set([
-  "Texto",
-  "Numero",
-  "Inteiro",
-  "Decimal",
-  "Booleano",
-  "Data",
-  "DataHora",
-  "Id",
-  "Email",
-  "Url",
-  "Json",
-  "Vazio",
-]);
-
-function encontrarSubBloco(bloco: BlocoGenericoAst, palavraChave: string): BlocoGenericoAst | undefined {
-  return bloco.blocos.find((subbloco): subbloco is BlocoGenericoAst => subbloco.tipo === "bloco_generico" && subbloco.palavraChave === palavraChave);
-}
-
-function localizarCampo(bloco: BlocoGenericoAst | undefined, ...nomes: string[]): CampoAst | undefined {
-  return bloco?.campos.find((campo) => nomes.includes(campo.nome));
-}
-
-function valorCampoCompleto(campo?: CampoAst): string | undefined {
-  if (!campo) {
-    return undefined;
-  }
-  return [campo.valor, ...campo.modificadores].join(" ").trim() || undefined;
-}
-
-function normalizarTipoDeclarado(tipo: string): string {
-  return tipo
-    .replace(/\s*([<>\[\](),|?])\s*/g, "$1")
-    .replace(/\s+/g, "")
-    .trim();
-}
-
-function dividirNoNivelRaiz(texto: string, separador: string): string[] {
-  const partes: string[] = [];
-  let profundidadeAngular = 0;
-  let profundidadeColchete = 0;
-  let inicio = 0;
-
-  for (let indice = 0; indice < texto.length; indice += 1) {
-    const caractere = texto[indice]!;
-    if (caractere === "<") {
-      profundidadeAngular += 1;
-      continue;
-    }
-    if (caractere === ">") {
-      profundidadeAngular = Math.max(0, profundidadeAngular - 1);
-      continue;
-    }
-    if (caractere === "[") {
-      profundidadeColchete += 1;
-      continue;
-    }
-    if (caractere === "]") {
-      profundidadeColchete = Math.max(0, profundidadeColchete - 1);
-      continue;
-    }
-    if (profundidadeAngular === 0 && profundidadeColchete === 0 && texto.startsWith(separador, indice)) {
-      partes.push(texto.slice(inicio, indice));
-      inicio = indice + separador.length;
-      indice += separador.length - 1;
-    }
-  }
-
-  partes.push(texto.slice(inicio));
-  return partes.map((parte) => parte.trim()).filter(Boolean);
-}
-
-function analisarCampoTipo(tipo: string, modificadores: string[]): Omit<IrCampo, "nome"> {
-  const tipoOriginal = normalizarTipoDeclarado(tipo);
-  const modificadoresNormalizados = modificadores.map((item) => item.trim()).filter(Boolean);
-  const refinamentos = modificadoresNormalizados.filter((item) => !["required", "optional", "opcional"].includes(item));
-  const opcionalPorModificador = modificadoresNormalizados.includes("optional") || modificadoresNormalizados.includes("opcional");
-
-  let tipoBase = tipoOriginal;
-  let cardinalidade: IrCampo["cardinalidade"] = "unitario";
-  let tiposAlternativos: string[] = [];
-  let tipoItem: string | undefined;
-  let chaveMapa: string | undefined;
-  let valorMapa: string | undefined;
-  let opcional = opcionalPorModificador;
-
-  if (tipoBase.endsWith("?")) {
-    opcional = true;
-    tipoBase = tipoBase.slice(0, -1);
-  }
-
-  if (/^Opcional<.+>$/.test(tipoBase)) {
-    opcional = true;
-    tipoBase = tipoBase.slice("Opcional<".length, -1);
-  }
-
-  const uniao = dividirNoNivelRaiz(tipoBase, "|");
-  if (uniao.length > 1) {
-    cardinalidade = "uniao";
-    tiposAlternativos = uniao.map(normalizarTipoDeclarado);
-    tipoBase = tiposAlternativos[0] ?? tipoBase;
-  } else if (/^Lista<.+>$/.test(tipoBase)) {
-    cardinalidade = "lista";
-    tipoItem = tipoBase.slice("Lista<".length, -1).trim();
-    tipoBase = tipoItem;
-  } else if (/^Mapa<.+>$/.test(tipoBase)) {
-    cardinalidade = "mapa";
-    const partesMapa = dividirNoNivelRaiz(tipoBase.slice("Mapa<".length, -1), ",");
-    chaveMapa = partesMapa[0];
-    valorMapa = partesMapa[1];
-    tipoBase = valorMapa ?? tipoBase;
-  }
-
-  return {
-    tipo: tipoOriginal,
-    modificadores: modificadoresNormalizados,
-    tipoOriginal,
-    tipoBase,
-    cardinalidade,
-    opcional,
-    tiposAlternativos,
-    tipoItem,
-    chaveMapa,
-    valorMapa,
-    refinamentos,
-  };
-}
-
-function converterCampo(campo: CampoAst): IrCampo {
-  return {
-    nome: campo.nome,
-    ...analisarCampoTipo(campo.valor, campo.modificadores),
-  };
-}
-
-function converterCampos(bloco?: BlocoGenericoAst): IrCampo[] {
-  if (!bloco) {
-    return [];
-  }
-  return bloco.campos.map(converterCampo);
-}
-
-function converterBloco(bloco?: BlocoGenericoAst): IrBlocoDeclarativo {
-  return {
-    campos: converterCampos(bloco),
-    linhas: bloco?.linhas.map((linha) => linha.conteudo) ?? [],
-    blocos: (bloco?.blocos ?? [])
-      .filter((subbloco): subbloco is BlocoGenericoAst => subbloco.tipo === "bloco_generico")
-      .map((subbloco) => ({
-        nome: subbloco.nome ?? subbloco.palavraChave,
-        conteudo: converterBloco(subbloco),
-      })),
-  };
-}
-
-function converterCaso(caso: BlocoCasoTesteAst): IrCasoTeste {
-  return {
-    nome: caso.nome,
-    given: converterBloco(caso.given),
-    when: caso.when ? converterBloco(caso.when) : undefined,
-    expect: converterBloco(caso.expect),
-    error: caso.error ? converterBloco(caso.error) : undefined,
-  };
-}
-
-function converterImplementacoes(bloco?: BlocoGenericoAst): IrImplementacaoTask[] {
-  const implementacoes: IrImplementacaoTask[] = [];
-  for (const campo of bloco?.campos ?? []) {
-    const origem = campo.nome.toLowerCase();
-    if (origem === "ts" || origem === "typescript") {
-      implementacoes.push({ origem: "ts", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
-      continue;
-    }
-    if (origem === "py" || origem === "python") {
-      implementacoes.push({ origem: "py", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
-      continue;
-    }
-    if (origem === "dart") {
-      implementacoes.push({ origem: "dart", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
-      continue;
-    }
-    if (origem === "cs" || origem === "csharp" || origem === "dotnet") {
-      implementacoes.push({ origem: "cs", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
-      continue;
-    }
-    if (origem === "java") {
-      implementacoes.push({ origem: "java", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
-      continue;
-    }
-    if (origem === "go" || origem === "golang") {
-      implementacoes.push({ origem: "go", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
-      continue;
-    }
-    if (origem === "rust" || origem === "rs") {
-      implementacoes.push({ origem: "rust", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
-      continue;
-    }
-    if (origem === "cpp" || origem === "cxx" || origem === "cc" || origem === "c++") {
-      implementacoes.push({ origem: "cpp", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
-    }
-  }
-  return implementacoes;
-}
-
-function converterVinculos(bloco?: BlocoGenericoAst): IrVinculo[] {
-  if (!bloco) {
-    return [];
-  }
-
-  const campos = bloco.campos.map((campo) => {
-    const valor = valorCampoCompleto(campo) ?? "";
-    return {
-      tipo: campo.nome,
-      valor,
-      arquivo: campo.nome === "arquivo" ? valor : undefined,
-      simbolo: campo.nome === "simbolo" ? valor : undefined,
-      recurso: ["recurso", "tabela", "fila", "cache", "storage"].includes(campo.nome) ? valor : undefined,
-      superficie: ["superficie", "rota", "worker", "cron", "webhook", "evento", "policy", "fila", "cache", "storage"].includes(campo.nome) ? valor : undefined,
-      statusResolucao: "nao_verificado" as const,
-    };
-  });
-
-  const linhas = bloco.linhas.map((linha) => {
-    const [tipo, ...resto] = linha.conteudo.split(/\s+/);
-    const valor = resto.join(" ").trim();
-    return {
-      tipo: tipo ?? "desconhecido",
-      valor,
-      statusResolucao: "nao_verificado" as const,
-    };
-  }).filter((item) => item.valor);
-
-  const subblocos = bloco.blocos
-    .filter((item): item is BlocoGenericoAst => item.tipo === "bloco_generico")
-    .map((item) => ({
-      tipo: item.palavraChave === "desconhecido" ? (item.nome ?? "desconhecido") : item.palavraChave,
-      valor: item.nome ?? item.palavraChave,
-      arquivo: valorCampoCompleto(localizarCampo(item, "arquivo")),
-      simbolo: valorCampoCompleto(localizarCampo(item, "simbolo")),
-      recurso: valorCampoCompleto(localizarCampo(item, "recurso", "tabela", "fila", "cache", "storage")),
-      superficie: valorCampoCompleto(localizarCampo(item, "superficie", "rota", "worker", "cron", "webhook", "evento")),
-      statusResolucao: "nao_verificado" as const,
-    }));
-
-  return [...campos, ...linhas, ...subblocos];
-}
-
-function converterExecucao(bloco?: BlocoGenericoAst): IrExecucao {
-  const idempotencia = valorCampoCompleto(localizarCampo(bloco, "idempotencia"));
-  const criticidadeOperacional = valorCampoCompleto(localizarCampo(bloco, "criticidade_operacional"));
-
-  return {
-    idempotencia: idempotencia === "verdadeiro" || idempotencia === "true",
-    timeout: valorCampoCompleto(localizarCampo(bloco, "timeout")) ?? "padrao",
-    retry: valorCampoCompleto(localizarCampo(bloco, "retry")) ?? "nenhum",
-    compensacao: valorCampoCompleto(localizarCampo(bloco, "compensacao")) ?? "nenhuma",
-    criticidadeOperacional: (
-      criticidadeOperacional === "baixa"
-      || criticidadeOperacional === "alta"
-      || criticidadeOperacional === "critica"
-    ) ? criticidadeOperacional : "media",
-    explicita: Boolean(bloco),
-  };
-}
-
-function converterAuth(bloco?: BlocoGenericoAst): IrAuth {
-  return extrairContratoAuth(bloco);
-}
-
-function converterAuthz(bloco?: BlocoGenericoAst): IrAuthz {
-  return extrairContratoAuthz(bloco);
-}
-
-function converterDados(bloco?: BlocoGenericoAst): IrDados {
-  return extrairContratoDados(bloco);
-}
-
-function converterAudit(bloco?: BlocoGenericoAst): IrAudit {
-  return extrairContratoAudit(bloco);
-}
-
-function converterSegredos(bloco?: BlocoGenericoAst): IrSegredos {
-  return extrairContratoSegredos(bloco);
-}
-
-function converterForbidden(bloco?: BlocoGenericoAst): IrForbidden {
-  return extrairContratoForbidden(bloco);
-}
-
-function converterErrosTask(bloco?: BlocoGenericoAst, fallback?: ErroSemanticoTask[]): IrErroOperacional[] {
-  const erros = new Map<string, IrErroOperacional>();
-
-  for (const campo of bloco?.campos ?? []) {
-    erros.set(campo.nome, {
-      codigo: campo.nome,
-      mensagem: valorCampoCompleto(campo) ?? "",
-    });
-  }
-
-  for (const subbloco of bloco?.blocos ?? []) {
-    if (subbloco.tipo !== "bloco_generico") {
-      continue;
-    }
-    const codigo = subbloco.nome ?? subbloco.palavraChave;
-    if (!codigo || codigo === "desconhecido") {
-      continue;
-    }
-    erros.set(codigo, {
-      codigo,
-      mensagem: valorCampoCompleto(localizarCampo(subbloco, "mensagem")) ?? `Erro estruturado "${codigo}".`,
-      categoria: valorCampoCompleto(localizarCampo(subbloco, "categoria")),
-      recuperabilidade: valorCampoCompleto(localizarCampo(subbloco, "recuperabilidade")),
-      acaoChamador: valorCampoCompleto(localizarCampo(subbloco, "acao_chamador")),
-      impactaEstado: valorCampoCompleto(localizarCampo(subbloco, "impacta_estado")) === "verdadeiro",
-      requerCompensacao: valorCampoCompleto(localizarCampo(subbloco, "requer_compensacao")) === "verdadeiro",
-    });
-  }
-
-  for (const erro of fallback ?? []) {
-    if (!erros.has(erro.codigo)) {
-      erros.set(erro.codigo, {
-        codigo: erro.codigo,
-        mensagem: erro.mensagem,
-        categoria: erro.categoria,
-        recuperabilidade: erro.recuperabilidade,
-        acaoChamador: erro.acaoChamador,
-        impactaEstado: erro.impactaEstado,
-        requerCompensacao: erro.requerCompensacao,
-      });
-    }
-  }
-
-  return [...erros.values()];
-}
-
-function extrairPerfil(bloco?: BlocoGenericoAst, padrao: PerfilCompatibilidade = "interno"): PerfilCompatibilidade {
-  const perfil = valorCampoCompleto(localizarCampo(bloco, "perfil", "compatibilidade"))?.toLowerCase();
-  if (
-    perfil === "publico"
-    || perfil === "interno"
-    || perfil === "experimental"
-    || perfil === "legado"
-    || perfil === "deprecado"
-  ) {
-    return perfil;
-  }
-  return padrao;
-}
-
-function tipoNaoPrimitivo(campo: IrCampo): string | undefined {
-  if (!TIPOS_PRIMITIVOS.has(campo.tipoBase)) {
-    return campo.tipoBase;
-  }
-  if (campo.tipoItem && !TIPOS_PRIMITIVOS.has(campo.tipoItem)) {
-    return campo.tipoItem;
-  }
-  if (campo.valorMapa && !TIPOS_PRIMITIVOS.has(campo.valorMapa)) {
-    return campo.valorMapa;
-  }
-  return undefined;
-}
-
-function deduplicarTexto(valores: string[]): string[] {
-  return [...new Set(valores.filter(Boolean))].sort((a, b) => a.localeCompare(b, "pt-BR"));
-}
-
-function resumirAgente(params: {
-  input?: IrCampo[];
-  output?: IrCampo[];
-  efeitos?: Array<{ categoria: string; alvo: string; criticidade?: string }>;
-  vinculos?: IrVinculo[];
-  execucao?: IrExecucao;
-  auth?: IrAuth;
-  authz?: IrAuthz;
-  dados?: IrDados;
-  audit?: IrAudit;
-  segredos?: IrSegredos;
-  forbidden?: IrForbidden;
-  superficiePublica?: string;
-}): IrResumoAgente {
-  const entidadesAfetadas = deduplicarTexto([
-    ...(params.input ?? []).map(tipoNaoPrimitivo).filter((item): item is string => Boolean(item)),
-    ...(params.output ?? []).map(tipoNaoPrimitivo).filter((item): item is string => Boolean(item)),
-    ...(params.efeitos ?? []).map((efeito) => efeito.alvo),
-  ]);
-
-  const mutacoesPrevistas = deduplicarTexto(
-    (params.efeitos ?? []).map((efeito) => `${efeito.categoria}:${efeito.alvo}`),
-  );
-
-  const riscos = new Set<string>();
-  if ((params.efeitos ?? []).some((efeito) => efeito.categoria === "persistencia")) {
-    riscos.add("altera_persistencia");
-  }
-  if ((params.efeitos ?? []).some((efeito) => efeitoEhPrivilegiado(efeito))) {
-    riscos.add("efeito_privilegiado");
-  }
-  if ((params.efeitos ?? []).some((efeito) => efeito.criticidade === "alta" || efeito.criticidade === "critica")) {
-    riscos.add("efeito_critico");
-  }
-  if (params.execucao?.criticidadeOperacional === "alta" || params.execucao?.criticidadeOperacional === "critica") {
-    riscos.add("execucao_critica");
-  }
-  if (contratoDadosTemSensivel(params.dados)) {
-    riscos.add("dados_sensiveis");
-  }
-  if (params.segredos?.itens.length) {
-    riscos.add("segredo_operacional");
-  }
-  if ((params.vinculos ?? []).length === 0) {
-    riscos.add("vinculo_fraco");
-  }
-
-  const checks = new Set<string>();
-  checks.add("rodar sema validar --json");
-  if ((params.output ?? []).length > 0) {
-    checks.add("verificar guarantees");
-  }
-  if ((params.vinculos ?? []).length > 0) {
-    checks.add("rodar sema drift --json");
-  }
-  if (params.auth?.explicita || params.authz?.explicita) {
-    checks.add("revisar auth e authz");
-  }
-  if (params.dados?.explicita) {
-    checks.add("validar classificacao de dados");
-  }
-  if (params.audit?.explicita) {
-    checks.add("validar trilha de auditoria");
-  }
-  if (params.forbidden?.explicita) {
-    checks.add("confirmar proibicoes operacionais");
-  }
-  if (params.superficiePublica) {
-    checks.add("validar superficie publica impactada");
-  }
-
-  return {
-    riscos: [...riscos],
-    checks: [...checks],
-    entidadesAfetadas,
-    superficiesPublicas: params.superficiePublica ? [params.superficiePublica] : [],
-    mutacoesPrevistas,
-  };
-}
-
-function recomporCaminho(campo?: CampoAst): string | undefined {
-  const valor = valorCampoCompleto(campo);
-  return valor?.replace(/\s*\/\s*/g, "/").trim();
-}
-
-function ehUseInterop(
-  use: ModuloAst["uses"][number],
-): use is ModuloAst["uses"][number] & { origem: "ts" | "py" | "dart" | "cs" | "java" | "go" | "rust" | "cpp" } {
-  return use.origem !== "sema";
-}
-
-function converterErroPublico(erro: IrErroOperacional, origemTask?: string) {
-  return {
-    nome: erro.codigo,
-    codigo: erro.codigo,
-    mensagem: erro.mensagem,
-    categoria: erro.categoria,
-    recuperabilidade: erro.recuperabilidade,
-    acaoChamador: erro.acaoChamador,
-    impactaEstado: erro.impactaEstado,
-    requerCompensacao: erro.requerCompensacao,
-    origemTask,
-  };
-}
-
-function calcularConfiancaPublica(route: IrRoute): NivelConfiancaSemantica {
-  if (route.task && route.vinculos.length > 0) {
-    return "alta";
-  }
-  if (route.task || route.vinculos.length > 0) {
-    return "media";
-  }
-  return "baixa";
-}
-
-function calcularRiscoPublico(route: IrRoute): NivelRiscoSemantico {
-  if (
-    !route.auth.explicita
-    || contratoDadosTemSensivel(route.dados)
-    || route.efeitosPublicos.some((efeito) => efeitoEhPrivilegiado(efeito) || efeito.categoria === "persistencia" || efeito.criticidade === "critica")
-  ) {
-    return "alto";
-  }
-  if (route.efeitosPublicos.length > 0 || route.errosPublicos.length > 0) {
-    return "medio";
-  }
-  return "baixo";
-}
-
-function converterSuperficie(
-  tipo: TipoSuperficieIr,
-  superficie: BlocoGenericoAst,
-): IrSuperficie {
-  const input = converterCampos(encontrarSubBloco(superficie, "input"));
-  const output = converterCampos(encontrarSubBloco(superficie, "output"));
-  const effects = (encontrarSubBloco(superficie, "effects")?.linhas ?? [])
-    .map((linha) => parsearEfeitoSemantico(linha.conteudo))
-    .filter((linha): linha is NonNullable<typeof linha> => Boolean(linha));
-  const vinculos = converterVinculos(encontrarSubBloco(superficie, "vinculos"));
-  const execucao = converterExecucao(encontrarSubBloco(superficie, "execucao"));
-  const auth = converterAuth(encontrarSubBloco(superficie, "auth"));
-  const authz = converterAuthz(encontrarSubBloco(superficie, "authz"));
-  const dados = converterDados(encontrarSubBloco(superficie, "dados"));
-  const audit = converterAudit(encontrarSubBloco(superficie, "audit"));
-  const segredos = converterSegredos(encontrarSubBloco(superficie, "segredos"));
-  const forbidden = converterForbidden(encontrarSubBloco(superficie, "forbidden"));
-  const task = valorCampoCompleto(localizarCampo(superficie, "task", "tarefa"));
-  const perfilCompatibilidade = extrairPerfil(superficie, tipo === "webhook" ? "publico" : "interno");
-  const resumoAgente = resumirAgente({
-    input,
-    output,
-    efeitos: effects,
-    vinculos,
-    execucao,
-    auth,
-    authz,
-    dados,
-    audit,
-    segredos,
-    forbidden,
-    superficiePublica: perfilCompatibilidade === "publico" ? `${tipo}:${superficie.nome ?? tipo}` : undefined,
-  });
-
-  return {
-    tipo,
-    nome: superficie.nome ?? tipo,
-    campos: converterCampos(superficie),
-    linhas: superficie.linhas.map((linha) => linha.conteudo),
-    task: task || undefined,
-    input,
-    output,
-    effects,
-    implementacoesExternas: converterImplementacoes(encontrarSubBloco(superficie, "impl")),
-    vinculos,
-    execucao,
-    auth,
-    authz,
-    dados,
-    audit,
-    segredos,
-    forbidden,
-    perfilCompatibilidade,
-    resumoAgente,
-  };
-}
-
-export function converterParaIr(modulo: ModuloAst, diagnosticos: Diagnostico[], contexto?: ContextoSemantico): IrModulo {
-  const perfilModulo = extrairPerfil(modulo.vinculos, modulo.routes.length > 0 || modulo.webhooks.length > 0 ? "publico" : "interno");
-
-  const types: IrType[] = modulo.types.map((type) => ({
-    nome: type.nome,
-    definicao: converterBloco(encontrarSubBloco(type.corpo, "fields") ?? type.corpo),
-    invariantes: (encontrarSubBloco(type.corpo, "invariants")?.linhas ?? [])
-      .map((linha) => parsearExpressaoSemantica(linha.conteudo))
-      .filter((linha): linha is NonNullable<typeof linha> => Boolean(linha)),
-  }));
-
-  const entities: IrEntity[] = modulo.entities.map((entity) => ({
-    nome: entity.nome,
-    campos: converterCampos(encontrarSubBloco(entity.corpo, "fields")),
-    invariantes: (encontrarSubBloco(entity.corpo, "invariants")?.linhas ?? [])
-      .map((linha) => parsearExpressaoSemantica(linha.conteudo))
-      .filter((linha): linha is NonNullable<typeof linha> => Boolean(linha)),
-  }));
-
-  const tarefasSemanticas = contexto?.tarefasDetalhadas ?? new Map();
-  const tasks: IrTask[] = modulo.tasks.map((task) => {
-    const input = converterCampos(task.input);
-    const output = converterCampos(task.output);
-    const effects = (task.effects?.linhas ?? [])
-      .map((linha) => parsearEfeitoSemantico(linha.conteudo))
-      .filter((linha): linha is NonNullable<typeof linha> => Boolean(linha));
-    const vinculos = converterVinculos(task.vinculos);
-    const execucao = converterExecucao(task.execucao);
-    const auth = converterAuth(encontrarSubBloco(task.corpo, "auth"));
-    const authz = converterAuthz(encontrarSubBloco(task.corpo, "authz"));
-    const dados = converterDados(encontrarSubBloco(task.corpo, "dados"));
-    const audit = converterAudit(encontrarSubBloco(task.corpo, "audit"));
-    const segredos = converterSegredos(encontrarSubBloco(task.corpo, "segredos"));
-    const forbidden = converterForbidden(encontrarSubBloco(task.corpo, "forbidden"));
-    const errosDetalhados = converterErrosTask(task.error, tarefasSemanticas.get(task.nome)?.errors);
-    const perfilCompatibilidade = extrairPerfil(task.corpo, "interno");
-    const resumoAgente = resumirAgente({
-      input,
-      output,
-      efeitos: effects,
-      vinculos,
-      execucao,
-      auth,
-      authz,
-      dados,
-      audit,
-      segredos,
-      forbidden,
-    });
-
-    return {
-      nome: task.nome,
-      input,
-      output,
-      rules: task.rules?.linhas.map((linha) => linha.conteudo) ?? [],
-      regrasEstruturadas: (task.rules?.linhas ?? [])
-        .map((linha) => parsearExpressaoSemantica(linha.conteudo))
-        .filter((linha): linha is NonNullable<typeof linha> => Boolean(linha)),
-      effects: task.effects?.linhas.map((linha) => linha.conteudo) ?? [],
-      efeitosEstruturados: effects,
-      implementacoesExternas: converterImplementacoes(task.impl),
-      vinculos,
-      execucao,
-      auth,
-      authz,
-      dados,
-      audit,
-      segredos,
-      forbidden,
-      guarantees: task.guarantees?.linhas.map((linha) => linha.conteudo) ?? [],
-      garantiasEstruturadas: (task.guarantees?.linhas ?? [])
-        .map((linha) => parsearExpressaoSemantica(linha.conteudo))
-        .filter((linha): linha is NonNullable<typeof linha> => Boolean(linha)),
-      errors: Object.fromEntries(errosDetalhados.map((erro) => [erro.codigo, erro.mensagem])),
-      errosDetalhados,
-      perfilCompatibilidade,
-      stateContract: task.state ? {
-        nomeEstado: task.state.nome ?? task.state.campos.find((campo) => campo.nome === "state" || campo.nome === "estado")?.valor,
-        campos: converterCampos(task.state),
-        linhas: task.state.linhas.map((linha) => linha.conteudo),
-        transicoes: (encontrarSubBloco(task.state, "transitions")?.linhas ?? task.state.linhas)
-          .map((linha) => parsearTransicaoEstado(linha.conteudo))
-          .filter((linha): linha is NonNullable<typeof linha> => Boolean(linha)),
-      } : undefined,
-      resumoAgente,
-      tests: (task.tests?.blocos.filter((bloco): bloco is BlocoCasoTesteAst => bloco.tipo === "caso_teste") ?? []).map(converterCaso),
-    };
-  });
-
-  const tarefasPorNome = new Map(tasks.map((task) => [task.nome, task] as const));
-
-  const flows: IrFlow[] = modulo.flows.map((flow) => {
-    const campos = converterCampos(flow.corpo);
-    const effects = (encontrarSubBloco(flow.corpo, "effects")?.linhas ?? [])
-      .map((linha) => parsearEfeitoSemantico(linha.conteudo))
-      .filter((linha): linha is NonNullable<typeof linha> => Boolean(linha));
-    const vinculos = converterVinculos(flow.vinculos);
-    const perfilCompatibilidade = extrairPerfil(flow.corpo, "interno");
-    return {
-      nome: flow.nome,
-      campos,
-      linhas: flow.corpo.linhas.map((linha) => linha.conteudo),
-      tasksReferenciadas: flow.corpo.campos
-        .filter((campo) => campo.nome === "task" || campo.nome === "tarefa")
-        .map((campo) => campo.valor),
-      etapasEstruturadas: flow.corpo.linhas
-        .map((linha) => parsearEtapaFlow(linha.conteudo))
-        .filter((linha): linha is NonNullable<typeof linha> => Boolean(linha)),
-      effects: (encontrarSubBloco(flow.corpo, "effects")?.linhas ?? []).map((linha) => linha.conteudo),
-      efeitosEstruturados: effects,
-      vinculos,
-      perfilCompatibilidade,
-      resumoAgente: resumirAgente({
-        input: campos,
-        efeitos: effects,
-        vinculos,
-      }),
-    };
-  });
-
-  const routes: IrRoute[] = modulo.routes.map((route) => ({
-    nome: route.nome,
-    campos: converterCampos(route.corpo),
-    linhas: route.corpo.linhas.map((linha) => linha.conteudo),
-    metodo: route.corpo.campos.find((campo) => campo.nome === "metodo")?.valor,
-    caminho: recomporCaminho(route.corpo.campos.find((campo) => campo.nome === "caminho")),
-    task: route.corpo.campos.find((campo) => campo.nome === "task" || campo.nome === "tarefa")?.valor,
-    inputPublico: [],
-    outputPublico: [],
-    errosPublicos: [],
-    efeitosPublicos: [],
-    vinculos: converterVinculos(route.vinculos),
-    auth: converterAuth(encontrarSubBloco(route.corpo, "auth")),
-    authz: converterAuthz(encontrarSubBloco(route.corpo, "authz")),
-    dados: converterDados(encontrarSubBloco(route.corpo, "dados")),
-    audit: converterAudit(encontrarSubBloco(route.corpo, "audit")),
-    segredos: converterSegredos(encontrarSubBloco(route.corpo, "segredos")),
-    forbidden: converterForbidden(encontrarSubBloco(route.corpo, "forbidden")),
-    perfilCompatibilidade: extrairPerfil(route.corpo, "publico"),
-    garantiasPublicasMinimas: [],
-    resumoAgente: {
-      riscos: [],
-      checks: [],
-      entidadesAfetadas: [],
-      superficiesPublicas: [],
-      mutacoesPrevistas: [],
-    },
-    publico: {
-      metodo: undefined,
-      caminho: undefined,
-      task: undefined,
-      input: [],
-      output: [],
-      errors: [],
-      effects: [],
-      garantiasMinimas: [],
-    },
-  })).map((route) => {
-    const routeAst = modulo.routes.find((item) => item.nome === route.nome)!;
-    const tarefaAssociada = route.task ? tarefasPorNome.get(route.task) : undefined;
-    const tarefaSemantica = route.task ? tarefasSemanticas.get(route.task) : undefined;
-    const inputPublicoDeclarado = converterCampos(encontrarSubBloco(routeAst.corpo, "input"));
-    const outputPublicoDeclarado = converterCampos(encontrarSubBloco(routeAst.corpo, "output"));
-    const errosDeclarados = converterErrosTask(encontrarSubBloco(routeAst.corpo, "error"), tarefaSemantica?.errors);
-    const efeitosPublicosDeclarados = (encontrarSubBloco(routeAst.corpo, "effects")?.linhas ?? [])
-      .map((linha) => parsearEfeitoSemantico(linha.conteudo))
-      .filter((linha): linha is NonNullable<typeof linha> => Boolean(linha));
-    const inputPublicoResolvido = inputPublicoDeclarado.length > 0
-      ? inputPublicoDeclarado
-      : (tarefaAssociada?.input ?? tarefaSemantica?.input?.map((campo: { nome: string; tipo: string; modificadores: string[] }) => ({
-        nome: campo.nome,
-        tipo: campo.tipo,
-        modificadores: campo.modificadores,
-        tipoOriginal: campo.tipo,
-        tipoBase: campo.tipo,
-        cardinalidade: "unitario" as const,
-        opcional: false,
-        tiposAlternativos: [],
-        refinamentos: [],
-      })) ?? []);
-    const outputPublicoResolvido = outputPublicoDeclarado.length > 0
-      ? outputPublicoDeclarado
-      : (tarefaAssociada?.output ?? tarefaSemantica?.output?.map((campo: { nome: string; tipo: string; modificadores: string[] }) => ({
-        nome: campo.nome,
-        tipo: campo.tipo,
-        modificadores: campo.modificadores,
-        tipoOriginal: campo.tipo,
-        tipoBase: campo.tipo,
-        cardinalidade: "unitario" as const,
-        opcional: false,
-        tiposAlternativos: [],
-        refinamentos: [],
-      })) ?? []);
-    const errosPublicosResolvidos = errosDeclarados.length > 0
-      ? errosDeclarados.map((erro) => converterErroPublico(erro, route.task))
-      : (tarefaAssociada?.errosDetalhados ?? (tarefaSemantica?.errors ?? []).map((erro: { codigo: string; mensagem: string }) => ({ codigo: erro.codigo, mensagem: erro.mensagem }))).map((erro: IrErroOperacional) =>
-        converterErroPublico(erro, route.task));
-    const garantiasPublicasMinimas = (tarefaAssociada?.guarantees ?? tarefaSemantica?.guarantees ?? []).filter((garantia: string) => {
-      const referencia = garantia.trim().split(/\s+/)[0] ?? "";
-      return outputPublicoResolvido.some((campo: IrCampo) => campo.nome === referencia || garantia.includes(`${campo.nome}.`));
-    });
-
-    const routeResolvida: IrRoute = {
-      ...route,
-      inputPublico: inputPublicoResolvido,
-      outputPublico: outputPublicoResolvido,
-      errosPublicos: errosPublicosResolvidos,
-      efeitosPublicos: efeitosPublicosDeclarados,
-      garantiasPublicasMinimas,
-      resumoAgente: resumirAgente({
-        input: inputPublicoResolvido,
-        output: outputPublicoResolvido,
-        efeitos: efeitosPublicosDeclarados,
-        vinculos: route.vinculos,
-        auth: route.auth,
-        authz: route.authz,
-        dados: route.dados,
-        audit: route.audit,
-        segredos: route.segredos,
-        forbidden: route.forbidden,
-        superficiePublica: `${route.metodo ?? "?"} ${route.caminho ?? "?"}`,
-      }),
-      publico: {
-        metodo: route.metodo,
-        caminho: route.caminho,
-        task: route.task,
-        input: inputPublicoResolvido,
-        output: outputPublicoResolvido,
-        errors: errosPublicosResolvidos,
-        effects: efeitosPublicosDeclarados,
-        garantiasMinimas: garantiasPublicasMinimas,
-        confiancaContrato: "media",
-        riscoRegressao: "medio",
-        divergenciasPublicas: [],
-      },
-    };
-
-    routeResolvida.publico.confiancaContrato = calcularConfiancaPublica(routeResolvida);
-    routeResolvida.publico.riscoRegressao = calcularRiscoPublico(routeResolvida);
-    return routeResolvida;
-  });
-
-  const superficies: IrSuperficie[] = [
-    ...modulo.workers.map((item) => converterSuperficie("worker", item)),
-    ...modulo.eventos.map((item) => converterSuperficie("evento", item)),
-    ...modulo.filas.map((item) => converterSuperficie("fila", item)),
-    ...modulo.crons.map((item) => converterSuperficie("cron", item)),
-    ...modulo.webhooks.map((item) => converterSuperficie("webhook", item)),
-    ...modulo.caches.map((item) => converterSuperficie("cache", item)),
-    ...modulo.storages.map((item) => converterSuperficie("storage", item)),
-    ...modulo.policies.map((item) => converterSuperficie("policy", item)),
-  ];
-
-  const states: IrState[] = modulo.states.map((state) => ({
-    nome: state.nome,
-    campos: converterCampos(encontrarSubBloco(state.corpo, "fields") ?? state.corpo),
-    linhas: state.corpo.linhas.map((linha) => linha.conteudo),
-    invariantes: (encontrarSubBloco(state.corpo, "invariants")?.linhas ?? [])
-      .map((linha) => parsearExpressaoSemantica(linha.conteudo))
-      .filter((linha): linha is NonNullable<typeof linha> => Boolean(linha)),
-    transicoes: (encontrarSubBloco(state.corpo, "transitions")?.linhas ?? [])
-      .map((linha) => parsearTransicaoEstado(linha.conteudo))
-      .filter((linha): linha is NonNullable<typeof linha> => Boolean(linha)),
-  }));
-
-  const resumoAgenteModulo = resumirAgente({
-    input: [],
-    output: [],
-    efeitos: [
-      ...tasks.flatMap((task) => task.efeitosEstruturados),
-      ...routes.flatMap((route) => route.efeitosPublicos),
-      ...superficies.flatMap((superficie) => superficie.effects),
-    ],
-    vinculos: [
-      ...converterVinculos(modulo.vinculos),
-      ...tasks.flatMap((task) => task.vinculos),
-      ...routes.flatMap((route) => route.vinculos),
-      ...superficies.flatMap((superficie) => superficie.vinculos),
-    ],
-  });
-
-  return {
-    nome: modulo.nome,
-    uses: contexto?.modulosImportados.length
-      ? [...contexto.modulosImportados]
-      : modulo.uses.filter((use) => use.origem === "sema").map((use) => use.caminho),
-    imports: modulo.uses.map((use) => ({
-      origem: use.origem,
-      caminho: use.caminho,
-      externo: use.origem !== "sema",
-    })),
-    interoperabilidades: contexto?.interoperabilidades.map((interop) => ({ ...interop })) ?? modulo.uses
-      .filter(ehUseInterop)
-      .map((use) => ({ origem: use.origem, caminho: use.caminho })),
-    vinculos: converterVinculos(modulo.vinculos),
-    perfilCompatibilidade: perfilModulo,
-    types,
-    entities,
-    enums: modulo.enums.map((enumeracao) => ({ nome: enumeracao.nome, valores: enumeracao.valores })),
-    tasks,
-    flows,
-    routes,
-    superficies,
-    states,
-    resumoAgente: {
-      ...resumoAgenteModulo,
-      superficiesPublicas: deduplicarTexto([
-        ...routes.map((route) => `${route.metodo ?? "?"} ${route.caminho ?? route.nome}`),
-        ...superficies
-          .filter((superficie) => superficie.perfilCompatibilidade === "publico")
-          .map((superficie) => `${superficie.tipo}:${superficie.nome}`),
-      ]),
-    },
-    diagnosticos,
-  };
-}