@semacode/cli 1.5.16 → 1.5.17

package/node_modules/@sema/nucleo/dist/ir/conversor.js

@@ -0,0 +1,1072 @@
+import { localizarCampoPersistencia, matrizCompatibilidadePersistencia, nomeTipoRecursoPersistencia, normalizarConsistenciaPersistencia, normalizarDurabilidadePersistencia, normalizarEngineBanco, normalizarModeloConsultaPersistencia, normalizarModeloTransacaoPersistencia, parsearBooleanoPersistencia, TIPOS_RECURSO_PERSISTENCIA, } from "../persistencia/contratos.js";
+import { contratoDadosTemSensivel, extrairContratoAudit, extrairContratoAuth, extrairContratoAuthz, extrairContratoDados, extrairContratoForbidden, extrairContratoSegredos, efeitoEhPrivilegiado, } from "../semantico/seguranca.js";
+import { parsearEfeitoSemantico, parsearEtapaFlow, parsearExpressaoSemantica, parsearTransicaoEstado } from "../semantico/estruturas.js";
+const TIPOS_PRIMITIVOS = new Set([
+    "Texto",
+    "Numero",
+    "Inteiro",
+    "Decimal",
+    "Booleano",
+    "Data",
+    "DataHora",
+    "Id",
+    "Email",
+    "Url",
+    "Json",
+    "Vazio",
+]);
+function encontrarSubBloco(bloco, palavraChave) {
+    return bloco.blocos.find((subbloco) => subbloco.tipo === "bloco_generico" && subbloco.palavraChave === palavraChave);
+}
+function localizarCampo(bloco, ...nomes) {
+    return bloco?.campos.find((campo) => nomes.includes(campo.nome));
+}
+function valorCampoCompleto(campo) {
+    if (!campo) {
+        return undefined;
+    }
+    return [campo.valor, ...campo.modificadores].join(" ").trim() || undefined;
+}
+const TIPOS_VINCULO_SUPERFICIE = new Set(["superficie", "rota", "worker", "cron", "webhook", "evento", "policy", "fila", "cache", "storage"]);
+const TIPOS_VINCULO_CAMINHO = new Set(["superficie", "rota", "webhook"]);
+function normalizarValorVinculo(tipo, valor) {
+    if (!TIPOS_VINCULO_CAMINHO.has(tipo)) {
+        return valor;
+    }
+    return valor
+        .trim()
+        .replace(/\s*\/\s*/g, "/")
+        .replace(/\s+/g, "");
+}
+function normalizarTipoDeclarado(tipo) {
+    return tipo
+        .replace(/\s*([<>\[\](),|?])\s*/g, "$1")
+        .replace(/\s+/g, "")
+        .trim();
+}
+function dividirNoNivelRaiz(texto, separador) {
+    const partes = [];
+    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, modificadores) {
+    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 = "unitario";
+    let tiposAlternativos = [];
+    let tipoItem;
+    let chaveMapa;
+    let valorMapa;
+    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) {
+    return {
+        nome: campo.nome,
+        ...analisarCampoTipo(campo.valor, campo.modificadores),
+    };
+}
+function converterCampos(bloco) {
+    if (!bloco) {
+        return [];
+    }
+    return bloco.campos.map(converterCampo);
+}
+function converterBloco(bloco) {
+    return {
+        campos: converterCampos(bloco),
+        linhas: bloco?.linhas.map((linha) => linha.conteudo) ?? [],
+        blocos: (bloco?.blocos ?? [])
+            .filter((subbloco) => subbloco.tipo === "bloco_generico")
+            .map((subbloco) => ({
+            nome: subbloco.nome ?? subbloco.palavraChave,
+            conteudo: converterBloco(subbloco),
+        })),
+    };
+}
+function converterCaso(caso) {
+    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 nomeBlocoDeclarativo(bloco) {
+    return bloco.palavraChave === "desconhecido"
+        ? (bloco.nome ?? "desconhecido")
+        : bloco.palavraChave;
+}
+function blocoTemNome(bloco, nomes) {
+    const nomeNormalizado = nomeBlocoDeclarativo(bloco).toLowerCase();
+    return nomes.includes(nomeNormalizado);
+}
+function coletarValoresBloco(bloco) {
+    if (!bloco) {
+        return [];
+    }
+    return deduplicarTexto([
+        ...bloco.linhas.map((linha) => linha.conteudo),
+        ...bloco.campos.map((campo) => valorCampoCompleto(campo) ?? campo.nome),
+    ]);
+}
+function coletarValoresSubblocos(bloco, nomes) {
+    return deduplicarTexto(bloco.blocos
+        .filter((item) => item.tipo === "bloco_generico" && blocoTemNome(item, nomes))
+        .flatMap(coletarValoresBloco));
+}
+function extrairToleranciasAuthor(bloco) {
+    const tolerancias = {};
+    for (const subbloco of bloco.blocos) {
+        if (subbloco.tipo !== "bloco_generico" || !blocoTemNome(subbloco, ["tolerancia", "tolerance"])) {
+            continue;
+        }
+        for (const campo of subbloco.campos) {
+            const valor = valorCampoCompleto(campo);
+            if (valor) {
+                tolerancias[campo.nome] = valor;
+            }
+        }
+    }
+    return tolerancias;
+}
+function extrairProibicoesAuthor(bloco) {
+    const proibicoes = [];
+    for (const subbloco of bloco.blocos) {
+        if (subbloco.tipo !== "bloco_generico"
+            || !blocoTemNome(subbloco, ["forbidden", "proibido", "avoid", "evitar", "echo", "ecos"])) {
+            continue;
+        }
+        const origem = nomeBlocoDeclarativo(subbloco);
+        for (const campo of subbloco.campos) {
+            const valor = valorCampoCompleto(campo);
+            if (valor) {
+                proibicoes.push({ tipo: campo.nome, valor, origem });
+            }
+        }
+        for (const linha of subbloco.linhas) {
+            proibicoes.push({ tipo: origem, valor: linha.conteudo, origem });
+        }
+    }
+    return proibicoes;
+}
+function converterAuthorBlock(bloco) {
+    const tipo = bloco.palavraChave;
+    return {
+        tipo,
+        nome: bloco.nome ?? tipo,
+        campos: converterCampos(bloco),
+        linhas: bloco.linhas.map((linha) => linha.conteudo),
+        proibicoes: extrairProibicoesAuthor(bloco),
+        preferencias: coletarValoresSubblocos(bloco, ["preferir", "prefer", "preferencias", "preferences"]),
+        requisitos: coletarValoresSubblocos(bloco, ["require", "requer", "requisitos", "requirements"]),
+        tolerancias: extrairToleranciasAuthor(bloco),
+        bloco: converterBloco(bloco),
+    };
+}
+const REQUISITOS_AUTHOR_AUTOMATICOS = [
+    "mostrar_por_evidencia",
+    "causa_e_consequencia",
+    "cena_com_dupla_funcao",
+    "exposicao_com_atrito",
+    "antagonista_com_logica_interna",
+    "conflito_sem_solucao_limpa",
+    "continuidade_de_personagens",
+    "misterio_em_escada",
+    "dialogo_com_subtexto",
+    "acao_com_geografia_e_dano",
+    "final_de_capitulo_sem_slogan",
+    "morte_com_peso_estrutural",
+    "especificidade_sensorial",
+    "voz_distinta_por_personagem",
+    "anti_cliche_adaptativa",
+];
+const PROIBICOES_AUTHOR_AUTOMATICAS = [
+    { tipo: "moral_explicada", valor: "emocao ou mudanca social resumida sem evidencia concreta em cena", origem: "automatico" },
+    { tipo: "cena_morta", valor: "cena que nao cumpre ao menos duas funcoes narrativas", origem: "automatico" },
+    { tipo: "exposicao_sem_atrito", valor: "lore em formato de palestra sem tensao, custo ou conflito", origem: "automatico" },
+    { tipo: "solucao_limpa", valor: "problema importante resolvido sem custo, perda ou novo problema", origem: "automatico" },
+    { tipo: "dialogo_expositivo", valor: "dialogo usado so para explicar trama ou emocao declarada", origem: "automatico" },
+    { tipo: "acao_generica", valor: "acao sem geografia, objetivo, obstaculo crescente ou dano posterior", origem: "automatico" },
+    { tipo: "final_slogan", valor: "capitulo encerrado com frase moralizante ou efeito de trailer", origem: "automatico" },
+    { tipo: "cliche", valor: "nao era sobre X, era sobre Y", origem: "automatico" },
+    { tipo: "cliche", valor: "a esperanca renasceu", origem: "automatico" },
+    { tipo: "cliche", valor: "o destino cobraria seu preco", origem: "automatico" },
+];
+const PREFERENCIAS_AUTHOR_AUTOMATICAS = [
+    "trocar abstracao por gesto, objeto, rotina quebrada ou decisao visivel",
+    "mostrar consequencia emocional, fisica, politica, logistica, moral ou relacional",
+    "plantar pista, contradicao e verdade parcial antes de revelacao grande",
+    "usar subtexto, silencio, resposta indireta ou pergunta como ataque em dialogos",
+    "terminar capitulos com decisao, imagem forte, perda concreta, ameaca especifica ou descoberta parcial",
+    "diferenciar personagens por vocabulario, ritmo de fala, tipo de silencio e forma de decidir",
+];
+function criarRegrasAuthorAutomaticas() {
+    return {
+        tipo: "style_rule",
+        nome: "regras_gerais_author",
+        campos: [],
+        linhas: [
+            "Aplicado automaticamente a todo modulo com blocos Author.",
+            "As regras sao gerais e nao pertencem a um universo especifico.",
+        ],
+        proibicoes: [...PROIBICOES_AUTHOR_AUTOMATICAS],
+        preferencias: [...PREFERENCIAS_AUTHOR_AUTOMATICAS],
+        requisitos: [...REQUISITOS_AUTHOR_AUTOMATICOS],
+        tolerancias: {
+            max_repeticao_palavra_por_trecho: "2",
+            cena_funcoes_minimas: "2",
+            morte_dimensoes_minimas: "3",
+        },
+        bloco: {
+            campos: [],
+            linhas: [
+                "automatico: verdadeiro",
+                "escopo: author_geral",
+            ],
+            blocos: [],
+        },
+    };
+}
+function converterAgent(agent) {
+    return {
+        nome: agent.nome ?? "agent",
+        role: valorCampoCompleto(localizarCampo(agent, "role", "papel")),
+        goal: valorCampoCompleto(localizarCampo(agent, "goal", "objetivo")),
+        tools: coletarValoresSubblocos(agent, ["tools", "ferramentas"]),
+        memory: coletarValoresSubblocos(agent, ["memory", "memoria"]),
+        policy: coletarValoresSubblocos(agent, ["policy", "politica"]),
+        permissions: coletarValoresSubblocos(agent, ["permissions", "permissoes"]),
+        campos: converterCampos(agent),
+        linhas: agent.linhas.map((linha) => linha.conteudo),
+        bloco: converterBloco(agent),
+    };
+}
+function coletarLinhasPersistencia(bloco, nome) {
+    if (!bloco) {
+        return [];
+    }
+    return encontrarSubBloco(bloco, nome)?.linhas.map((linha) => linha.conteudo) ?? [];
+}
+function resolverTipoRecursoPersistencia(bloco) {
+    const explicito = valorCampoCompleto(localizarCampoPersistencia(bloco, "resource_kind"));
+    if (explicito && TIPOS_RECURSO_PERSISTENCIA.has(explicito)) {
+        return explicito;
+    }
+    return nomeTipoRecursoPersistencia(bloco);
+}
+function converterCompatibilidadePersistencia(compatibilidades) {
+    return compatibilidades.map((item) => ({ ...item }));
+}
+function converterRecursoPersistencia(recurso) {
+    const resourceKind = resolverTipoRecursoPersistencia(recurso);
+    if (!resourceKind) {
+        return undefined;
+    }
+    const mode = valorCampoCompleto(localizarCampoPersistencia(recurso, "mode"));
+    const isolation = valorCampoCompleto(localizarCampoPersistencia(recurso, "isolation"));
+    return {
+        nome: recurso.nome ?? resourceKind,
+        resourceKind,
+        entity: valorCampoCompleto(localizarCampoPersistencia(recurso, "entity")),
+        collection: valorCampoCompleto(localizarCampoPersistencia(recurso, "collection")),
+        table: valorCampoCompleto(localizarCampoPersistencia(recurso, "table")),
+        consistency: normalizarConsistenciaPersistencia(valorCampoCompleto(localizarCampoPersistencia(recurso, "consistency")))
+            ?? valorCampoCompleto(localizarCampoPersistencia(recurso, "consistency")),
+        durability: normalizarDurabilidadePersistencia(valorCampoCompleto(localizarCampoPersistencia(recurso, "durability")))
+            ?? valorCampoCompleto(localizarCampoPersistencia(recurso, "durability")),
+        transactionModel: normalizarModeloTransacaoPersistencia(valorCampoCompleto(localizarCampoPersistencia(recurso, "transaction_model")))
+            ?? valorCampoCompleto(localizarCampoPersistencia(recurso, "transaction_model")),
+        queryModel: normalizarModeloConsultaPersistencia(valorCampoCompleto(localizarCampoPersistencia(recurso, "query_model")))
+            ?? valorCampoCompleto(localizarCampoPersistencia(recurso, "query_model")),
+        mode,
+        isolation,
+        strategy: valorCampoCompleto(localizarCampoPersistencia(recurso, "strategy")),
+        ttl: valorCampoCompleto(localizarCampoPersistencia(recurso, "ttl")),
+        retention: valorCampoCompleto(localizarCampoPersistencia(recurso, "retention")),
+        path: valorCampoCompleto(localizarCampoPersistencia(recurso, "path")),
+        from: valorCampoCompleto(localizarCampoPersistencia(recurso, "from")),
+        to: valorCampoCompleto(localizarCampoPersistencia(recurso, "to")),
+        surface: valorCampoCompleto(localizarCampoPersistencia(recurso, "surface")),
+        adapter: valorCampoCompleto(localizarCampoPersistencia(recurso, "adapter")),
+        portavel: parsearBooleanoPersistencia(valorCampoCompleto(localizarCampoPersistencia(recurso, "portavel"))),
+        capabilities: coletarLinhasPersistencia(recurso, "capabilities"),
+        operations: coletarLinhasPersistencia(recurso, "operations"),
+        indexing: coletarLinhasPersistencia(recurso, "indexing"),
+        guarantees: coletarLinhasPersistencia(recurso, "guarantees"),
+        diagnostics: coletarLinhasPersistencia(recurso, "diagnostics"),
+        risks: coletarLinhasPersistencia(recurso, "risks"),
+        fields: converterCampos(recurso),
+        lines: recurso.linhas.map((linha) => linha.conteudo),
+        block: converterBloco(recurso),
+        compatibilidade: converterCompatibilidadePersistencia(matrizCompatibilidadePersistencia(resourceKind, { mode, isolation })),
+    };
+}
+function converterDatabase(database) {
+    return {
+        nome: database.nome ?? "database",
+        engine: normalizarEngineBanco(valorCampoCompleto(localizarCampoPersistencia(database, "engine"))),
+        schema: valorCampoCompleto(localizarCampoPersistencia(database, "schema")),
+        database: valorCampoCompleto(localizarCampoPersistencia(database, "database")),
+        consistency: normalizarConsistenciaPersistencia(valorCampoCompleto(localizarCampoPersistencia(database, "consistency")))
+            ?? valorCampoCompleto(localizarCampoPersistencia(database, "consistency")),
+        durability: normalizarDurabilidadePersistencia(valorCampoCompleto(localizarCampoPersistencia(database, "durability")))
+            ?? valorCampoCompleto(localizarCampoPersistencia(database, "durability")),
+        transactionModel: normalizarModeloTransacaoPersistencia(valorCampoCompleto(localizarCampoPersistencia(database, "transaction_model")))
+            ?? valorCampoCompleto(localizarCampoPersistencia(database, "transaction_model")),
+        queryModel: normalizarModeloConsultaPersistencia(valorCampoCompleto(localizarCampoPersistencia(database, "query_model")))
+            ?? valorCampoCompleto(localizarCampoPersistencia(database, "query_model")),
+        portavel: parsearBooleanoPersistencia(valorCampoCompleto(localizarCampoPersistencia(database, "portavel"))),
+        adapter: valorCampoCompleto(localizarCampoPersistencia(database, "adapter")),
+        capabilities: coletarLinhasPersistencia(database, "capabilities"),
+        operations: coletarLinhasPersistencia(database, "operations"),
+        indexing: coletarLinhasPersistencia(database, "indexing"),
+        guarantees: coletarLinhasPersistencia(database, "guarantees"),
+        diagnostics: coletarLinhasPersistencia(database, "diagnostics"),
+        risks: coletarLinhasPersistencia(database, "risks"),
+        fields: converterCampos(database),
+        lines: database.linhas.map((linha) => linha.conteudo),
+        block: converterBloco(database),
+        resources: database.blocos
+            .filter((bloco) => bloco.tipo === "bloco_generico")
+            .map(converterRecursoPersistencia)
+            .filter((item) => Boolean(item)),
+    };
+}
+function converterImplementacoes(bloco) {
+    const implementacoes = [];
+    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 === "lua") {
+            implementacoes.push({ origem: "lua", caminho: campo.valor, resolucaoImpl: campo.valor, statusImpl: "nao_verificado" });
+            continue;
+        }
+        if (origem === "php") {
+            implementacoes.push({ origem: "php", 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) {
+    if (!bloco) {
+        return [];
+    }
+    const campos = bloco.campos.map((campo) => {
+        const valor = normalizarValorVinculo(campo.nome, 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: TIPOS_VINCULO_SUPERFICIE.has(campo.nome) ? valor : undefined,
+            statusResolucao: "nao_verificado",
+        };
+    });
+    const linhas = bloco.linhas.map((linha) => {
+        const [tipo, ...resto] = linha.conteudo.split(/\s+/);
+        const valor = normalizarValorVinculo(tipo ?? "desconhecido", resto.join(" ").trim());
+        return {
+            tipo: tipo ?? "desconhecido",
+            valor,
+            statusResolucao: "nao_verificado",
+        };
+    }).filter((item) => item.valor);
+    const subblocos = bloco.blocos
+        .filter((item) => 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: (() => {
+            const campo = localizarCampo(item, "superficie", "rota", "worker", "cron", "webhook", "evento");
+            return campo ? normalizarValorVinculo(campo.nome, valorCampoCompleto(campo) ?? "") : undefined;
+        })(),
+        statusResolucao: "nao_verificado",
+    }));
+    return [...campos, ...linhas, ...subblocos];
+}
+function converterExecucao(bloco) {
+    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) {
+    return extrairContratoAuth(bloco);
+}
+function converterAuthz(bloco) {
+    return extrairContratoAuthz(bloco);
+}
+function converterDados(bloco) {
+    return extrairContratoDados(bloco);
+}
+function converterAudit(bloco) {
+    return extrairContratoAudit(bloco);
+}
+function converterSegredos(bloco) {
+    return extrairContratoSegredos(bloco);
+}
+function converterForbidden(bloco) {
+    return extrairContratoForbidden(bloco);
+}
+function converterErrosTask(bloco, fallback) {
+    const erros = new Map();
+    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, padrao = "interno") {
+    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) {
+    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) {
+    return [...new Set(valores.filter(Boolean))].sort((a, b) => a.localeCompare(b, "pt-BR"));
+}
+function resumirAgente(params) {
+    const entidadesAfetadas = deduplicarTexto([
+        ...(params.input ?? []).map(tipoNaoPrimitivo).filter((item) => Boolean(item)),
+        ...(params.output ?? []).map(tipoNaoPrimitivo).filter((item) => Boolean(item)),
+        ...(params.efeitos ?? []).map((efeito) => efeito.alvo),
+    ]);
+    const mutacoesPrevistas = deduplicarTexto((params.efeitos ?? []).map((efeito) => `${efeito.categoria}:${efeito.alvo}`));
+    const riscos = new Set();
+    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();
+    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) {
+    const valor = valorCampoCompleto(campo);
+    return valor?.replace(/\s*\/\s*/g, "/").trim();
+}
+function ehUseInterop(use) {
+    return use.origem !== "sema";
+}
+function resolverReferenciaAgent(referencia, agentesConhecidos) {
+    if (!referencia) {
+        return undefined;
+    }
+    if (agentesConhecidos.has(referencia)) {
+        return referencia;
+    }
+    if (referencia.startsWith("agent.")) {
+        const nome = referencia.slice("agent.".length);
+        return agentesConhecidos.has(nome) ? nome : undefined;
+    }
+    return undefined;
+}
+function converterErroPublico(erro, origemTask) {
+    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) {
+    if (route.task && route.vinculos.length > 0) {
+        return "alta";
+    }
+    if (route.task || route.vinculos.length > 0) {
+        return "media";
+    }
+    return "baixa";
+}
+function calcularRiscoPublico(route) {
+    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, superficie) {
+    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) => 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, diagnosticos, contexto) {
+    const perfilModulo = extrairPerfil(modulo.vinculos, modulo.routes.length > 0 || modulo.webhooks.length > 0 ? "publico" : "interno");
+    const types = 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) => Boolean(linha)),
+    }));
+    const entities = 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) => Boolean(linha)),
+    }));
+    const authorDeclarado = modulo.authorBlocks.map(converterAuthorBlock);
+    const author = modulo.authorBlocks.length > 0
+        ? [criarRegrasAuthorAutomaticas(), ...authorDeclarado]
+        : authorDeclarado;
+    const agents = modulo.agents.map(converterAgent);
+    const agentsConhecidos = new Set(agents.map((agent) => agent.nome));
+    const tarefasSemanticas = contexto?.tarefasDetalhadas ?? new Map();
+    const tasks = 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) => 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) => 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) => 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) => Boolean(linha)),
+            } : undefined,
+            resumoAgente,
+            tests: (task.tests?.blocos.filter((bloco) => bloco.tipo === "caso_teste") ?? []).map(converterCaso),
+        };
+    });
+    const tarefasPorNome = new Map(tasks.map((task) => [task.nome, task]));
+    const flows = modulo.flows.map((flow) => {
+        const campos = converterCampos(flow.corpo);
+        const effects = (encontrarSubBloco(flow.corpo, "effects")?.linhas ?? [])
+            .map((linha) => parsearEfeitoSemantico(linha.conteudo))
+            .filter((linha) => Boolean(linha));
+        const vinculos = converterVinculos(flow.vinculos);
+        const perfilCompatibilidade = extrairPerfil(flow.corpo, "interno");
+        const etapasEstruturadas = flow.corpo.linhas
+            .map((linha) => parsearEtapaFlow(linha.conteudo))
+            .filter((linha) => Boolean(linha));
+        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),
+            agentsReferenciados: deduplicarTexto(etapasEstruturadas
+                .map((etapa) => resolverReferenciaAgent(etapa.task, agentsConhecidos))
+                .filter((agent) => Boolean(agent))),
+            etapasEstruturadas,
+            effects: (encontrarSubBloco(flow.corpo, "effects")?.linhas ?? []).map((linha) => linha.conteudo),
+            efeitosEstruturados: effects,
+            vinculos,
+            perfilCompatibilidade,
+            resumoAgente: resumirAgente({
+                input: campos,
+                efeitos: effects,
+                vinculos,
+            }),
+        };
+    });
+    const routes = 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) => Boolean(linha));
+        const inputPublicoResolvido = inputPublicoDeclarado.length > 0
+            ? inputPublicoDeclarado
+            : (tarefaAssociada?.input ?? tarefaSemantica?.input?.map((campo) => ({
+                nome: campo.nome,
+                tipo: campo.tipo,
+                modificadores: campo.modificadores,
+                tipoOriginal: campo.tipo,
+                tipoBase: campo.tipo,
+                cardinalidade: "unitario",
+                opcional: false,
+                tiposAlternativos: [],
+                refinamentos: [],
+            })) ?? []);
+        const outputPublicoResolvido = outputPublicoDeclarado.length > 0
+            ? outputPublicoDeclarado
+            : (tarefaAssociada?.output ?? tarefaSemantica?.output?.map((campo) => ({
+                nome: campo.nome,
+                tipo: campo.tipo,
+                modificadores: campo.modificadores,
+                tipoOriginal: campo.tipo,
+                tipoBase: campo.tipo,
+                cardinalidade: "unitario",
+                opcional: false,
+                tiposAlternativos: [],
+                refinamentos: [],
+            })) ?? []);
+        const errosPublicosResolvidos = errosDeclarados.length > 0
+            ? errosDeclarados.map((erro) => converterErroPublico(erro, route.task))
+            : (tarefaAssociada?.errosDetalhados ?? (tarefaSemantica?.errors ?? []).map((erro) => ({ codigo: erro.codigo, mensagem: erro.mensagem }))).map((erro) => converterErroPublico(erro, route.task));
+        const garantiasPublicasMinimas = (tarefaAssociada?.guarantees ?? tarefaSemantica?.guarantees ?? []).filter((garantia) => {
+            const referencia = garantia.trim().split(/\s+/)[0] ?? "";
+            return outputPublicoResolvido.some((campo) => campo.nome === referencia || garantia.includes(`${campo.nome}.`));
+        });
+        const routeResolvida = {
+            ...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 = [
+        ...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 = 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) => Boolean(linha)),
+        transicoes: (encontrarSubBloco(state.corpo, "transitions")?.linhas ?? [])
+            .map((linha) => parsearTransicaoEstado(linha.conteudo))
+            .filter((linha) => Boolean(linha)),
+    }));
+    const databases = modulo.databases.map(converterDatabase);
+    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 })),
+        author,
+        agents,
+        tasks,
+        flows,
+        routes,
+        superficies,
+        states,
+        databases,
+        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,
+    };
+}
+//# sourceMappingURL=conversor.js.map