@semacode/cli 1.5.36 → 1.5.37

package/dist/importador.js

@@ -1,2939 +1,12 @@
-import { access, readdir, readFile } from "node:fs/promises";
-import path from "node:path";
-import ts from "typescript";
-import { compilarProjeto, formatarCodigo, temErros } from "@sema/nucleo";
-import { normalizarSegmentoModulo } from "@sema/padroes";
-import { extrairSimbolosCpp } from "./cpp-symbols.js";
-import { extrairRotasDotnet, extrairSimbolosDotnet } from "./dotnet-http.js";
-import { extrairRotasGo, extrairSimbolosGo } from "./go-http.js";
-import { extrairRotasJava, extrairSimbolosJava } from "./java-http.js";
-import { extrairParametrosCaminhoFlask, extrairRotasFlaskDecoradas } from "./python-http.js";
-import { extrairRotasRust, extrairSimbolosRust } from "./rust-http.js";
-import { extrairRotasTypeScriptHttp, inferirSemanticaHandlerTypeScriptHttp, localizarExportacaoTypeScriptHttp, } from "./typescript-http.js";
-import { coletarSuperficiesAngularStandaloneConsumer } from "./angular-consumer-standalone.js";
-const DIRETORIOS_IGNORADOS = new Set([
-    ".git",
-    ".hg",
-    ".svn",
-    ".gradle",
-    ".cargo",
-    "node_modules",
-    "dist",
-    "build",
-    "bin",
-    "obj",
-    ".next",
-    ".nuxt",
-    ".dart_tool",
-    "__pycache__",
-    ".venv",
-    "venv",
-    "coverage",
-    ".tmp",
-    "generated",
-    "vendor",
-    "ephemeral",
-]);
-const SUFIXOS_WRAPPER = ["Entrada", "Saida", "Dto", "Request", "Response", "Payload", "Body", "Input", "Output"];
-const NOMES_RESERVADOS_CAMPO = new Set([
-    "module",
-    "use",
-    "type",
-    "entity",
-    "enum",
-    "task",
-    "input",
-    "output",
-    "rules",
-    "effects",
-    "impl",
-    "guarantees",
-    "state",
-    "flow",
-    "route",
-    "tests",
-    "error",
-    "docs",
-    "comments",
-    "fields",
-    "invariants",
-    "transitions",
-    "given",
-    "when",
-    "expect",
-    "caso",
-    "required",
-]);
-function escaparTexto(texto) {
-    return texto.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-}
-function paraSnakeCase(valor) {
-    return valor
-        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
-        .replace(/[^A-Za-z0-9_]+/g, "_")
-        .replace(/_{2,}/g, "_")
-        .replace(/^_+|_+$/g, "")
-        .toLowerCase();
-}
-function paraIdentificadorModulo(valor) {
-    return normalizarSegmentoModulo(valor).replace(/_+/g, "_").replace(/^_+|_+$/g, "").toLowerCase();
-}
-function normalizarNomeCampoImportado(valor) {
-    const normalizado = paraSnakeCase(valor);
-    return NOMES_RESERVADOS_CAMPO.has(normalizado)
-        ? `${normalizado}_campo`
-        : normalizado;
-}
-function nomeProjetoPadrao(diretorio) {
-    const base = path.basename(diretorio);
-    if (["src", "app", "api", "backend", "server"].includes(base.toLowerCase())) {
-        return `${path.basename(path.dirname(diretorio))}.${base}`;
-    }
-    return base;
-}
-export function inferirNamespaceBase(diretorio, namespaceExplicito) {
-    if (namespaceExplicito) {
-        return namespaceExplicito
-            .split(".")
-            .map((segmento) => paraIdentificadorModulo(segmento))
-            .filter(Boolean)
-            .join(".");
-    }
-    return ["legado", ...nomeProjetoPadrao(diretorio).split(/[\\/._-]+/g)]
-        .map((segmento) => paraIdentificadorModulo(segmento))
-        .filter(Boolean)
-        .join(".");
-}
-async function listarArquivosRecursivos(diretorio, extensoes) {
-    const entradas = await readdir(diretorio, { withFileTypes: true });
-    const encontrados = [];
-    for (const entrada of entradas) {
-        if (DIRETORIOS_IGNORADOS.has(entrada.name)) {
-            continue;
-        }
-        const caminhoAtual = path.join(diretorio, entrada.name);
-        if (entrada.isDirectory()) {
-            encontrados.push(...await listarArquivosRecursivos(caminhoAtual, extensoes));
-            continue;
-        }
-        if (extensoes.some((extensao) => entrada.name.endsWith(extensao))) {
-            encontrados.push(caminhoAtual);
-        }
-    }
-    return encontrados.sort((a, b) => a.localeCompare(b, "pt-BR"));
-}
-function inferirContextoPorArquivo(relacao, opcoes) {
-    const semExtensao = relacao.replace(/\.[^.]+$/, "");
-    const segmentosOriginais = semExtensao.split(path.sep).filter(Boolean);
-    const segmentos = segmentosOriginais.map((segmento) => paraIdentificadorModulo(segmento)).filter(Boolean);
-    if (segmentos[0] === "src" || segmentos[0] === "app") {
-        segmentos.shift();
-        segmentosOriginais.shift();
-    }
-    const ultimo = segmentos.at(-1) ?? "";
-    const semSufixo = ultimo
-        .replace(/(\.controller|\.service|\.module|_router|_service|_schemas|_contract)$/g, "")
-        .replace(/(controller|service|module|router|schemas|contract)$/g, "")
-        .replace(/_+$/g, "");
-    if (segmentos.length === 0) {
-        return ["importado"];
-    }
-    if (!opcoes?.preservarUltimo && semSufixo && semSufixo !== ultimo) {
-        segmentos[segmentos.length - 1] = semSufixo;
-    }
-    if (opcoes?.snakeCaseUltimo && segmentos.length > 0) {
-        segmentos[segmentos.length - 1] = paraSnakeCase(segmentosOriginais[segmentosOriginais.length - 1] ?? ultimo);
-    }
-    if (segmentos.length > 1 && segmentos[segmentos.length - 1] === segmentos[segmentos.length - 2]) {
-        segmentos.pop();
-    }
-    return segmentos;
-}
-function juntarCaminhoHttp(base, sufixo) {
-    const partes = [base ?? "", sufixo ?? ""]
-        .map((item) => item.trim())
-        .filter(Boolean)
-        .map((item) => item.replace(/^\/+|\/+$/g, ""));
-    const caminho = `/${partes.join("/")}`.replace(/\/+/g, "/");
-    return caminho === "//" ? "/" : caminho;
-}
-function extrairTextoLiteral(expr) {
-    if (!expr) {
-        return undefined;
-    }
-    if (ts.isStringLiteralLike(expr) || ts.isNoSubstitutionTemplateLiteral(expr)) {
-        return expr.text;
-    }
-    if (ts.isNumericLiteral(expr)) {
-        return expr.text;
-    }
-    return undefined;
-}
-function listarDecoradores(node) {
-    return ts.canHaveDecorators(node) ? ts.getDecorators(node) ?? [] : [];
-}
-function lerDecorator(node, nomes) {
-    for (const decorator of listarDecoradores(node)) {
-        const expressao = decorator.expression;
-        if (ts.isCallExpression(expressao)) {
-            const alvo = expressao.expression;
-            if (ts.isIdentifier(alvo) && nomes.includes(alvo.text)) {
-                return { nome: alvo.text, argumentos: expressao.arguments };
-            }
-        }
-        else if (ts.isIdentifier(expressao) && nomes.includes(expressao.text)) {
-            return { nome: expressao.text, argumentos: ts.factory.createNodeArray() };
-        }
-    }
-    return undefined;
-}
-function mapearTipoPrimitivo(tipo) {
-    const limpo = tipo.trim().replace(/\s+/g, "");
-    const base = limpo
-        .replace(/^Promise<(.*)>$/, "$1")
-        .replace(/^Future<(.*)>$/, "$1")
-        .replace(/\|undefined/g, "")
-        .replace(/\|null/g, "")
-        .replace(/\bundefined\|/g, "")
-        .replace(/\bnull\|/g, "")
-        .trim();
-    const minusculo = base.toLowerCase();
-    if (minusculo === "string" || minusculo === "texto") {
-        return "Texto";
-    }
-    if (minusculo === "number" || minusculo === "float" || minusculo === "double") {
-        return "Decimal";
-    }
-    if (minusculo === "int" || minusculo === "integer" || minusculo === "inteiro") {
-        return "Inteiro";
-    }
-    if (minusculo === "boolean" || minusculo === "bool") {
-        return "Booleano";
-    }
-    if (minusculo === "date") {
-        return "Data";
-    }
-    if (minusculo === "datetime" || minusculo === "timestamp") {
-        return "DataHora";
-    }
-    if (minusculo === "id" || minusculo.endsWith("id")) {
-        return "Id";
-    }
-    if (minusculo.includes("[]")
-        || minusculo.startsWith("array<")
-        || minusculo.startsWith("record<")
-        || minusculo.startsWith("map<")
-        || minusculo.startsWith("list<")
-        || minusculo.startsWith("list[")
-        || minusculo.startsWith("dict[")) {
-        return "Json";
-    }
-    if (minusculo === "json"
-        || minusculo === "object"
-        || minusculo === "unknown"
-        || minusculo === "any"
-        || minusculo === "dynamic"
-        || minusculo === "void"
-        || minusculo === "none") {
-        return minusculo === "void" || minusculo === "none" ? "Vazio" : "Json";
-    }
-    return tipo.trim();
-}
-function limparTipoBackend(tipo) {
-    if (!tipo) {
-        return undefined;
-    }
-    return tipo
-        .trim()
-        .replace(/^Task<(.+)>$/i, "$1")
-        .replace(/^ActionResult<(.+)>$/i, "$1")
-        .replace(/^IActionResult$/i, "Json")
-        .replace(/^Results<(.+)>$/i, "$1")
-        .replace(/^ResponseEntity<(.+)>$/i, "$1")
-        .replace(/^Optional<(.+)>$/i, "$1")
-        .replace(/^Result<(.+)>$/i, "$1")
-        .replace(/^impl\s+IntoResponse$/i, "Json")
-        .replace(/^Json<(.+)>$/i, "$1")
-        .replace(/^Option<(.+)>$/i, "$1")
-        .replace(/^Vec<(.+)>$/i, "Json")
-        .replace(/^List<(.+)>$/i, "Json")
-        .replace(/^Map<(.+)>$/i, "Json")
-        .replace(/^Dictionary<(.+)>$/i, "Json");
-}
-function mapearTipoBackendParaSema(tipo) {
-    const limpo = limparTipoBackend(tipo);
-    if (!limpo) {
-        return "Json";
-    }
-    const basico = mapearTipoPrimitivo(limpo);
-    if (basico !== limpo) {
-        return basico;
-    }
-    if (/\[\]$/.test(limpo) || /^(IEnumerable|IReadOnlyList|List|Vec|HashMap|Map|Dictionary)</.test(limpo)) {
-        return "Json";
-    }
-    if (/^(void|unit|\(\)|nil)$/i.test(limpo)) {
-        return "Vazio";
-    }
-    if (/\b(uuid|guid)\b/i.test(limpo)) {
-        return "Id";
-    }
-    return "Json";
-}
-function criarCampoResultadoBackend(tipo) {
-    const tipoSema = mapearTipoBackendParaSema(tipo);
-    return tipoSema === "Vazio"
-        ? []
-        : [{ nome: "resultado", tipo: tipoSema, obrigatorio: false }];
-}
-function camposDeParametrosRotaBackend(parametros) {
-    return parametros.map((parametro) => ({
-        nome: normalizarNomeCampoImportado(parametro.nome),
-        tipo: parametro.tipoSema,
-        obrigatorio: true,
-    }));
-}
-function pareceWrapperTipo(nome) {
-    return SUFIXOS_WRAPPER.some((sufixo) => nome.endsWith(sufixo)) || /(entrada|saida|dto|request|response|payload|body|input|output)/i.test(nome);
-}
-function descreverEfeitosPorHeuristica(codigo) {
-    const texto = codigo.toLowerCase();
-    const efeitos = [];
-    const adicionar = (categoria, alvo, criticidade) => {
-        if (!efeitos.some((efeito) => efeito.categoria === categoria && efeito.alvo === alvo)) {
-            efeitos.push({ categoria, alvo, criticidade });
-        }
-    };
-    if (/(prisma\.|repository\.|\.create\(|\.update\(|\.delete\(|\.save\()/i.test(codigo)) {
-        adicionar("persistencia", "banco", "alta");
-    }
-    if (/(findmany|findunique|findfirst|\.find\(|\.select\(|\.query\(|\.get\()/i.test(texto)) {
-        adicionar("consulta", "dados", "media");
-    }
-    if (/(emit\(|publish\(|dispatch\(|eventbus|event_emitter)/i.test(texto)) {
-        adicionar("evento", "dominio", "media");
-    }
-    if (/(notify|notification|sendmessage|send_email|telegram|smtp|mail)/i.test(texto)) {
-        adicionar("notificacao", "usuarios", "media");
-    }
-    if (/(audit|logger|logging|log\.|trace|observability)/i.test(texto)) {
-        adicionar("auditoria", "operacao", "baixa");
-    }
-    return efeitos;
-}
-function deduplicarDatabases(databases) {
-    const mapa = new Map();
-    for (const database of databases) {
-        const chave = `${database.engine}:${database.nome}`;
-        const existente = mapa.get(chave);
-        if (!existente) {
-            mapa.set(chave, {
-                ...database,
-                resources: [...database.resources],
-                diagnostics: [...(database.diagnostics ?? [])],
-            });
-            continue;
-        }
-        const recursos = new Map();
-        for (const recurso of [...existente.resources, ...database.resources]) {
-            recursos.set(`${recurso.tipo}:${recurso.nome}`, recurso);
-        }
-        existente.resources = [...recursos.values()];
-        existente.diagnostics = [...new Set([...(existente.diagnostics ?? []), ...(database.diagnostics ?? [])])];
-    }
-    return [...mapa.values()];
-}
-function inferirDatabasesPorHeuristica(codigo, relacao) {
-    const databases = [];
-    const adicionar = (database) => {
-        databases.push(database);
-    };
-    const texto = codigo.toLowerCase();
-    if (/(postgresql|postgres\b|node-postgres|pg\.pool|pgclient|typeorm.+postgres|sequelize.+postgres|provider\s*=\s*["']postgresql["'])/i.test(codigo)) {
-        adicionar({
-            nome: "principal_postgres",
-            resumo: `Persistencia PostgreSQL inferida automaticamente de ${relacao}.`,
-            engine: "postgres",
-            queryModel: "sql",
-            transactionModel: "mvcc",
-            resources: [
-                { tipo: "table", nome: "tabelas_relacionais", table: "legado_principal" },
-                { tipo: "query", nome: "consultas_sql", mode: "sql" },
-            ],
-            diagnostics: ["inferido_por_heuristica"],
-        });
-    }
-    if (/(mysql\b|mariadb|mysql2|typeorm.+mysql|sequelize.+mysql|provider\s*=\s*["']mysql["'])/i.test(codigo)) {
-        adicionar({
-            nome: "principal_mysql",
-            resumo: `Persistencia MySQL inferida automaticamente de ${relacao}.`,
-            engine: "mysql",
-            queryModel: "sql",
-            transactionModel: "bloqueio",
-            resources: [
-                { tipo: "table", nome: "tabelas_relacionais", table: "legado_principal" },
-                { tipo: "query", nome: "consultas_sql", mode: "sql" },
-            ],
-            diagnostics: ["inferido_por_heuristica"],
-        });
-    }
-    if (/(sqlite\b|better-sqlite3|provider\s*=\s*["']sqlite["'])/i.test(codigo)) {
-        adicionar({
-            nome: "principal_sqlite",
-            resumo: `Persistencia SQLite inferida automaticamente de ${relacao}.`,
-            engine: "sqlite",
-            queryModel: "sql",
-            transactionModel: "single_thread",
-            resources: [
-                { tipo: "table", nome: "tabelas_locais", table: "legado_local" },
-                { tipo: "query", nome: "consultas_locais", mode: "sql" },
-            ],
-            diagnostics: ["inferido_por_heuristica"],
-        });
-    }
-    if (/(mongodb|mongoose|mongo\.collection|mongoclient|prisma.+mongodb|provider\s*=\s*["']mongodb["'])/i.test(codigo)) {
-        adicionar({
-            nome: "principal_mongodb",
-            resumo: `Persistencia MongoDB inferida automaticamente de ${relacao}.`,
-            engine: "mongodb",
-            queryModel: "documento",
-            transactionModel: "documento",
-            resources: [
-                { tipo: "collection", nome: "colecoes_documentais", collection: "documentos" },
-                { tipo: "document", nome: "documentos_agregados", mode: /aggregate|\$match|\$group/i.test(codigo) ? "pipeline" : "documento" },
-            ],
-            diagnostics: ["inferido_por_heuristica"],
-        });
-    }
-    if (/(redis\b|ioredis|upstash|bullmq|xadd|xreadgroup)/i.test(codigo)) {
-        adicionar({
-            nome: "principal_redis",
-            resumo: `Persistencia Redis inferida automaticamente de ${relacao}.`,
-            engine: "redis",
-            queryModel: "chave_valor",
-            transactionModel: "single_thread",
-            resources: [
-                { tipo: "keyspace", nome: "estado_chaves", ttl: /\bttl\b|expire\(/i.test(codigo) ? "300s" : undefined },
-                { tipo: "stream", nome: "eventos_stream", surface: /bullmq|queue|worker/i.test(codigo) ? "fila" : "evento" },
-            ],
-            diagnostics: ["inferido_por_heuristica"],
-        });
-    }
-    return deduplicarDatabases(databases);
-}
-function normalizarNomeErroBruto(nome) {
-    return paraSnakeCase(nome.replace(/(Error|Erro|Exception)$/i, "")) || "erro_importado";
-}
-function extrairErrosTs(node, sourceFile) {
-    const encontrados = new Map();
-    const visitar = (atual) => {
-        if (ts.isThrowStatement(atual) && atual.expression) {
-            const expressao = atual.expression;
-            if (ts.isNewExpression(expressao)) {
-                const nomeErro = expressao.expression.getText(sourceFile);
-                const mensagem = extrairTextoLiteral(expressao.arguments?.[0]) ?? `Erro importado automaticamente de ${nomeErro}.`;
-                encontrados.set(normalizarNomeErroBruto(nomeErro), mensagem);
-            }
-        }
-        atual.forEachChild(visitar);
-    };
-    node.forEachChild(visitar);
-    return [...encontrados.entries()].map(([nome, mensagem]) => ({ nome, mensagem }));
-}
-function extrairTiposTs(sourceFile) {
-    const tipos = new Map();
-    const adicionarObjeto = (nome, campos) => {
-        if (!campos.length || tipos.has(nome)) {
-            return;
-        }
-        tipos.set(nome, { tipo: "objeto", nome, campos });
-    };
-    const adicionarEnum = (nome, valores) => {
-        if (!valores.length || tipos.has(nome)) {
-            return;
-        }
-        tipos.set(nome, { tipo: "enum", nome, valores });
-    };
-    sourceFile.forEachChild((node) => {
-        if (ts.isInterfaceDeclaration(node) && node.name) {
-            const campos = node.members
-                .filter(ts.isPropertySignature)
-                .map((member) => ({
-                nome: member.name.getText(sourceFile),
-                tipoTexto: member.type?.getText(sourceFile),
-                obrigatorio: !member.questionToken,
-            }));
-            adicionarObjeto(node.name.text, campos);
-            return;
-        }
-        if (ts.isClassDeclaration(node) && node.name) {
-            const campos = node.members
-                .filter((member) => ts.isPropertyDeclaration(member) && Boolean(member.name))
-                .map((member) => ({
-                nome: member.name.getText(sourceFile),
-                tipoTexto: member.type?.getText(sourceFile),
-                obrigatorio: !member.questionToken,
-            }));
-            adicionarObjeto(node.name.text, campos);
-            return;
-        }
-        if (ts.isTypeAliasDeclaration(node) && node.name) {
-            if (ts.isUnionTypeNode(node.type) && node.type.types.every((tipo) => ts.isLiteralTypeNode(tipo) && ts.isStringLiteralLike(tipo.literal))) {
-                adicionarEnum(node.name.text, node.type.types
-                    .map((tipo) => ts.isLiteralTypeNode(tipo) && ts.isStringLiteralLike(tipo.literal) ? tipo.literal.text : undefined)
-                    .filter((valor) => Boolean(valor)));
-                return;
-            }
-            if (ts.isTypeLiteralNode(node.type)) {
-                const campos = node.type.members
-                    .filter(ts.isPropertySignature)
-                    .map((member) => ({
-                    nome: member.name.getText(sourceFile),
-                    tipoTexto: member.type?.getText(sourceFile),
-                    obrigatorio: !member.questionToken,
-                }));
-                adicionarObjeto(node.name.text, campos);
-            }
-        }
-    });
-    return tipos;
-}
-function mapearTipoTsParaSema(tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados) {
-    if (!tipoTexto) {
-        return "Json";
-    }
-    const basico = mapearTipoPrimitivo(tipoTexto);
-    if (basico !== tipoTexto.trim()) {
-        return basico;
-    }
-    const limpo = tipoTexto
-        .trim()
-        .replace(/^Promise<(.*)>$/, "$1")
-        .replace(/\| undefined/g, "")
-        .replace(/\| null/g, "")
-        .replace(/Readonly<(.+)>/, "$1")
-        .replace(/Partial<(.+)>/, "$1")
-        .trim();
-    if (tipos.has(limpo)) {
-        const encontrado = tipos.get(limpo);
-        if (encontrado.tipo === "enum") {
-            enumsReferenciados.add(encontrado.nome);
-            return encontrado.nome;
-        }
-        if (!pareceWrapperTipo(encontrado.nome)) {
-            entidadesReferenciadas.add(encontrado.nome);
-            return encontrado.nome;
-        }
-    }
-    return "Json";
-}
-function expandirCamposTs(nomeParametro, tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados, obrigatorio) {
-    if (!tipoTexto) {
-        return [{ nome: normalizarNomeCampoImportado(nomeParametro), tipo: "Json", obrigatorio }];
-    }
-    const limpo = tipoTexto
-        .trim()
-        .replace(/^Promise<(.*)>$/, "$1")
-        .replace(/\| undefined/g, "")
-        .replace(/\| null/g, "")
-        .replace(/Readonly<(.+)>/, "$1")
-        .replace(/Partial<(.+)>/, "$1")
-        .trim();
-    const descoberto = tipos.get(limpo);
-    if (descoberto?.tipo === "objeto" && pareceWrapperTipo(descoberto.nome)) {
-        return descoberto.campos.map((campo) => ({
-            nome: normalizarNomeCampoImportado(campo.nome),
-            tipo: mapearTipoTsParaSema(campo.tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados),
-            obrigatorio: campo.obrigatorio,
-        }));
-    }
-    return [{
-            nome: normalizarNomeCampoImportado(nomeParametro),
-            tipo: mapearTipoTsParaSema(tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados),
-            obrigatorio,
-        }];
-}
-function criarEntidadesReferenciadas(tipos, entidadesReferenciadas, enumsReferenciados) {
-    const fila = [...entidadesReferenciadas];
-    const processadas = new Set();
-    const entities = [];
-    while (fila.length > 0) {
-        const nomeAtual = fila.shift();
-        if (processadas.has(nomeAtual)) {
-            continue;
-        }
-        processadas.add(nomeAtual);
-        const tipo = tipos.get(nomeAtual);
-        if (!tipo || tipo.tipo !== "objeto") {
-            continue;
-        }
-        const entidade = {
-            nome: tipo.nome,
-            campos: tipo.campos.map((campo) => ({
-                nome: normalizarNomeCampoImportado(campo.nome),
-                tipo: mapearTipoTsParaSema(campo.tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados),
-                obrigatorio: campo.obrigatorio,
-            })),
-        };
-        entities.push(entidade);
-        for (const referenciado of entidadesReferenciadas) {
-            if (!processadas.has(referenciado) && !fila.includes(referenciado)) {
-                fila.push(referenciado);
-            }
-        }
-    }
-    const enums = [...enumsReferenciados]
-        .map((nome) => tipos.get(nome))
-        .filter((item) => Boolean(item && item.tipo === "enum"))
-        .map((tipo) => ({
-        nome: tipo.nome,
-        valores: tipo.valores,
-    }))
-        .filter((enumItem, indice, lista) => lista.findIndex((item) => item.nome === enumItem.nome) === indice);
-    return { entities: deduplicarEntidades(entities), enums };
-}
-function caminhoImplTs(diretorioBase, arquivo, simbolo) {
-    const relativo = path.relative(diretorioBase, arquivo).replace(/\.[^.]+$/, "");
-    const segmentos = relativo.split(path.sep).map((segmento) => paraIdentificadorModulo(segmento)).filter(Boolean);
-    return [...segmentos, simbolo].join(".");
-}
-function mapearCampoInferidoTypeScriptHttp(campo, tipos, entidadesReferenciadas, enumsReferenciados) {
-    const tipoBasico = campo.tipoTexto ? mapearTipoPrimitivo(campo.tipoTexto) : "Json";
-    return {
-        nome: paraSnakeCase(campo.nome),
-        tipo: ["Texto", "Decimal", "Inteiro", "Booleano", "Data", "DataHora", "Id", "Json", "Vazio"].includes(tipoBasico)
-            ? tipoBasico
-            : campo.tipoTexto
-                ? mapearTipoTsParaSema(campo.tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados)
-                : "Json",
-        obrigatorio: campo.obrigatorio,
-    };
-}
-function camposDeSemanticaTypeScriptHttp(campos, tipos, entidadesReferenciadas, enumsReferenciados) {
-    return campos.map((campo) => mapearCampoInferidoTypeScriptHttp(campo, tipos, entidadesReferenciadas, enumsReferenciados));
-}
-function camposEstruturadosTypeScriptHttp(nomeParametro, tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados) {
-    const campos = expandirCamposTs(nomeParametro, tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados, false);
-    const nomeWrapper = normalizarNomeCampoImportado(nomeParametro);
-    if (campos.length === 1 && campos[0]?.nome === nomeWrapper && campos[0]?.tipo === "Json") {
-        return [];
-    }
-    return campos;
-}
-function errosPorStatusHttp(statuses) {
-    return [...new Set(statuses)].map((status) => {
-        switch (status) {
-            case 401:
-                return { nome: "nao_autorizado", mensagem: "Falha HTTP importada automaticamente com status 401." };
-            case 403:
-                return { nome: "acesso_negado", mensagem: "Falha HTTP importada automaticamente com status 403." };
-            case 404:
-                return { nome: "nao_encontrado", mensagem: "Falha HTTP importada automaticamente com status 404." };
-            case 409:
-                return { nome: "conflito", mensagem: "Falha HTTP importada automaticamente com status 409." };
-            case 422:
-                return { nome: "entrada_invalida", mensagem: "Falha HTTP importada automaticamente com status 422." };
-            case 500:
-                return { nome: "erro_interno", mensagem: "Falha HTTP importada automaticamente com status 500." };
-            default:
-                return { nome: `erro_http_${status}`, mensagem: `Falha HTTP importada automaticamente com status ${status}.` };
-        }
-    });
-}
-function resolverEscopoImportacaoNextJs(diretorioEntrada) {
-    const resolvido = path.resolve(diretorioEntrada);
-    const partes = path.parse(resolvido);
-    const relativoSemRaiz = resolvido.slice(partes.root.length);
-    const segmentos = relativoSemRaiz.split(path.sep).filter(Boolean);
-    const procurarSequencia = (sequencia) => segmentos.findIndex((segmento, indice) => sequencia.every((item, deslocamento) => segmentos[indice + deslocamento]?.toLowerCase() === item));
-    const montarBase = (indice) => indice <= 0
-        ? partes.root
-        : path.join(partes.root, ...segmentos.slice(0, indice));
-    const indiceSrcAppApi = procurarSequencia(["src", "app", "api"]);
-    if (indiceSrcAppApi >= 0) {
-        return {
-            baseProjeto: montarBase(indiceSrcAppApi),
-            diretorioEscopo: resolvido,
-        };
-    }
-    const indiceAppApi = procurarSequencia(["app", "api"]);
-    if (indiceAppApi >= 0) {
-        return {
-            baseProjeto: montarBase(indiceAppApi),
-            diretorioEscopo: resolvido,
-        };
-    }
-    const indiceSrcApp = procurarSequencia(["src", "app"]);
-    if (indiceSrcApp >= 0) {
-        return {
-            baseProjeto: montarBase(indiceSrcApp),
-            diretorioEscopo: resolvido,
-        };
-    }
-    const indiceApp = procurarSequencia(["app"]);
-    if (indiceApp >= 0) {
-        return {
-            baseProjeto: montarBase(indiceApp),
-            diretorioEscopo: resolvido,
-        };
-    }
-    return {
-        baseProjeto: resolvido,
-        diretorioEscopo: resolvido,
-    };
-}
-function normalizarCaminhoImportado(caminhoArquivo) {
-    return caminhoArquivo.replace(/\\/g, "/");
-}
-function normalizarSegmentoRotaConsumer(segmento) {
-    const opcionalCatchAll = segmento.match(/^\[\[\.\.\.([A-Za-z_]\w*)\]\]$/);
-    if (opcionalCatchAll) {
-        return `{${opcionalCatchAll[1]}}`;
-    }
-    const catchAll = segmento.match(/^\[\.\.\.([A-Za-z_]\w*)\]$/);
-    if (catchAll) {
-        return `{${catchAll[1]}}`;
-    }
-    const dinamico = segmento.match(/^\[([A-Za-z_]\w*)\]$/);
-    if (dinamico) {
-        return `{${dinamico[1]}}`;
-    }
-    return segmento;
-}
-function montarCaminhoRotaConsumer(partes) {
-    const filtradas = partes
-        .filter((segmento) => segmento && segmento !== "index" && !/^\(.*\)$/.test(segmento) && !segmento.startsWith("@"))
-        .map(normalizarSegmentoRotaConsumer);
-    return filtradas.length > 0 ? `/${filtradas.join("/")}`.replace(/\/+/g, "/") : "/";
-}
-function resolverEscopoImportacaoFrontendConsumer(diretorioEntrada) {
-    const resolvido = path.resolve(diretorioEntrada);
-    const partes = path.parse(resolvido);
-    const segmentos = resolvido.slice(partes.root.length).split(path.sep).filter(Boolean);
-    const procurarSequencia = (sequencia) => segmentos.findIndex((segmento, indice) => sequencia.every((item, deslocamento) => segmentos[indice + deslocamento]?.toLowerCase() === item));
-    const montarBase = (indice) => indice <= 0
-        ? partes.root
-        : path.join(partes.root, ...segmentos.slice(0, indice));
-    for (const sequencia of [
-        ["src", "pages"],
-        ["pages"],
-        ["src", "app", "api"],
-        ["app", "api"],
-        ["src", "app"],
-        ["app"],
-        ["src", "lib"],
-        ["lib"],
-    ]) {
-        const indice = procurarSequencia(sequencia);
-        if (indice >= 0) {
-            return {
-                baseProjeto: montarBase(indice),
-                diretorioEscopo: resolvido,
-            };
-        }
-    }
-    return {
-        baseProjeto: resolvido,
-        diretorioEscopo: resolvido,
-    };
-}
-function arquivoEhBridgeNextJsConsumer(relacaoArquivo) {
-    const relacao = normalizarCaminhoImportado(relacaoArquivo);
-    return /(?:^|\/)(?:src\/)?lib\/(?:sema_consumer_bridge|sema\/.+)\.(?:ts|tsx|js|jsx)$/i.test(relacao);
-}
-function arquivoEhBridgeReactViteConsumer(relacaoArquivo) {
-    const relacao = normalizarCaminhoImportado(relacaoArquivo);
-    return /(?:^|\/)(?:src\/)?lib\/(?:sema_consumer_bridge|sema\/.+)\.(?:ts|tsx|js|jsx)$/i.test(relacao);
-}
-function arquivoEhBridgeAngularConsumer(relacaoArquivo) {
-    const relacao = normalizarCaminhoImportado(relacaoArquivo);
-    return /(?:^|\/)(?:src\/)?app\/(?:sema_consumer_bridge|sema\/.+)\.(?:ts|js)$/i.test(relacao);
-}
-function arquivoEhSuperficieNextJsConsumer(relacaoArquivo) {
-    const relacao = normalizarCaminhoImportado(relacaoArquivo);
-    return /(?:^|\/)(?:src\/)?app\/(?:(?!api\/).)*?(?:page|layout|loading|error)\.(?:ts|tsx|js|jsx)$/i.test(relacao);
-}
-function arquivoEhSuperficieReactViteConsumer(relacaoArquivo) {
-    const relacao = normalizarCaminhoImportado(relacaoArquivo);
-    return /^(?:src\/)?pages\/.+\.(?:ts|tsx|js|jsx)$/i.test(relacao)
-        || /^(?:src\/)?App\.(?:ts|tsx|js|jsx)$/i.test(relacao);
-}
-function arquivoEhRotasReactViteConsumer(relacaoArquivo, codigo) {
-    const relacao = normalizarCaminhoImportado(relacaoArquivo);
-    return /(?:^|\/)(?:src\/)?(?:app\/)?(?:router|routes)\.(?:ts|tsx|js|jsx)$/i.test(relacao)
-        || /from\s+["']react-router-dom["']|createBrowserRouter|RouterProvider|useRoutes\s*\(|<Routes\b|<Route\b/.test(codigo ?? "");
-}
-function arquivoEhRotasAngularConsumer(relacaoArquivo) {
-    const relacao = normalizarCaminhoImportado(relacaoArquivo);
-    return /(?:^|\/)(?:src\/)?app(?:\/.+)?\/[^/]+\.routes\.(?:ts|js)$/i.test(relacao);
-}
-function arquivoEhRotasAngularConsumerRaiz(relacaoArquivo) {
-    const relacao = normalizarCaminhoImportado(relacaoArquivo);
-    return /(?:^|\/)(?:src\/)?app\/[^/]+\.routes\.(?:ts|js)$/i.test(relacao);
-}
-function arquivoEhBridgeFlutterConsumer(relacaoArquivo) {
-    const relacao = normalizarCaminhoImportado(relacaoArquivo);
-    return /(?:^|\/)(?:lib\/)?(?:sema_consumer_bridge|api\/sema_contract_bridge|sema\/.+)\.dart$/i.test(relacao);
-}
-function arquivoEhSuperficieFlutterConsumer(relacaoArquivo) {
-    const relacao = normalizarCaminhoImportado(relacaoArquivo);
-    return /(?:^|\/)(?:lib\/)?(?:screens|pages)\/.+\.dart$/i.test(relacao)
-        || /(?:^|\/)(?:lib\/)?main\.dart$/i.test(relacao);
-}
-function arquivoEhRotasFlutterConsumer(relacaoArquivo, codigo) {
-    const relacao = normalizarCaminhoImportado(relacaoArquivo);
-    return /(?:^|\/)(?:lib\/)?(?:router|app_router|routes)\.dart$/i.test(relacao)
-        || /MaterialApp(?:\.router)?\s*\(|CupertinoApp(?:\.router)?\s*\(|GoRouter\s*\(/.test(codigo ?? "");
-}
-function inferirCaminhoNextJsConsumer(relacaoArquivo) {
-    const relacao = normalizarCaminhoImportado(relacaoArquivo);
-    const segmentos = relacao.split("/");
-    const indiceSrcApp = segmentos.findIndex((segmento, indice) => segmento === "src" && segmentos[indice + 1] === "app");
-    const indiceApp = segmentos.findIndex((segmento) => segmento === "app");
-    const inicioApp = indiceSrcApp >= 0 ? indiceSrcApp + 2 : indiceApp >= 0 ? indiceApp + 1 : -1;
-    if (inicioApp < 0) {
-        return undefined;
-    }
-    const arquivoFinal = segmentos.at(-1) ?? "";
-    const tipoArquivo = arquivoFinal.match(/^(page|layout|loading|error)\.(?:ts|tsx|js|jsx)$/)?.[1];
-    if (!tipoArquivo) {
-        return undefined;
-    }
-    const caminhoAteArquivo = segmentos.slice(inicioApp, -1);
-    if (caminhoAteArquivo[0] === "api") {
-        return undefined;
-    }
-    const partes = caminhoAteArquivo
-        .filter((segmento) => segmento);
-    const caminho = montarCaminhoRotaConsumer(partes);
-    return {
-        caminho,
-        arquivo: relacao,
-        tipoArquivo,
-    };
-}
-function inferirCaminhoReactViteConsumer(relacaoArquivo) {
-    const relacao = normalizarCaminhoImportado(relacaoArquivo);
-    if (!arquivoEhSuperficieReactViteConsumer(relacao)) {
-        return undefined;
-    }
-    if (/(?:^|\/)(?:src\/)?App\.(?:ts|tsx|js|jsx)$/i.test(relacao)) {
-        return {
-            caminho: "/",
-            arquivo: relacao,
-            tipoArquivo: "app",
-        };
-    }
-    const segmentos = relacao.split("/");
-    const indiceSrcPages = segmentos.findIndex((segmento, indice) => segmento === "src" && segmentos[indice + 1] === "pages");
-    const indicePages = segmentos.findIndex((segmento) => segmento === "pages");
-    const inicioPages = indiceSrcPages >= 0 ? indiceSrcPages + 2 : indicePages >= 0 ? indicePages + 1 : -1;
-    if (inicioPages < 0) {
-        return undefined;
-    }
-    const arquivoFinal = segmentos.at(-1) ?? "";
-    const nomeBase = arquivoFinal.replace(/\.(?:ts|tsx|js|jsx)$/i, "");
-    const caminho = montarCaminhoRotaConsumer([...segmentos.slice(inicioPages, -1), nomeBase]);
-    return {
-        caminho,
-        arquivo: relacao,
-        tipoArquivo: "page",
-    };
-}
-function inferirCaminhoFlutterConsumer(relacaoArquivo) {
-    const relacao = normalizarCaminhoImportado(relacaoArquivo);
-    if (!arquivoEhSuperficieFlutterConsumer(relacao)) {
-        return undefined;
-    }
-    if (/(?:^|\/)(?:lib\/)?main\.dart$/i.test(relacao)) {
-        return {
-            caminho: "/",
-            arquivo: relacao,
-            tipoArquivo: "app",
-        };
-    }
-    const segmentos = relacao.split("/");
-    const indiceLibScreens = segmentos.findIndex((segmento, indice) => segmento === "lib" && ["screens", "pages"].includes(segmentos[indice + 1] ?? ""));
-    const indiceScreens = segmentos.findIndex((segmento) => segmento === "screens" || segmento === "pages");
-    const inicio = indiceLibScreens >= 0 ? indiceLibScreens + 2 : indiceScreens >= 0 ? indiceScreens + 1 : -1;
-    if (inicio < 0) {
-        return undefined;
-    }
-    const arquivoFinal = segmentos.at(-1) ?? "";
-    const nomeBase = arquivoFinal
-        .replace(/\.(?:dart)$/i, "")
-        .replace(/_(screen|page)$/i, "");
-    return {
-        caminho: montarCaminhoRotaConsumer([...segmentos.slice(inicio, -1), nomeBase]),
-        arquivo: relacao,
-        tipoArquivo: "screen",
-    };
-}
-function normalizarRotaDeclaradaConsumer(caminhoCru, prefixo = "/") {
-    const partesPrefixo = prefixo.replace(/^\/+|\/+$/g, "").split("/").filter(Boolean);
-    const partesCaminho = (caminhoCru ?? "").trim().replace(/^\/+|\/+$/g, "").split("/").filter(Boolean);
-    return montarCaminhoRotaConsumer([...partesPrefixo, ...partesCaminho]);
-}
-function resolverImportRelativoTypeScript(relacaoArquivoBase, especificador) {
-    if (!especificador.startsWith(".")) {
-        return undefined;
-    }
-    const baseDir = path.posix.dirname(normalizarCaminhoImportado(relacaoArquivoBase));
-    for (const sufixo of ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js", "/index.jsx"]) {
-        const candidato = path.posix.normalize(path.posix.join(baseDir, `${especificador}${sufixo}`));
-        if (!/\.(?:ts|tsx|js|jsx)$/i.test(candidato)) {
-            continue;
-        }
-        return candidato;
-    }
-    return undefined;
-}
-function extrairImportsTypeScriptConsumer(relacaoArquivo, codigo) {
-    const imports = new Map();
-    for (const match of codigo.matchAll(/import\s*\{\s*([^}]+)\s*\}\s*from\s*["']([^"']+)["']/g)) {
-        const moduloImportado = match[2];
-        const relacaoImportada = resolverImportRelativoTypeScript(relacaoArquivo, moduloImportado);
-        if (!relacaoImportada) {
-            continue;
-        }
-        for (const bruto of match[1].split(",")) {
-            const normalizado = bruto.trim();
-            if (!normalizado) {
-                continue;
-            }
-            const local = normalizado.split(/\s+as\s+/i).at(-1)?.trim();
-            if (local) {
-                imports.set(local, relacaoImportada);
-            }
-        }
-    }
-    for (const match of codigo.matchAll(/import\s+([A-Za-z_]\w*)\s+from\s*["']([^"']+)["']/g)) {
-        const relacaoImportada = resolverImportRelativoTypeScript(relacaoArquivo, match[2]);
-        const local = match[1]?.trim();
-        if (relacaoImportada && local) {
-            imports.set(local, relacaoImportada);
-        }
-    }
-    return imports;
-}
-function extrairRotasReactViteConsumer(relacaoArquivo, codigo) {
-    const imports = extrairImportsTypeScriptConsumer(relacaoArquivo, codigo);
-    const rotas = new Map();
-    const registrar = (caminhoCru, componente) => {
-        const caminho = normalizarRotaDeclaradaConsumer(caminhoCru);
-        const chave = `${caminho}:${normalizarCaminhoImportado(relacaoArquivo)}:${componente ?? "router"}`;
-        rotas.set(chave, {
-            caminho,
-            arquivoRotas: normalizarCaminhoImportado(relacaoArquivo),
-            arquivoComponente: componente ? imports.get(componente) : undefined,
-        });
-    };
-    for (const match of codigo.matchAll(/(?:path\s*:\s*["'`]([^"'`]*)["'`]|index\s*:\s*true)[\s\S]{0,260}?(?:element\s*:\s*<\s*([A-Za-z_]\w*)|Component\s*:\s*([A-Za-z_]\w*))/g)) {
-        const caminhoCru = match[1] ?? "";
-        const componente = match[2] ?? match[3];
-        registrar(caminhoCru, componente);
-    }
-    for (const match of codigo.matchAll(/<Route\b[^>]*?(?:path=["'`]([^"'`]*)["'`][^>]*?)?(index\b)?[^>]*?(?:element=\{\s*<\s*([A-Za-z_]\w*)|Component=\{\s*([A-Za-z_]\w*))/g)) {
-        const caminhoCru = match[2] ? "" : (match[1] ?? "");
-        const componente = match[3] ?? match[4];
-        registrar(caminhoCru, componente);
-    }
-    return [...rotas.values()];
-}
-function extrairRotasAngularConsumerDiretas(relacaoArquivo, codigo, prefixo = "/") {
-    const imports = extrairImportsTypeScriptConsumer(relacaoArquivo, codigo);
-    const rotas = [];
-    for (const match of codigo.matchAll(/path\s*:\s*["'`]([^"'`]*)["'`][\s\S]{0,320}?component\s*:\s*([A-Za-z_]\w*)/g)) {
-        const caminhoCru = (match[1] ?? "").trim();
-        const componente = match[2];
-        rotas.push({
-            caminho: normalizarRotaDeclaradaConsumer(caminhoCru, prefixo),
-            arquivoRotas: normalizarCaminhoImportado(relacaoArquivo),
-            arquivoComponente: imports.get(componente),
-        });
-    }
-    for (const match of codigo.matchAll(/path\s*:\s*["'`]([^"'`]*)["'`][\s\S]{0,320}?loadComponent\s*:\s*\(\s*\)\s*=>\s*import\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g)) {
-        const caminhoCru = (match[1] ?? "").trim();
-        const relacaoImportada = resolverImportRelativoTypeScript(relacaoArquivo, match[2] ?? "");
-        rotas.push({
-            caminho: normalizarRotaDeclaradaConsumer(caminhoCru, prefixo),
-            arquivoRotas: normalizarCaminhoImportado(relacaoArquivo),
-            arquivoComponente: relacaoImportada,
-        });
-    }
-    for (const match of codigo.matchAll(/path\s*:\s*["'`]([^"'`]*)["'`][\s\S]{0,360}?loadChildren\s*:\s*\(\s*\)\s*=>\s*import\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g)) {
-        const caminhoCru = (match[1] ?? "").trim();
-        const relacaoImportada = resolverImportRelativoTypeScript(relacaoArquivo, match[2] ?? "");
-        rotas.push({
-            caminho: normalizarRotaDeclaradaConsumer(caminhoCru, prefixo),
-            arquivoRotas: normalizarCaminhoImportado(relacaoArquivo),
-            arquivoRotasFilhas: relacaoImportada,
-        });
-    }
-    return rotas;
-}
-async function extrairRotasAngularConsumer(baseProjeto, relacaoArquivo, prefixo = "/", visitados = new Set()) {
-    const relacaoNormalizada = normalizarCaminhoImportado(relacaoArquivo);
-    if (visitados.has(relacaoNormalizada)) {
-        return [];
-    }
-    visitados.add(relacaoNormalizada);
-    const caminhoAbsoluto = path.join(baseProjeto, relacaoNormalizada);
-    let codigo = "";
-    try {
-        codigo = await readFile(caminhoAbsoluto, "utf8");
-    }
-    catch {
-        return [];
-    }
-    const diretas = extrairRotasAngularConsumerDiretas(relacaoNormalizada, codigo, prefixo);
-    const agregadas = [...diretas];
-    for (const rota of diretas) {
-        if (!rota.arquivoRotasFilhas) {
-            continue;
-        }
-        agregadas.push(...await extrairRotasAngularConsumer(baseProjeto, rota.arquivoRotasFilhas, rota.caminho, visitados));
-    }
-    return agregadas;
-}
-function normalizarRotaDeclaradaFlutter(caminhoCru) {
-    return montarCaminhoRotaConsumer((caminhoCru ?? "").trim().replace(/^\/+|\/+$/g, "").split("/").filter(Boolean));
-}
-function extrairRotasFlutterConsumer(relacaoArquivo, codigo) {
-    const rotas = new Map();
-    const registrar = (caminhoCru) => {
-        const caminho = normalizarRotaDeclaradaFlutter(caminhoCru);
-        rotas.set(`${caminho}:${normalizarCaminhoImportado(relacaoArquivo)}`, {
-            caminho,
-            arquivoRotas: normalizarCaminhoImportado(relacaoArquivo),
-        });
-    };
-    for (const match of codigo.matchAll(/GoRoute\s*\([\s\S]{0,220}?path\s*:\s*["'`]([^"'`]+)["'`]/g)) {
-        registrar(match[1] ?? "");
-    }
-    for (const match of codigo.matchAll(/["'`]([^"'`]+)["'`]\s*:\s*\([^)]*\)\s*=>/g)) {
-        registrar(match[1] ?? "");
-    }
-    if (/home\s*:\s*(?:const\s+)?[A-Za-z_]\w*\(/.test(codigo)) {
-        registrar("/");
-    }
-    return [...rotas.values()];
-}
-async function carregarContextosBridgeConsumer(baseProjeto, arquivosBridge) {
-    return Promise.all(arquivosBridge.map(async (arquivo) => {
-        const texto = await readFile(arquivo, "utf8");
-        const scriptKind = arquivo.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
-        return {
-            sourceFile: ts.createSourceFile(arquivo, texto, ts.ScriptTarget.Latest, true, scriptKind),
-            texto,
-            relacao: path.relative(baseProjeto, arquivo),
-        };
-    }));
-}
-function extrairTasksBridgeConsumer(baseProjeto, contextosBridge) {
-    const tiposGlobais = consolidarTiposTs(contextosBridge);
-    const entitiesRef = new Set();
-    const enumsRef = new Set();
-    const tasks = [];
-    for (const contexto of contextosBridge) {
-        contexto.sourceFile.forEachChild((node) => {
-            if (ts.isFunctionDeclaration(node) && node.name && node.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
-                const nome = node.name.text;
-                const input = node.parameters.flatMap((parametro) => expandirCamposTs(parametro.name.getText(contexto.sourceFile), parametro.type?.getText(contexto.sourceFile), tiposGlobais, entitiesRef, enumsRef, !parametro.questionToken));
-                const output = node.type?.getText(contexto.sourceFile) && mapearTipoPrimitivo(node.type.getText(contexto.sourceFile)) === "Vazio"
-                    ? []
-                    : deduplicarCampos(expandirCamposTs("resultado", node.type?.getText(contexto.sourceFile), tiposGlobais, entitiesRef, enumsRef, false));
-                tasks.push({
-                    nome: nomeTaskBridgeConsumer(nome),
-                    resumo: `Task consumer importada automaticamente de ${contexto.relacao}#${nome}.`,
-                    input: deduplicarCampos(input),
-                    output,
-                    errors: node.body ? extrairErrosTs(node.body, contexto.sourceFile) : [],
-                    effects: node.body ? descreverEfeitosPorHeuristica(node.body.getText(contexto.sourceFile)) : [],
-                    impl: { ts: caminhoImplTs(baseProjeto, path.join(baseProjeto, contexto.relacao), nome) },
-                    vinculos: deduplicarVinculos([
-                        { tipo: "arquivo", valor: normalizarCaminhoImportado(contexto.relacao) },
-                        { tipo: "simbolo", valor: caminhoImplTs(baseProjeto, path.join(baseProjeto, contexto.relacao), nome) },
-                    ]),
-                    origemArquivo: contexto.relacao,
-                    origemSimbolo: nome,
-                });
-            }
-            if (ts.isClassDeclaration(node) && node.name && node.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
-                const nomeClasse = node.name.text;
-                for (const member of node.members) {
-                    if (!ts.isMethodDeclaration(member) || !member.name || !member.body) {
-                        continue;
-                    }
-                    if (member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.PrivateKeyword || modifier.kind === ts.SyntaxKind.ProtectedKeyword)) {
-                        continue;
-                    }
-                    const nomeMetodo = member.name.getText(contexto.sourceFile);
-                    if (nomeMetodo === "constructor") {
-                        continue;
-                    }
-                    const input = member.parameters.flatMap((parametro) => expandirCamposTs(parametro.name.getText(contexto.sourceFile), parametro.type?.getText(contexto.sourceFile), tiposGlobais, entitiesRef, enumsRef, !parametro.questionToken));
-                    const output = member.type?.getText(contexto.sourceFile) && mapearTipoPrimitivo(member.type.getText(contexto.sourceFile)) === "Vazio"
-                        ? []
-                        : deduplicarCampos(expandirCamposTs("resultado", member.type?.getText(contexto.sourceFile), tiposGlobais, entitiesRef, enumsRef, false));
-                    const caminhoSimbolo = caminhoImplTs(baseProjeto, path.join(baseProjeto, contexto.relacao), `${nomeClasse}.${nomeMetodo}`);
-                    tasks.push({
-                        nome: nomeTaskBridgeConsumer(nomeMetodo),
-                        resumo: `Task consumer importada automaticamente de ${contexto.relacao}#${nomeClasse}.${nomeMetodo}.`,
-                        input: deduplicarCampos(input),
-                        output,
-                        errors: extrairErrosTs(member.body, contexto.sourceFile),
-                        effects: descreverEfeitosPorHeuristica(member.body.getText(contexto.sourceFile)),
-                        impl: { ts: caminhoSimbolo },
-                        vinculos: deduplicarVinculos([
-                            { tipo: "arquivo", valor: normalizarCaminhoImportado(contexto.relacao) },
-                            { tipo: "simbolo", valor: caminhoSimbolo },
-                        ]),
-                        origemArquivo: contexto.relacao,
-                        origemSimbolo: `${nomeClasse}.${nomeMetodo}`,
-                    });
-                }
-            }
-        });
-    }
-    const { entities, enums } = criarEntidadesReferenciadas(tiposGlobais, entitiesRef, enumsRef);
-    return {
-        tasks,
-        entities,
-        enums,
-    };
-}
-function montarVinculosSuperficiesConsumer(superficies) {
-    return deduplicarVinculos(superficies.flatMap((superficie) => [
-        { tipo: "superficie", valor: superficie.caminho },
-        { tipo: "arquivo", valor: normalizarCaminhoImportado(superficie.arquivo) },
-    ]));
-}
-async function importarConsumerBase(diretorio, namespaceBase, descricaoFramework, ehBridge, coletarSuperficies) {
-    const escopo = resolverEscopoImportacaoFrontendConsumer(diretorio);
-    const arquivos = await listarArquivosRecursivos(escopo.baseProjeto, [".ts", ".tsx", ".js", ".jsx"]);
-    const arquivosBridge = arquivos.filter((arquivo) => ehBridge(path.relative(escopo.baseProjeto, arquivo)));
-    const contextosBridge = await carregarContextosBridgeConsumer(escopo.baseProjeto, arquivosBridge);
-    const { tasks, entities, enums } = extrairTasksBridgeConsumer(escopo.baseProjeto, contextosBridge);
-    const superficiesImportadas = await coletarSuperficies(escopo.baseProjeto, arquivos);
-    const superficies = montarVinculosSuperficiesConsumer(superficiesImportadas);
-    if (tasks.length === 0 && superficies.length === 0) {
-        return [];
-    }
-    const nomeModulo = namespaceBase.endsWith(".consumer")
-        ? namespaceBase
-        : `${namespaceBase}.consumer`;
-    return [{
-            nome: nomeModulo,
-            resumo: `Rascunho Sema importado automaticamente do consumer ${descricaoFramework} em ${escopo.baseProjeto}.`,
-            tasks: deduplicarTarefas(tasks),
-            routes: [],
-            entities,
-            enums,
-            vinculos: superficies,
-        }];
-}
-async function coletarSuperficiesNextJsConsumer(baseProjeto, arquivos) {
-    return arquivos
-        .map((arquivo) => inferirCaminhoNextJsConsumer(path.relative(baseProjeto, arquivo)))
-        .filter((item) => Boolean(item));
-}
-async function coletarSuperficiesReactViteConsumer(baseProjeto, arquivos) {
-    const superficies = [];
-    for (const arquivo of arquivos) {
-        const relacao = path.relative(baseProjeto, arquivo);
-        const codigo = await readFile(arquivo, "utf8");
-        if (arquivoEhRotasReactViteConsumer(relacao, codigo)) {
-            for (const rota of extrairRotasReactViteConsumer(relacao, codigo)) {
-                superficies.push({
-                    caminho: rota.caminho,
-                    arquivo: rota.arquivoRotas,
-                    tipoArquivo: "router",
-                });
-                if (rota.arquivoComponente) {
-                    superficies.push({
-                        caminho: rota.caminho,
-                        arquivo: rota.arquivoComponente,
-                        tipoArquivo: "page",
-                    });
-                }
-            }
-        }
-    }
-    for (const arquivo of arquivos) {
-        const superficie = inferirCaminhoReactViteConsumer(path.relative(baseProjeto, arquivo));
-        if (superficie) {
-            superficies.push(superficie);
-        }
-    }
-    return superficies;
-}
-async function coletarSuperficiesAngularConsumer(baseProjeto, arquivos) {
-    const superficies = [];
-    const arquivosRotas = arquivos.filter((arquivo) => arquivoEhRotasAngularConsumer(path.relative(baseProjeto, arquivo)));
-    const arquivosRaiz = arquivosRotas.filter((arquivo) => arquivoEhRotasAngularConsumerRaiz(path.relative(baseProjeto, arquivo)));
-    const pontosEntrada = arquivosRaiz.length > 0 ? arquivosRaiz : arquivosRotas;
-    for (const arquivoRotas of pontosEntrada) {
-        const relacao = path.relative(baseProjeto, arquivoRotas);
-        for (const rota of await extrairRotasAngularConsumer(baseProjeto, relacao)) {
-            superficies.push({
-                caminho: rota.caminho,
-                arquivo: rota.arquivoRotas,
-                tipoArquivo: "routes",
-            });
-            if (rota.arquivoComponente) {
-                superficies.push({
-                    caminho: rota.caminho,
-                    arquivo: rota.arquivoComponente,
-                    tipoArquivo: "component",
-                });
-            }
-        }
-    }
-    if (superficies.length > 0) {
-        return superficies;
-    }
-    return (await coletarSuperficiesAngularStandaloneConsumer(baseProjeto, arquivos)).map((superficie) => ({
-        caminho: superficie.rota,
-        arquivo: superficie.arquivo,
-        tipoArquivo: superficie.tipoArquivo,
-    }));
-}
-async function importarNextJsConsumerBase(diretorio, namespaceBase) {
-    return importarConsumerBase(diretorio, namespaceBase, "Next.js", arquivoEhBridgeNextJsConsumer, coletarSuperficiesNextJsConsumer);
-}
-async function importarReactViteConsumerBase(diretorio, namespaceBase) {
-    return importarConsumerBase(diretorio, namespaceBase, "React/Vite", arquivoEhBridgeReactViteConsumer, coletarSuperficiesReactViteConsumer);
-}
-async function importarAngularConsumerBase(diretorio, namespaceBase) {
-    return importarConsumerBase(diretorio, namespaceBase, "Angular", arquivoEhBridgeAngularConsumer, coletarSuperficiesAngularConsumer);
-}
-async function extrairTasksBridgeFlutterConsumer(baseProjeto, arquivosBridge) {
-    const tasks = [];
-    for (const arquivo of arquivosBridge) {
-        const texto = await readFile(arquivo, "utf8");
-        const relacao = path.relative(baseProjeto, arquivo);
-        for (const match of texto.matchAll(/(?:Future<([^\n]+)>|([\w?<>.,\s]+))\s+(\w+)\(([^)]*)\)\s*(?:async\s*)?\{/g)) {
-            const retorno = (match[1] ?? match[2] ?? "").trim();
-            const nome = match[3];
-            if (["build", "toString", "hashCode"].includes(nome)) {
-                continue;
-            }
-            const parametros = match[4];
-            const input = parametros
-                .split(",")
-                .map((item) => item.trim())
-                .filter(Boolean)
-                .map((item) => item.replace(/^(required|final)\s+/g, ""))
-                .map((item) => {
-                const partes = item.split(/\s+/).filter(Boolean);
-                const nomeParametro = partes.at(-1) ?? "arg";
-                const tipoParametro = partes.slice(0, -1).join(" ");
-                return {
-                    nome: paraSnakeCase(nomeParametro),
-                    tipo: mapearTipoPrimitivo(tipoParametro || "Json"),
-                    obrigatorio: !/\?/.test(tipoParametro),
-                };
-            });
-            const caminhoSimbolo = caminhoImplDart(baseProjeto, arquivo, nome);
-            tasks.push({
-                nome: nomeTaskBridgeConsumer(nome),
-                resumo: `Task consumer importada automaticamente de ${relacao}#${nome}.`,
-                input,
-                output: retorno && mapearTipoPrimitivo(retorno) === "Vazio"
-                    ? []
-                    : [{ nome: "resultado", tipo: mapearTipoPrimitivo(retorno || "Json"), obrigatorio: false }],
-                errors: [],
-                effects: descreverEfeitosPorHeuristica(texto),
-                impl: { dart: caminhoSimbolo },
-                vinculos: deduplicarVinculos([
-                    { tipo: "arquivo", valor: normalizarCaminhoImportado(relacao) },
-                    { tipo: "simbolo", valor: caminhoSimbolo },
-                ]),
-                origemArquivo: relacao,
-                origemSimbolo: nome,
-            });
-        }
-    }
-    return tasks;
-}
-async function coletarSuperficiesFlutterConsumer(baseProjeto, arquivos) {
-    const superficies = [];
-    for (const arquivo of arquivos) {
-        const relacao = path.relative(baseProjeto, arquivo);
-        const codigo = await readFile(arquivo, "utf8");
-        if (arquivoEhRotasFlutterConsumer(relacao, codigo)) {
-            for (const rota of extrairRotasFlutterConsumer(relacao, codigo)) {
-                superficies.push({
-                    caminho: rota.caminho,
-                    arquivo: rota.arquivoRotas,
-                    tipoArquivo: "router",
-                });
-            }
-        }
-    }
-    for (const arquivo of arquivos) {
-        const superficie = inferirCaminhoFlutterConsumer(path.relative(baseProjeto, arquivo));
-        if (superficie) {
-            superficies.push(superficie);
-        }
-    }
-    return superficies;
-}
-async function importarFlutterConsumerBase(diretorio, namespaceBase) {
-    const escopo = resolverEscopoImportacaoFrontendConsumer(diretorio);
-    const arquivos = (await listarArquivosRecursivos(escopo.baseProjeto, [".dart"]))
-        .filter((arquivo) => !arquivo.endsWith(".g.dart") && !arquivo.endsWith(".freezed.dart"));
-    const arquivosBridge = arquivos.filter((arquivo) => arquivoEhBridgeFlutterConsumer(path.relative(escopo.baseProjeto, arquivo)));
-    const tasks = await extrairTasksBridgeFlutterConsumer(escopo.baseProjeto, arquivosBridge);
-    const superficiesImportadas = await coletarSuperficiesFlutterConsumer(escopo.baseProjeto, arquivos);
-    const superficies = montarVinculosSuperficiesConsumer(superficiesImportadas);
-    if (tasks.length === 0 && superficies.length === 0) {
-        return [];
-    }
-    const nomeModulo = namespaceBase.endsWith(".consumer")
-        ? namespaceBase
-        : `${namespaceBase}.consumer`;
-    return [{
-            nome: nomeModulo,
-            resumo: `Rascunho Sema importado automaticamente do consumer Flutter em ${escopo.baseProjeto}.`,
-            tasks: deduplicarTarefas(tasks),
-            routes: [],
-            entities: [],
-            enums: [],
-            vinculos: superficies,
-        }];
-}
-function nomeTaskBridgeConsumer(nome) {
-    return paraSnakeCase(nome.replace(/^sema/, "")) || paraSnakeCase(nome) || "task_consumer";
-}
-function extrairChamadaServiceTs(node) {
-    let encontrado;
-    const visitar = (atual) => {
-        if (encontrado) {
-            return;
-        }
-        if (ts.isCallExpression(atual) && ts.isPropertyAccessExpression(atual.expression)) {
-            const alvo = atual.expression.expression;
-            if (ts.isPropertyAccessExpression(alvo) && alvo.expression.kind === ts.SyntaxKind.ThisKeyword && alvo.name.text.endsWith("Service")) {
-                encontrado = atual.expression.name.text;
-                return;
-            }
-        }
-        atual.forEachChild(visitar);
-    };
-    node.forEachChild(visitar);
-    return encontrado;
-}
-function deduplicarCampos(campos) {
-    const mapa = new Map();
-    for (const campo of campos) {
-        if (!mapa.has(campo.nome)) {
-            mapa.set(campo.nome, campo);
-        }
-    }
-    return [...mapa.values()];
-}
-function deduplicarErros(errors) {
-    const mapa = new Map();
-    for (const erro of errors) {
-        if (!mapa.has(erro.nome)) {
-            mapa.set(erro.nome, erro);
-        }
-    }
-    return [...mapa.values()];
-}
-function deduplicarEfeitos(effects) {
-    const mapa = new Map();
-    for (const effect of effects) {
-        const chave = `${effect.categoria}:${effect.alvo}`;
-        if (!mapa.has(chave)) {
-            mapa.set(chave, effect);
-        }
-    }
-    return [...mapa.values()];
-}
-function deduplicarVinculos(vinculos) {
-    const mapa = new Map();
-    for (const vinculo of vinculos) {
-        const chave = `${vinculo.tipo}:${vinculo.valor}`;
-        if (!mapa.has(chave)) {
-            mapa.set(chave, vinculo);
-        }
-    }
-    return [...mapa.values()];
-}
-function deduplicarEntidades(entities) {
-    const mapa = new Map();
-    for (const entity of entities) {
-        if (!mapa.has(entity.nome)) {
-            mapa.set(entity.nome, entity);
-        }
-    }
-    return [...mapa.values()];
-}
-function deduplicarEnums(enums) {
-    const mapa = new Map();
-    for (const enumItem of enums) {
-        if (!mapa.has(enumItem.nome)) {
-            mapa.set(enumItem.nome, enumItem);
-        }
-    }
-    return [...mapa.values()];
-}
-function deduplicarTarefas(tasks) {
-    const mapa = new Map();
-    for (const task of tasks) {
-        if (!mapa.has(task.nome)) {
-            mapa.set(task.nome, task);
-            continue;
-        }
-        const existente = mapa.get(task.nome);
-        existente.input = deduplicarCampos([...existente.input, ...task.input]);
-        existente.output = deduplicarCampos([...existente.output, ...task.output]);
-        existente.errors = deduplicarErros([...existente.errors, ...task.errors]);
-        existente.effects = deduplicarEfeitos([...existente.effects, ...task.effects]);
-        existente.vinculos = deduplicarVinculos([...(existente.vinculos ?? []), ...(task.vinculos ?? [])]);
-    }
-    return [...mapa.values()];
-}
-function deduplicarRotas(routes) {
-    const mapa = new Map();
-    for (const route of routes) {
-        const chave = `${route.metodo}:${route.caminho}`;
-        if (!mapa.has(chave)) {
-            mapa.set(chave, route);
-        }
-    }
-    return [...mapa.values()];
-}
-function sincronizarRotasComTasks(routes, tasks) {
-    const mapaTasks = new Map(tasks.map((task) => [task.nome, task]));
-    for (const route of routes) {
-        const task = mapaTasks.get(route.task);
-        if (!task) {
-            continue;
-        }
-        if (route.output.length === 0) {
-            route.output = task.output.map((campo) => ({ ...campo, obrigatorio: true }));
-        }
-        if (route.errors.length === 0) {
-            route.errors = task.errors;
-        }
-    }
-}
-function renderizarCampos(bloco, campos, indentacao = "  ", sempre = false) {
-    if (campos.length === 0 && !sempre) {
-        return [];
-    }
-    return [
-        `${indentacao}${bloco} {`,
-        ...campos.map((campo) => `${indentacao}  ${normalizarNomeCampoImportado(campo.nome)}: ${campo.tipo}${campo.obrigatorio ? " required" : ""}`),
-        `${indentacao}}`,
-        "",
-    ];
-}
-function renderizarErrors(erros, indentacao = "  ") {
-    if (erros.length === 0) {
-        return [];
-    }
-    return [
-        `${indentacao}error {`,
-        ...erros.map((erro) => `${indentacao}  ${erro.nome}: "${escaparTexto(erro.mensagem)}"`),
-        `${indentacao}}`,
-        "",
-    ];
-}
-function renderizarEffects(effects, indentacao = "  ") {
-    if (effects.length === 0) {
-        return [];
-    }
-    return [
-        `${indentacao}effects {`,
-        ...effects.map((effect) => `${indentacao}  ${effect.categoria} ${effect.alvo}${effect.criticidade ? ` criticidade = ${effect.criticidade}` : ""}`),
-        `${indentacao}}`,
-        "",
-    ];
-}
-function renderizarImpl(impl, indentacao = "  ") {
-    if (!impl || Object.keys(impl).length === 0) {
-        return [];
-    }
-    return [
-        `${indentacao}impl {`,
-        ...(impl.ts ? [`${indentacao}  ts: ${impl.ts}`] : []),
-        ...(impl.py ? [`${indentacao}  py: ${impl.py}`] : []),
-        ...(impl.dart ? [`${indentacao}  dart: ${impl.dart}`] : []),
-        ...(impl.cs ? [`${indentacao}  cs: ${impl.cs}`] : []),
-        ...(impl.java ? [`${indentacao}  java: ${impl.java}`] : []),
-        ...(impl.go ? [`${indentacao}  go: ${impl.go}`] : []),
-        ...(impl.rust ? [`${indentacao}  rust: ${impl.rust}`] : []),
-        ...(impl.cpp ? [`${indentacao}  cpp: ${impl.cpp}`] : []),
-        `${indentacao}}`,
-        "",
-    ];
-}
-function renderizarValorVinculo(vinculo) {
-    if (vinculo.tipo === "simbolo") {
-        return vinculo.valor;
-    }
-    if (vinculo.tipo === "arquivo" || vinculo.valor.includes("/") || vinculo.valor.includes("\\") || vinculo.valor.includes("{")) {
-        return `"${escaparTexto(vinculo.valor)}"`;
-    }
-    return vinculo.valor;
-}
-function renderizarVinculos(vinculos, indentacao = "  ") {
-    if (!vinculos || vinculos.length === 0) {
-        return [];
-    }
-    return [
-        `${indentacao}vinculos {`,
-        ...vinculos.map((vinculo) => `${indentacao}  ${vinculo.tipo}: ${renderizarValorVinculo(vinculo)}`),
-        `${indentacao}}`,
-        "",
-    ];
-}
-function renderizarTask(task) {
-    const linhas = [
-        `  task ${task.nome} {`,
-        "    docs {",
-        `      resumo: "${escaparTexto(task.resumo)}"`,
-        "    }",
-        "",
-        ...renderizarCampos("input", task.input, "    ", true),
-        ...renderizarCampos("output", task.output, "    ", true),
-        ...renderizarEffects(task.effects, "    "),
-        ...renderizarImpl(task.impl, "    "),
-        ...renderizarVinculos(task.vinculos, "    "),
-        ...renderizarErrors(task.errors, "    "),
-    ];
-    linhas.push("    guarantees {");
-    for (const campo of task.output) {
-        linhas.push(`      ${normalizarNomeCampoImportado(campo.nome)} existe`);
-    }
-    linhas.push("    }");
-    linhas.push("");
-    linhas.push("  }");
-    linhas.push("");
-    return linhas;
-}
-function renderizarRoute(route) {
-    const caminhoRenderizado = /[{}]/.test(route.caminho)
-        ? `"${escaparTexto(route.caminho)}"`
-        : route.caminho;
-    return [
-        `  route ${route.nome} {`,
-        "    docs {",
-        `      resumo: "${escaparTexto(route.resumo)}"`,
-        "    }",
-        "",
-        `    metodo: ${route.metodo}`,
-        `    caminho: ${caminhoRenderizado}`,
-        `    task: ${route.task}`,
-        ...renderizarCampos("input", route.input, "    "),
-        ...renderizarCampos("output", route.output, "    "),
-        ...renderizarErrors(route.errors, "    "),
-        "  }",
-        "",
-    ];
-}
-function renderizarEnum(enumItem) {
-    return [
-        `  enum ${enumItem.nome} {`,
-        `    ${enumItem.valores.join(",\n    ")}`,
-        "  }",
-        "",
-    ];
-}
-function renderizarEntidade(entity) {
-    return [
-        `  entity ${entity.nome} {`,
-        "    fields {",
-        ...entity.campos.map((campo) => `      ${normalizarNomeCampoImportado(campo.nome)}: ${campo.tipo}`),
-        "    }",
-        "  }",
-        "",
-    ];
-}
-function renderizarValorDatabase(valor) {
-    if (!valor) {
-        return undefined;
-    }
-    return /[\s/{}"]/u.test(valor)
-        ? `"${escaparTexto(valor)}"`
-        : valor;
-}
-function renderizarRecursoDatabase(recurso) {
-    const linhas = [`    ${recurso.tipo} ${recurso.nome} {`];
-    const mode = renderizarValorDatabase(recurso.mode);
-    const table = renderizarValorDatabase(recurso.table);
-    const collection = renderizarValorDatabase(recurso.collection);
-    const ttl = renderizarValorDatabase(recurso.ttl);
-    const surface = renderizarValorDatabase(recurso.surface);
-    if (mode) {
-        linhas.push(`      mode: ${mode}`);
-    }
-    if (table) {
-        linhas.push(`      table: ${table}`);
-    }
-    if (collection) {
-        linhas.push(`      collection: ${collection}`);
-    }
-    if (ttl) {
-        linhas.push(`      ttl: ${ttl}`);
-    }
-    if (surface) {
-        linhas.push(`      surface: ${surface}`);
-    }
-    linhas.push("    }");
-    linhas.push("");
-    return linhas;
-}
-function renderizarDatabase(database) {
-    const queryModel = renderizarValorDatabase(database.queryModel);
-    const transactionModel = renderizarValorDatabase(database.transactionModel);
-    return [
-        `  database ${database.nome} {`,
-        `    engine: ${database.engine}`,
-        ...(queryModel ? [`    query_model: ${queryModel}`] : []),
-        ...(transactionModel ? [`    transaction_model: ${transactionModel}`] : []),
-        ...(database.diagnostics?.length
-            ? [
-                "    diagnostics {",
-                ...database.diagnostics.map((diagnostico) => `      ${diagnostico}`),
-                "    }",
-            ]
-            : []),
-        ...database.resources.flatMap(renderizarRecursoDatabase),
-        "  }",
-        "",
-    ];
-}
-function moduloParaCodigo(modulo) {
-    const linhas = [
-        `module ${modulo.nome} {`,
-        "  docs {",
-        `    resumo: "${escaparTexto(modulo.resumo)}"`,
-        "  }",
-        "",
-        ...renderizarVinculos(modulo.vinculos, "  "),
-        ...(modulo.databases ?? []).flatMap(renderizarDatabase),
-        ...modulo.enums.flatMap(renderizarEnum),
-        ...modulo.entities.flatMap(renderizarEntidade),
-        ...modulo.tasks.flatMap(renderizarTask),
-        ...modulo.routes.flatMap(renderizarRoute),
-        "}",
-        "",
-    ];
-    return linhas.join("\n");
-}
-async function formatarModuloImportado(codigo, caminhoVirtual) {
-    const formatado = formatarCodigo(codigo, caminhoVirtual);
-    return formatado.codigoFormatado ?? codigo;
-}
-function nomeArquivoModulo(modulo) {
-    const segmentos = modulo.split(".");
-    return `${segmentos.at(-1) ?? "modulo"}.sema`;
-}
-function contextoArquivoModulo(modulo, namespaceBase) {
-    const prefixo = namespaceBase.split(".");
-    const segmentos = modulo.split(".");
-    const relativos = segmentos.slice(prefixo.length, -1);
-    return relativos.length ? path.join(...relativos) : "";
-}
-function montarArquivoImportado(modulo, namespaceBase, conteudo) {
-    const pasta = contextoArquivoModulo(modulo.nome, namespaceBase);
-    const caminhoRelativo = pasta ? path.join(pasta, nomeArquivoModulo(modulo.nome)) : nomeArquivoModulo(modulo.nome);
-    return {
-        caminhoRelativo,
-        conteudo,
-        modulo: modulo.nome,
-        tarefas: modulo.tasks.length,
-        rotas: modulo.routes.length,
-        entidades: modulo.entities.length,
-        enums: modulo.enums.length,
-        databases: modulo.databases?.length ?? 0,
-    };
-}
-function consolidarTiposTs(contextos) {
-    const tipos = new Map();
-    for (const contexto of contextos) {
-        for (const [nome, tipo] of extrairTiposTs(contexto.sourceFile)) {
-            if (!tipos.has(nome)) {
-                tipos.set(nome, tipo);
-            }
-        }
-    }
-    return tipos;
-}
-function importarNestJsDeArquivo(diretorioBase, arquivo, namespaceBase, tiposGlobais) {
-    const relacao = path.relative(diretorioBase, arquivo);
-    const codigo = ts.sys.readFile(arquivo, "utf8") ?? "";
-    const sourceFile = ts.createSourceFile(arquivo, codigo, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-    const contextoSegmentos = inferirContextoPorArquivo(relacao);
-    const nomeModulo = [namespaceBase, ...contextoSegmentos].join(".");
-    const entitiesRef = new Set();
-    const enumsRef = new Set();
-    const tasks = [];
-    const routes = [];
-    for (const node of sourceFile.statements) {
-        if (!ts.isClassDeclaration(node)) {
-            continue;
-        }
-        const controllerDecorator = lerDecorator(node, ["Controller"]);
-        if (controllerDecorator) {
-            const basePath = extrairTextoLiteral(controllerDecorator.argumentos[0]);
-            for (const member of node.members) {
-                if (!ts.isMethodDeclaration(member) || !member.body) {
-                    continue;
-                }
-                const httpDecorator = lerDecorator(member, ["Get", "Post", "Put", "Patch", "Delete"]);
-                if (!httpDecorator) {
-                    continue;
-                }
-                const taskOriginal = extrairChamadaServiceTs(member.body) ?? member.name.getText(sourceFile);
-                const taskNome = paraSnakeCase(taskOriginal);
-                const routeInput = member.parameters.flatMap((parametro) => expandirCamposTs(parametro.name.getText(sourceFile), parametro.type?.getText(sourceFile), tiposGlobais, entitiesRef, enumsRef, !parametro.questionToken));
-                const routeOutputTipo = member.type?.getText(sourceFile);
-                const routeOutput = !routeOutputTipo || mapearTipoPrimitivo(routeOutputTipo) === "Vazio"
-                    ? []
-                    : deduplicarCampos(expandirCamposTs("resultado", routeOutputTipo, tiposGlobais, entitiesRef, enumsRef, false));
-                routes.push({
-                    nome: `${taskNome}_publico`,
-                    resumo: `Rota importada automaticamente de ${relacao}#${member.name.getText(sourceFile)}.`,
-                    metodo: httpDecorator.nome.toUpperCase(),
-                    caminho: juntarCaminhoHttp(basePath, extrairTextoLiteral(httpDecorator.argumentos[0])),
-                    task: taskNome,
-                    input: deduplicarCampos(routeInput),
-                    output: routeOutput,
-                    errors: [],
-                });
-            }
-        }
-        if (!node.name?.text.endsWith("Service")) {
-            continue;
-        }
-        for (const member of node.members) {
-            if (!ts.isMethodDeclaration(member) || !member.body || !member.name) {
-                continue;
-            }
-            if (member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.PrivateKeyword || modifier.kind === ts.SyntaxKind.ProtectedKeyword)) {
-                continue;
-            }
-            const nomeMetodo = member.name.getText(sourceFile);
-            if (nomeMetodo === "constructor") {
-                continue;
-            }
-            const input = member.parameters.flatMap((parametro) => expandirCamposTs(parametro.name.getText(sourceFile), parametro.type?.getText(sourceFile), tiposGlobais, entitiesRef, enumsRef, !parametro.questionToken));
-            const output = member.type?.getText(sourceFile) && mapearTipoPrimitivo(member.type.getText(sourceFile)) === "Vazio"
-                ? []
-                : deduplicarCampos(expandirCamposTs("resultado", member.type?.getText(sourceFile), tiposGlobais, entitiesRef, enumsRef, false));
-            tasks.push({
-                nome: paraSnakeCase(nomeMetodo),
-                resumo: `Task importada automaticamente de ${relacao}#${nomeMetodo}.`,
-                input: deduplicarCampos(input),
-                output,
-                errors: extrairErrosTs(member.body, sourceFile),
-                effects: descreverEfeitosPorHeuristica(member.body.getText(sourceFile)),
-                impl: { ts: caminhoImplTs(diretorioBase, arquivo, nomeMetodo) },
-                origemArquivo: relacao,
-                origemSimbolo: nomeMetodo,
-            });
-        }
-    }
-    if (!tasks.length && !routes.length) {
-        return [];
-    }
-    const { entities, enums } = criarEntidadesReferenciadas(tiposGlobais, entitiesRef, enumsRef);
-    sincronizarRotasComTasks(routes, tasks);
-    return [{
-            nome: nomeModulo,
-            resumo: `Rascunho Sema importado de um contexto NestJS legado em ${contextoSegmentos.join("/")}.`,
-            entities,
-            enums,
-            tasks: deduplicarTarefas(tasks),
-            routes: deduplicarRotas(routes),
-        }];
-}
-async function importarTypeScriptBase(diretorio, namespaceBase, modoNestjs = false) {
-    const arquivos = await listarArquivosRecursivos(diretorio, [".ts"]);
-    const uteis = arquivos.filter((arquivo) => !arquivo.endsWith(".spec.ts")
-        && !arquivo.endsWith(".test.ts")
-        && !arquivo.endsWith(".d.ts")
-        && !(modoNestjs && !arquivo.endsWith(".controller.ts") && !arquivo.endsWith(".service.ts")));
-    const contextosTodos = await Promise.all(arquivos
-        .filter((arquivo) => !arquivo.endsWith(".spec.ts") && !arquivo.endsWith(".test.ts") && !arquivo.endsWith(".d.ts"))
-        .map(async (arquivo) => {
-        const texto = await readFile(arquivo, "utf8");
-        return {
-            sourceFile: ts.createSourceFile(arquivo, texto, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS),
-            texto,
-            relacao: path.relative(diretorio, arquivo),
-        };
-    }));
-    const contextos = await Promise.all(uteis.map(async (arquivo) => {
-        const texto = await readFile(arquivo, "utf8");
-        return {
-            sourceFile: ts.createSourceFile(arquivo, texto, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS),
-            texto,
-            relacao: path.relative(diretorio, arquivo),
-        };
-    }));
-    const tiposGlobais = consolidarTiposTs(contextosTodos);
-    const modulos = new Map();
-    if (modoNestjs) {
-        for (const contexto of contextos) {
-            for (const modulo of importarNestJsDeArquivo(diretorio, path.join(diretorio, contexto.relacao), namespaceBase, tiposGlobais)) {
-                const existente = modulos.get(modulo.nome);
-                if (!existente) {
-                    modulos.set(modulo.nome, modulo);
-                    continue;
-                }
-                existente.tasks = deduplicarTarefas([...existente.tasks, ...modulo.tasks]);
-                existente.routes = deduplicarRotas([...existente.routes, ...modulo.routes]);
-                existente.entities = deduplicarEntidades([...existente.entities, ...modulo.entities]);
-                existente.enums = deduplicarEnums([...existente.enums, ...modulo.enums]);
-            }
-        }
-        return [...modulos.values()];
-    }
-    for (const contexto of contextos) {
-        const entitiesRef = new Set();
-        const enumsRef = new Set();
-        const contextoSegmentos = inferirContextoPorArquivo(contexto.relacao);
-        const nomeModulo = [namespaceBase, ...contextoSegmentos].join(".");
-        const tasks = [];
-        contexto.sourceFile.forEachChild((node) => {
-            if (ts.isFunctionDeclaration(node) && node.name && node.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
-                const nome = node.name.text;
-                const input = node.parameters.flatMap((parametro) => expandirCamposTs(parametro.name.getText(contexto.sourceFile), parametro.type?.getText(contexto.sourceFile), tiposGlobais, entitiesRef, enumsRef, !parametro.questionToken));
-                const output = node.type?.getText(contexto.sourceFile) && mapearTipoPrimitivo(node.type.getText(contexto.sourceFile)) === "Vazio"
-                    ? []
-                    : deduplicarCampos(expandirCamposTs("resultado", node.type?.getText(contexto.sourceFile), tiposGlobais, entitiesRef, enumsRef, false));
-                const errors = node.body ? extrairErrosTs(node.body, contexto.sourceFile) : [];
-                const effects = node.body ? descreverEfeitosPorHeuristica(node.body.getText(contexto.sourceFile)) : [];
-                tasks.push({
-                    nome: paraSnakeCase(nome),
-                    resumo: `Task importada automaticamente de ${contexto.relacao}#${nome}.`,
-                    input: deduplicarCampos(input),
-                    output,
-                    errors,
-                    effects,
-                    impl: { ts: caminhoImplTs(diretorio, path.join(diretorio, contexto.relacao), nome) },
-                    origemArquivo: contexto.relacao,
-                    origemSimbolo: nome,
-                });
-            }
-            if (ts.isClassDeclaration(node) && node.name && node.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
-                const nomeClasse = node.name.text;
-                for (const member of node.members) {
-                    if (!ts.isMethodDeclaration(member) || !member.name || !member.body) {
-                        continue;
-                    }
-                    if (member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.PrivateKeyword || modifier.kind === ts.SyntaxKind.ProtectedKeyword)) {
-                        continue;
-                    }
-                    const nomeMetodo = member.name.getText(contexto.sourceFile);
-                    if (nomeMetodo === "constructor") {
-                        continue;
-                    }
-                    const input = member.parameters.flatMap((parametro) => expandirCamposTs(parametro.name.getText(contexto.sourceFile), parametro.type?.getText(contexto.sourceFile), tiposGlobais, entitiesRef, enumsRef, !parametro.questionToken));
-                    const output = member.type?.getText(contexto.sourceFile) && mapearTipoPrimitivo(member.type.getText(contexto.sourceFile)) === "Vazio"
-                        ? []
-                        : deduplicarCampos(expandirCamposTs("resultado", member.type?.getText(contexto.sourceFile), tiposGlobais, entitiesRef, enumsRef, false));
-                    tasks.push({
-                        nome: paraSnakeCase(nomeMetodo),
-                        resumo: `Task importada automaticamente de ${contexto.relacao}#${nomeClasse}.${nomeMetodo}.`,
-                        input: deduplicarCampos(input),
-                        output,
-                        errors: extrairErrosTs(member.body, contexto.sourceFile),
-                        effects: descreverEfeitosPorHeuristica(member.body.getText(contexto.sourceFile)),
-                        impl: { ts: caminhoImplTs(diretorio, path.join(diretorio, contexto.relacao), `${nomeClasse}.${nomeMetodo}`) },
-                        origemArquivo: contexto.relacao,
-                        origemSimbolo: `${nomeClasse}.${nomeMetodo}`,
-                    });
-                }
-            }
-        });
-        if (tasks.length === 0) {
-            continue;
-        }
-        const { entities, enums } = criarEntidadesReferenciadas(tiposGlobais, entitiesRef, enumsRef);
-        modulos.set(nomeModulo, {
-            nome: nomeModulo,
-            resumo: `Rascunho Sema importado automaticamente de ${contexto.relacao}.`,
-            tasks: deduplicarTarefas(tasks),
-            routes: [],
-            entities,
-            enums,
-        });
-    }
-    return [...modulos.values()];
-}
-function nomeTaskParaRotaTypeScript(caminho, metodo) {
-    const segmentos = caminho
-        .replace(/^\/+|\/+$/g, "")
-        .split("/")
-        .filter(Boolean)
-        .map((segmento) => segmento.replace(/[{}]/g, ""));
-    return paraSnakeCase([...segmentos, metodo.toLowerCase()].join("_")) || `rota_${metodo.toLowerCase()}`;
-}
-function camposDeParametrosRotaTypeScript(parametros) {
-    return parametros.map((parametro) => ({
-        nome: paraSnakeCase(parametro.nome),
-        tipo: parametro.tipoSema,
-        obrigatorio: true,
-    }));
-}
-function extrairColecoesFirebaseImportacao(texto) {
-    const encontrados = new Set();
-    for (const match of texto.matchAll(/\b(?:export\s+)?const\s+\w*COLLECTIONS?\w*\s*=\s*\{([\s\S]*?)\n\}/g)) {
-        const corpo = match[1] ?? "";
-        for (const valor of corpo.matchAll(/:\s*["'`]([^"'`]+)["'`]/g)) {
-            encontrados.add(valor[1]);
-        }
-    }
-    return [...encontrados];
-}
-async function importarNextJsBase(diretorio, namespaceBase) {
-    const escopo = resolverEscopoImportacaoNextJs(diretorio);
-    const arquivos = await listarArquivosRecursivos(escopo.diretorioEscopo, [".ts", ".tsx", ".js", ".jsx"]);
-    const uteis = arquivos.filter((arquivo) => !arquivo.endsWith(".spec.ts")
-        && !arquivo.endsWith(".test.ts")
-        && !arquivo.endsWith(".d.ts")
-        && /(\\|\/)(?:src\\|src\/)?app(\\|\/)api(\\|\/).+(\\|\/)route\.(ts|tsx|js|jsx)$/i.test(arquivo));
-    const contextos = await Promise.all(uteis.map(async (arquivo) => {
-        const texto = await readFile(arquivo, "utf8");
-        const scriptKind = arquivo.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
-        return {
-            sourceFile: ts.createSourceFile(arquivo, texto, ts.ScriptTarget.Latest, true, scriptKind),
-            texto,
-            relacao: path.relative(escopo.baseProjeto, arquivo),
-        };
-    }));
-    const tiposGlobais = consolidarTiposTs(contextos);
-    const modulos = new Map();
-    for (const contexto of contextos) {
-        const entitiesRef = new Set();
-        const enumsRef = new Set();
-        const contextoSegmentos = inferirContextoPorArquivo(contexto.relacao.replace(/[\\/]route\.(?:ts|tsx|js|jsx)$/i, "")).filter((segmento, indice) => !(indice === 0 && segmento === "app"));
-        const nomeModulo = [namespaceBase, ...contextoSegmentos].join(".");
-        const tasks = [];
-        const routes = [];
-        for (const rota of extrairRotasTypeScriptHttp(contexto.sourceFile, contexto.relacao).filter((item) => item.origem === "nextjs")) {
-            const taskNome = nomeTaskParaRotaTypeScript(rota.caminho, rota.metodo);
-            const exportacao = localizarExportacaoTypeScriptHttp(contexto.sourceFile, rota.simbolo);
-            const semantica = inferirSemanticaHandlerTypeScriptHttp(contexto.sourceFile, rota.simbolo);
-            const input = deduplicarCampos([
-                ...camposDeParametrosRotaTypeScript(rota.parametros),
-                ...camposDeSemanticaTypeScriptHttp(semantica?.query ?? [], tiposGlobais, entitiesRef, enumsRef),
-                ...camposEstruturadosTypeScriptHttp("body", semantica?.bodyTipoTexto, tiposGlobais, entitiesRef, enumsRef),
-                ...camposDeSemanticaTypeScriptHttp(semantica?.body ?? [], tiposGlobais, entitiesRef, enumsRef),
-            ]);
-            const output = semantica && semantica.response.length > 0
-                ? deduplicarCampos(camposDeSemanticaTypeScriptHttp(semantica.response, tiposGlobais, entitiesRef, enumsRef))
-                : semantica?.responseTipoTexto
-                    ? deduplicarCampos(expandirCamposTs("resultado", semantica.responseTipoTexto, tiposGlobais, entitiesRef, enumsRef, false))
-                    : exportacao?.retorno && mapearTipoPrimitivo(exportacao.retorno) === "Vazio"
-                        ? []
-                        : deduplicarCampos(expandirCamposTs("resultado", exportacao?.retorno, tiposGlobais, entitiesRef, enumsRef, false));
-            const taskOutput = output.length > 0 ? output : [{ nome: "resultado", tipo: "Json", obrigatorio: false }];
-            const resumoBase = `Rota Next.js App Router importada automaticamente de ${contexto.relacao}#${rota.simbolo}.`;
-            const errors = deduplicarErros([
-                ...(exportacao?.corpo ? extrairErrosTs(exportacao.corpo, contexto.sourceFile) : []),
-                ...errosPorStatusHttp(semantica?.errorStatuses ?? []),
-            ]);
-            tasks.push({
-                nome: taskNome,
-                resumo: `Task derivada automaticamente de ${contexto.relacao}#${rota.simbolo}.`,
-                input,
-                output: taskOutput,
-                errors,
-                effects: exportacao?.corpo ? descreverEfeitosPorHeuristica(exportacao.corpo.getText(contexto.sourceFile)) : descreverEfeitosPorHeuristica(contexto.texto),
-                impl: { ts: caminhoImplTs(escopo.baseProjeto, path.join(escopo.baseProjeto, contexto.relacao), rota.simbolo) },
-                origemArquivo: contexto.relacao,
-                origemSimbolo: rota.simbolo,
-            });
-            routes.push({
-                nome: `${taskNome}_publico`,
-                resumo: resumoBase,
-                metodo: rota.metodo,
-                caminho: rota.caminho,
-                task: taskNome,
-                input,
-                output: taskOutput,
-                errors,
-            });
-        }
-        if (!tasks.length && !routes.length) {
-            continue;
-        }
-        sincronizarRotasComTasks(routes, tasks);
-        const { entities, enums } = criarEntidadesReferenciadas(tiposGlobais, entitiesRef, enumsRef);
-        modulos.set(nomeModulo, {
-            nome: nomeModulo,
-            resumo: `Rascunho Sema importado automaticamente de ${contexto.relacao}.`,
-            tasks: deduplicarTarefas(tasks),
-            routes: deduplicarRotas(routes),
-            entities,
-            enums,
-        });
-    }
-    return [...modulos.values()];
-}
-async function importarFirebaseBase(diretorio, namespaceBase) {
-    const arquivos = await listarArquivosRecursivos(diretorio, [".ts", ".tsx", ".js", ".jsx"]);
-    const uteis = arquivos.filter((arquivo) => !arquivo.endsWith(".spec.ts")
-        && !arquivo.endsWith(".test.ts")
-        && !arquivo.endsWith(".d.ts")
-        && /(sema_contract_bridge|health-check|collections?|firestore)/i.test(arquivo));
-    const contextos = await Promise.all(uteis.map(async (arquivo) => {
-        const texto = await readFile(arquivo, "utf8");
-        const scriptKind = arquivo.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
-        return {
-            sourceFile: ts.createSourceFile(arquivo, texto, ts.ScriptTarget.Latest, true, scriptKind),
-            texto,
-            relacao: path.relative(diretorio, arquivo),
-        };
-    }));
-    const tiposGlobais = consolidarTiposTs(contextos);
-    const modulos = new Map();
-    for (const contexto of contextos) {
-        const entitiesRef = new Set();
-        const enumsRef = new Set();
-        const contextoSegmentos = inferirContextoPorArquivo(contexto.relacao);
-        const nomeModulo = [namespaceBase, ...contextoSegmentos].join(".");
-        const tasks = [];
-        const routes = [];
-        for (const node of contexto.sourceFile.statements) {
-            if (ts.isFunctionDeclaration(node) && node.name && node.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
-                const nome = node.name.text;
-                const input = node.parameters.flatMap((parametro) => expandirCamposTs(parametro.name.getText(contexto.sourceFile), parametro.type?.getText(contexto.sourceFile), tiposGlobais, entitiesRef, enumsRef, !parametro.questionToken));
-                const output = node.type?.getText(contexto.sourceFile) && mapearTipoPrimitivo(node.type.getText(contexto.sourceFile)) === "Vazio"
-                    ? []
-                    : deduplicarCampos(expandirCamposTs("resultado", node.type?.getText(contexto.sourceFile), tiposGlobais, entitiesRef, enumsRef, false));
-                tasks.push({
-                    nome: paraSnakeCase(nome.replace(/^sema/, "")) || paraSnakeCase(nome),
-                    resumo: `Task Firebase/worker importada automaticamente de ${contexto.relacao}#${nome}.`,
-                    input: deduplicarCampos(input),
-                    output: output.length > 0 ? output : [{ nome: "resultado", tipo: "Json", obrigatorio: false }],
-                    errors: node.body ? extrairErrosTs(node.body, contexto.sourceFile) : [],
-                    effects: node.body ? descreverEfeitosPorHeuristica(node.body.getText(contexto.sourceFile)) : descreverEfeitosPorHeuristica(contexto.texto),
-                    impl: { ts: caminhoImplTs(diretorio, path.join(diretorio, contexto.relacao), nome) },
-                    origemArquivo: contexto.relacao,
-                    origemSimbolo: nome,
-                });
-            }
-        }
-        for (const rota of extrairRotasTypeScriptHttp(contexto.sourceFile, contexto.relacao).filter((item) => item.origem === "firebase")) {
-            const taskNome = nomeTaskParaRotaTypeScript(rota.caminho, rota.metodo);
-            const exportacao = localizarExportacaoTypeScriptHttp(contexto.sourceFile, rota.simbolo);
-            const input = deduplicarCampos(camposDeParametrosRotaTypeScript(rota.parametros));
-            const output = exportacao?.retorno && mapearTipoPrimitivo(exportacao.retorno) === "Vazio"
-                ? []
-                : deduplicarCampos(expandirCamposTs("resultado", exportacao?.retorno, tiposGlobais, entitiesRef, enumsRef, false));
-            const taskOutput = output.length > 0 ? output : [{ nome: "resultado", tipo: "Json", obrigatorio: false }];
-            tasks.push({
-                nome: taskNome,
-                resumo: `Task HTTP do worker importada automaticamente de ${contexto.relacao}#${rota.simbolo}.`,
-                input,
-                output: taskOutput,
-                errors: exportacao?.corpo ? extrairErrosTs(exportacao.corpo, contexto.sourceFile) : [],
-                effects: exportacao?.corpo ? descreverEfeitosPorHeuristica(exportacao.corpo.getText(contexto.sourceFile)) : descreverEfeitosPorHeuristica(contexto.texto),
-                impl: { ts: caminhoImplTs(diretorio, path.join(diretorio, contexto.relacao), rota.simbolo) },
-                origemArquivo: contexto.relacao,
-                origemSimbolo: rota.simbolo,
-            });
-            routes.push({
-                nome: `${taskNome}_publico`,
-                resumo: `Rota do worker importada automaticamente de ${contexto.relacao}#${rota.simbolo}.`,
-                metodo: rota.metodo,
-                caminho: rota.caminho,
-                task: taskNome,
-                input,
-                output: taskOutput,
-                errors: exportacao?.corpo ? extrairErrosTs(exportacao.corpo, contexto.sourceFile) : [],
-            });
-        }
-        for (const colecao of extrairColecoesFirebaseImportacao(contexto.texto)) {
-            tasks.push({
-                nome: paraSnakeCase(`inventariar_${colecao}`),
-                resumo: `Task sintetica para registrar o recurso persistido ${colecao} descoberto em ${contexto.relacao}.`,
-                input: [],
-                output: [{ nome: "colecao", tipo: "Texto", obrigatorio: false }],
-                errors: [],
-                effects: [{ categoria: "persistencia", alvo: colecao, criticidade: "media" }],
-                origemArquivo: contexto.relacao,
-                origemSimbolo: colecao,
-            });
-        }
-        if (!tasks.length && !routes.length) {
-            continue;
-        }
-        sincronizarRotasComTasks(routes, tasks);
-        const { entities, enums } = criarEntidadesReferenciadas(tiposGlobais, entitiesRef, enumsRef);
-        modulos.set(nomeModulo, {
-            nome: nomeModulo,
-            resumo: `Rascunho Sema importado automaticamente de ${contexto.relacao}.`,
-            tasks: deduplicarTarefas(tasks),
-            routes: deduplicarRotas(routes),
-            entities,
-            enums,
-        });
-    }
-    return [...modulos.values()];
-}
-function extrairTiposPython(texto) {
-    const encontrados = new Map();
-    const regexBaseModel = /^class\s+(\w+)(?:\(([^)]*)\))?:\n((?:^[ \t].*(?:\n|$))*)/gm;
-    for (const match of texto.matchAll(regexBaseModel)) {
-        const [, nome, bases = "", corpo] = match;
-        if (!bases.includes("BaseModel")) {
-            continue;
-        }
-        const campos = [...corpo.matchAll(/^\s{4}(\w+)\s*:\s*([^\n=]+)(?:\s*=.+)?$/gm)].map((campo) => ({
-            nome: campo[1],
-            tipoTexto: campo[2].trim(),
-            obrigatorio: !/=/.test(campo[0]),
-        }));
-        encontrados.set(nome, { tipo: "objeto", nome: nome, campos });
-    }
-    const regexEnum = /^class\s+(\w+)(?:\(([^)]*)\))?:\n((?:^[ \t].*(?:\n|$))*)/gm;
-    for (const match of texto.matchAll(regexEnum)) {
-        const [, nome, bases = "", corpo] = match;
-        if (!/(Enum|StrEnum)/.test(bases)) {
-            continue;
-        }
-        const valores = [...corpo.matchAll(/^\s{4}(\w+)\s*=\s*["']([^"']+)["']$/gm)].map((valor) => valor[1]).filter(Boolean);
-        if (valores.length) {
-            encontrados.set(nome, { tipo: "enum", nome: nome, valores });
-        }
-    }
-    return encontrados;
-}
-function mapearTipoPythonParaSema(tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados) {
-    if (!tipoTexto) {
-        return "Json";
-    }
-    const limpo = tipoTexto.replace(/\s+/g, "");
-    const basico = mapearTipoPrimitivo(limpo);
-    if (basico !== limpo) {
-        return basico;
-    }
-    const simples = limpo.replace(/Optional\[(.+)\]/, "$1").replace(/list\[(.+)\]/i, "Json").replace(/dict\[(.+)\]/i, "Json");
-    if (tipos.has(simples)) {
-        const encontrado = tipos.get(simples);
-        if (encontrado.tipo === "enum") {
-            enumsReferenciados.add(encontrado.nome);
-            return encontrado.nome;
-        }
-        if (!pareceWrapperTipo(encontrado.nome)) {
-            entidadesReferenciadas.add(encontrado.nome);
-            return encontrado.nome;
-        }
-    }
-    return "Json";
-}
-function expandirCamposPython(nomeParametro, tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados, obrigatorio) {
-    if (!tipoTexto) {
-        return [{ nome: paraSnakeCase(nomeParametro), tipo: "Json", obrigatorio }];
-    }
-    const limpo = tipoTexto.replace(/\s+/g, "").replace(/Optional\[(.+)\]/, "$1");
-    const descoberto = tipos.get(limpo);
-    if (descoberto?.tipo === "objeto" && pareceWrapperTipo(descoberto.nome) && descoberto.campos) {
-        return descoberto.campos.map((campo) => ({
-            nome: paraSnakeCase(campo.nome),
-            tipo: mapearTipoPythonParaSema(campo.tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados),
-            obrigatorio: campo.obrigatorio,
-        }));
-    }
-    return [{
-            nome: paraSnakeCase(nomeParametro),
-            tipo: mapearTipoPythonParaSema(tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados),
-            obrigatorio,
-        }];
-}
-function criarEntidadesPython(tipos, entidadesReferenciadas, enumsReferenciados) {
-    const entities = [...entidadesReferenciadas]
-        .map((nome) => tipos.get(nome))
-        .filter((item) => Boolean(item?.tipo === "objeto" && item.campos))
-        .map((item) => ({
-        nome: item.nome,
-        campos: item.campos.map((campo) => ({
-            nome: paraSnakeCase(campo.nome),
-            tipo: mapearTipoPythonParaSema(campo.tipoTexto, tipos, entidadesReferenciadas, enumsReferenciados),
-            obrigatorio: campo.obrigatorio,
-        })),
-    }));
-    const enums = [...enumsReferenciados]
-        .map((nome) => tipos.get(nome))
-        .filter((item) => Boolean(item?.tipo === "enum" && item.valores))
-        .map((item) => ({
-        nome: item.nome,
-        valores: item.valores,
-    }));
-    return { entities: deduplicarEntidades(entities), enums: deduplicarEnums(enums) };
-}
-function extrairErrosPython(texto) {
-    const erros = new Map();
-    for (const match of texto.matchAll(/raise\s+(\w+)(?:\(([^)]*)\))?/g)) {
-        const nomeBruto = match[1];
-        const mensagem = (match[2] ?? "").match(/["']([^"']+)["']/)?.[1] ?? `Erro importado automaticamente de ${nomeBruto}.`;
-        erros.set(normalizarNomeErroBruto(nomeBruto), mensagem);
-    }
-    return [...erros.entries()].map(([nome, mensagem]) => ({ nome, mensagem }));
-}
-function caminhoImplGenerico(diretorioBase, arquivo, simbolo, opcoes) {
-    const relativo = path.relative(diretorioBase, arquivo).replace(/\.[^.]+$/, "");
-    const segmentos = relativo.split(path.sep).map((segmento, indice, lista) => opcoes?.snakeCaseUltimoArquivo && indice === lista.length - 1
-        ? paraSnakeCase(segmento)
-        : paraIdentificadorModulo(segmento))
-        .filter(Boolean);
-    return [...segmentos, simbolo].join(".");
-}
-function caminhoImplPython(diretorioBase, arquivo, simbolo) {
-    return caminhoImplGenerico(diretorioBase, arquivo, simbolo);
-}
-function caminhoImplDart(diretorioBase, arquivo, simbolo) {
-    return caminhoImplGenerico(diretorioBase, arquivo, simbolo);
-}
-function dividirParametrosPython(parametros) {
-    const partes = [];
-    let atual = "";
-    let profundidade = 0;
-    for (const caractere of parametros) {
-        if (caractere === "," && profundidade === 0) {
-            if (atual.trim()) {
-                partes.push(atual.trim());
-            }
-            atual = "";
-            continue;
-        }
-        if (["[", "(", "{", "<"].includes(caractere)) {
-            profundidade += 1;
-        }
-        else if (["]", ")", "}", ">"].includes(caractere) && profundidade > 0) {
-            profundidade -= 1;
-        }
-        atual += caractere;
-    }
-    if (atual.trim()) {
-        partes.push(atual.trim());
-    }
-    return partes;
-}
-function extrairAssinaturaParametrosPython(parametros) {
-    const assinatura = new Map();
-    for (const item of dividirParametrosPython(parametros)) {
-        if (!item || item.startsWith("self") || item.startsWith("cls") || item.startsWith("*")) {
-            continue;
-        }
-        const obrigatorio = !item.includes("=");
-        const semValorPadrao = item.split("=")[0]?.trim() ?? item.trim();
-        const [nomeBruto, tipo] = semValorPadrao.split(":").map((parte) => parte.trim());
-        const nome = nomeBruto?.replace(/^\*{1,2}/, "").trim();
-        if (!nome) {
-            continue;
-        }
-        assinatura.set(nome, {
-            tipoTexto: tipo || undefined,
-            obrigatorio,
-        });
-    }
-    return assinatura;
-}
-function mapearConversorFlaskParaSema(conversor) {
-    switch ((conversor ?? "").toLowerCase()) {
-        case "int":
-            return "Inteiro";
-        case "float":
-            return "Decimal";
-        case "uuid":
-            return "Id";
-        case "path":
-        default:
-            return "Texto";
-    }
-}
-function criarInputRotaFlask(caminho, parametros, tiposGlobais, entitiesRef, enumsRef) {
-    const assinatura = extrairAssinaturaParametrosPython(parametros);
-    return extrairParametrosCaminhoFlask(caminho).map((parametro) => {
-        const correspondente = assinatura.get(parametro.nome);
-        return {
-            nome: paraSnakeCase(parametro.nome),
-            tipo: correspondente?.tipoTexto
-                ? mapearTipoPythonParaSema(correspondente.tipoTexto, tiposGlobais, entitiesRef, enumsRef)
-                : mapearConversorFlaskParaSema(parametro.conversor),
-            obrigatorio: correspondente?.obrigatorio ?? true,
-        };
-    });
-}
-async function importarPythonBase(diretorio, namespaceBase, modoHttp = "nenhum") {
-    const arquivos = (await listarArquivosRecursivos(diretorio, [".py"]))
-        .filter((arquivo) => !arquivo.endsWith("__init__.py") && !/tests?[\\/]/i.test(arquivo));
-    const textos = new Map();
-    const tiposGlobais = new Map();
-    for (const arquivo of arquivos) {
-        const texto = await readFile(arquivo, "utf8");
-        textos.set(arquivo, texto);
-        for (const [nome, tipo] of extrairTiposPython(texto)) {
-            if (!tiposGlobais.has(nome)) {
-                tiposGlobais.set(nome, tipo);
-            }
-        }
-    }
-    const modulos = new Map();
-    for (const arquivo of arquivos) {
-        const texto = textos.get(arquivo);
-        const relacao = path.relative(diretorio, arquivo);
-        const contextoSegmentos = inferirContextoPorArquivo(relacao);
-        const nomeModulo = [namespaceBase, ...contextoSegmentos].join(".");
-        const entitiesRef = new Set();
-        const enumsRef = new Set();
-        const tasks = [];
-        const routes = [];
-        if (modoHttp === "fastapi") {
-            const prefixo = texto.match(/APIRouter\s*\(\s*prefix\s*=\s*["']([^"']+)["']/)?.[1];
-            const routeRegex = /@(?:router|app)\.(get|post|put|patch|delete)\(([^)]*)\)\s*\n(?:async\s+)?def\s+(\w+)\(([^)]*)\)(?:\s*->\s*([^:]+))?:/g;
-            for (const match of texto.matchAll(routeRegex)) {
-                const metodo = match[1].toUpperCase();
-                const argumentoDecorator = match[2] ?? "";
-                const sufixo = argumentoDecorator.match(/["']([^"']+)["']/)?.[1];
-                const nomeFuncao = match[3];
-                const parametros = match[4];
-                const retorno = match[5]?.trim();
-                const routeInput = parametros
-                    .split(",")
-                    .map((item) => item.trim())
-                    .filter(Boolean)
-                    .filter((item) => !item.startsWith("self") && !item.startsWith("cls"))
-                    .flatMap((item) => {
-                    const [nome, tipo] = item.split(":").map((parte) => parte.trim());
-                    const obrigatorio = !item.includes("=");
-                    return expandirCamposPython(nome, tipo, tiposGlobais, entitiesRef, enumsRef, obrigatorio);
-                });
-                const routeOutput = retorno && mapearTipoPrimitivo(retorno) === "Vazio"
-                    ? []
-                    : deduplicarCampos(expandirCamposPython("resultado", retorno, tiposGlobais, entitiesRef, enumsRef, false));
-                const taskNome = paraSnakeCase(nomeFuncao);
-                routes.push({
-                    nome: `${taskNome}_publico`,
-                    resumo: `Rota FastAPI importada automaticamente de ${relacao}#${nomeFuncao}.`,
-                    metodo,
-                    caminho: juntarCaminhoHttp(prefixo, sufixo),
-                    task: taskNome,
-                    input: deduplicarCampos(routeInput),
-                    output: routeOutput,
-                    errors: [],
-                });
-            }
-        }
-        else if (modoHttp === "flask") {
-            for (const rota of extrairRotasFlaskDecoradas(texto)) {
-                const taskNome = paraSnakeCase(rota.nomeFuncao);
-                const nomeBase = `${taskNome}_publico`;
-                const nome = routes.some((route) => route.nome === nomeBase)
-                    ? `${taskNome}_${rota.metodo.toLowerCase()}_publico`
-                    : nomeBase;
-                routes.push({
-                    nome,
-                    resumo: `Rota Flask importada automaticamente de ${relacao}#${rota.nomeFuncao}.`,
-                    metodo: rota.metodo,
-                    caminho: rota.caminho,
-                    task: taskNome,
-                    input: deduplicarCampos(criarInputRotaFlask(rota.caminho, rota.parametros, tiposGlobais, entitiesRef, enumsRef)),
-                    output: [],
-                    errors: [],
-                });
-            }
-        }
-        const funcRegex = /^(async\s+def|def)\s+(\w+)\(([^)]*)\)(?:\s*->\s*([^:]+))?:/gm;
-        for (const match of texto.matchAll(funcRegex)) {
-            const nomeFuncao = match[2];
-            if (nomeFuncao.startsWith("_")) {
-                continue;
-            }
-            const parametros = match[3];
-            const retorno = match[4]?.trim();
-            const inicioCorpo = match.index ?? 0;
-            const trecho = texto.slice(inicioCorpo, Math.min(texto.length, inicioCorpo + 1500));
-            const input = parametros
-                .split(",")
-                .map((item) => item.trim())
-                .filter(Boolean)
-                .filter((item) => !item.startsWith("self") && !item.startsWith("cls"))
-                .flatMap((item) => {
-                const [nome, tipo] = item.split(":").map((parte) => parte.trim());
-                const obrigatorio = !item.includes("=");
-                return expandirCamposPython(nome, tipo, tiposGlobais, entitiesRef, enumsRef, obrigatorio);
-            });
-            const output = retorno && mapearTipoPrimitivo(retorno) === "Vazio"
-                ? []
-                : deduplicarCampos(expandirCamposPython("resultado", retorno, tiposGlobais, entitiesRef, enumsRef, false));
-            tasks.push({
-                nome: paraSnakeCase(nomeFuncao),
-                resumo: `Task importada automaticamente de ${relacao}#${nomeFuncao}.`,
-                input: deduplicarCampos(input),
-                output,
-                errors: extrairErrosPython(trecho),
-                effects: descreverEfeitosPorHeuristica(trecho),
-                impl: { py: caminhoImplPython(diretorio, arquivo, nomeFuncao) },
-                origemArquivo: relacao,
-                origemSimbolo: nomeFuncao,
-            });
-        }
-        const classRegex = /^class\s+(\w+)(?:\(([^)]*)\))?:\n((?:^[ \t].*(?:\n|$))*)/gm;
-        for (const match of texto.matchAll(classRegex)) {
-            const nomeClasse = match[1];
-            const bases = match[2] ?? "";
-            const corpo = match[3];
-            if (/(BaseModel|Enum|StrEnum)/.test(bases)) {
-                continue;
-            }
-            for (const metodo of corpo.matchAll(/^\s{4}(?:async\s+def|def)\s+(\w+)\(([^)]*)\)(?:\s*->\s*([^:]+))?:/gm)) {
-                const nomeMetodo = metodo[1];
-                if (nomeMetodo.startsWith("_")) {
-                    continue;
-                }
-                const parametros = metodo[2];
-                const retorno = metodo[3]?.trim();
-                const input = parametros
-                    .split(",")
-                    .map((item) => item.trim())
-                    .filter(Boolean)
-                    .filter((item) => !item.startsWith("self") && !item.startsWith("cls"))
-                    .flatMap((item) => {
-                    const [nome, tipo] = item.split(":").map((parte) => parte.trim());
-                    const obrigatorio = !item.includes("=");
-                    return expandirCamposPython(nome, tipo, tiposGlobais, entitiesRef, enumsRef, obrigatorio);
-                });
-                const output = retorno && mapearTipoPrimitivo(retorno) === "Vazio"
-                    ? []
-                    : deduplicarCampos(expandirCamposPython("resultado", retorno, tiposGlobais, entitiesRef, enumsRef, false));
-                tasks.push({
-                    nome: paraSnakeCase(nomeMetodo),
-                    resumo: `Task importada automaticamente de ${relacao}#${nomeClasse}.${nomeMetodo}.`,
-                    input: deduplicarCampos(input),
-                    output,
-                    errors: extrairErrosPython(corpo),
-                    effects: descreverEfeitosPorHeuristica(corpo),
-                    impl: { py: caminhoImplPython(diretorio, arquivo, `${nomeClasse}.${nomeMetodo}`) },
-                    origemArquivo: relacao,
-                    origemSimbolo: `${nomeClasse}.${nomeMetodo}`,
-                });
-            }
-        }
-        if (!tasks.length && !routes.length) {
-            continue;
-        }
-        const { entities, enums } = criarEntidadesPython(tiposGlobais, entitiesRef, enumsRef);
-        sincronizarRotasComTasks(routes, tasks);
-        modulos.set(nomeModulo, {
-            nome: nomeModulo,
-            resumo: `Rascunho Sema importado automaticamente de ${relacao}.`,
-            tasks: deduplicarTarefas(tasks),
-            routes: deduplicarRotas(routes),
-            entities,
-            enums,
-        });
-    }
-    return [...modulos.values()];
-}
-async function importarDartBase(diretorio, namespaceBase) {
-    const arquivos = (await listarArquivosRecursivos(diretorio, [".dart"]))
-        .filter((arquivo) => !arquivo.endsWith(".g.dart") && !arquivo.endsWith(".freezed.dart"));
-    const modulos = [];
-    for (const arquivo of arquivos) {
-        const texto = await readFile(arquivo, "utf8");
-        const relacao = path.relative(diretorio, arquivo);
-        const contextoSegmentos = inferirContextoPorArquivo(relacao);
-        const nomeModulo = [namespaceBase, ...contextoSegmentos].join(".");
-        const tasks = [];
-        for (const match of texto.matchAll(/(?:Future<([^\n]+)>|([\w?<>.,\s]+))\s+(\w+)\(([^)]*)\)\s*(?:async\s*)?\{/g)) {
-            const retorno = (match[1] ?? match[2] ?? "").trim();
-            const nome = match[3];
-            if (["build", "toString", "hashCode"].includes(nome)) {
-                continue;
-            }
-            const parametros = match[4];
-            const input = parametros
-                .split(",")
-                .map((item) => item.trim())
-                .filter(Boolean)
-                .map((item) => item.replace(/^(required|final)\s+/g, ""))
-                .map((item) => {
-                const partes = item.split(/\s+/);
-                const nomeParametro = partes.at(-1) ?? "param";
-                const tipoParametro = partes.length > 1 ? partes.slice(0, -1).join(" ") : undefined;
-                return {
-                    nome: paraSnakeCase(nomeParametro),
-                    tipo: mapearTipoPrimitivo(tipoParametro ?? "Json"),
-                    obrigatorio: item.includes("required"),
-                };
-            });
-            const output = retorno && mapearTipoPrimitivo(retorno) === "Vazio"
-                ? []
-                : [{ nome: "resultado", tipo: mapearTipoPrimitivo(retorno || "Json"), obrigatorio: false }];
-            tasks.push({
-                nome: paraSnakeCase(nome),
-                resumo: `Task importada automaticamente de ${relacao}#${nome}.`,
-                input,
-                output,
-                errors: [],
-                effects: descreverEfeitosPorHeuristica(texto),
-                impl: { dart: caminhoImplDart(diretorio, arquivo, nome) },
-                origemArquivo: relacao,
-                origemSimbolo: nome,
-            });
-        }
-        if (tasks.length === 0) {
-            continue;
-        }
-        modulos.push({
-            nome: nomeModulo,
-            resumo: `Rascunho Sema importado automaticamente de ${relacao}.`,
-            tasks: deduplicarTarefas(tasks),
-            routes: [],
-            entities: [],
-            enums: [],
-        });
-    }
-    return modulos;
-}
-function criarModuloImportadoSimples(nome, resumo, tasks, routes = [], vinculos = [], databases = []) {
-    sincronizarRotasComTasks(routes, tasks);
-    return {
-        nome,
-        resumo,
-        tasks: deduplicarTarefas(tasks),
-        routes: deduplicarRotas(routes),
-        entities: [],
-        enums: [],
-        databases: deduplicarDatabases(databases),
-        vinculos: deduplicarVinculos(vinculos),
-    };
-}
-function acumularModuloImportado(modulos, modulo) {
-    const existente = modulos.get(modulo.nome);
-    if (!existente) {
-        modulos.set(modulo.nome, modulo);
-        return;
-    }
-    existente.tasks = deduplicarTarefas([...existente.tasks, ...modulo.tasks]);
-    existente.routes = deduplicarRotas([...existente.routes, ...modulo.routes]);
-    existente.entities = deduplicarEntidades([...existente.entities, ...modulo.entities]);
-    existente.enums = deduplicarEnums([...existente.enums, ...modulo.enums]);
-    existente.databases = deduplicarDatabases([...(existente.databases ?? []), ...(modulo.databases ?? [])]);
-    existente.vinculos = deduplicarVinculos([...(existente.vinculos ?? []), ...(modulo.vinculos ?? [])]);
-}
-function selecionarSimbolosPreferidos(simbolos) {
-    const mapa = new Map();
-    for (const simbolo of simbolos) {
-        const chave = simbolo.simbolo.split(".").at(-1) ?? simbolo.simbolo;
-        const existente = mapa.get(chave);
-        if (!existente) {
-            mapa.set(chave, simbolo);
-            continue;
-        }
-        const pontuacaoAtual = simbolo.simbolo.split(".").length;
-        const pontuacaoExistente = existente.simbolo.split(".").length;
-        if (pontuacaoAtual > pontuacaoExistente) {
-            mapa.set(chave, simbolo);
-        }
-    }
-    return [...mapa.values()];
-}
-async function existeArquivo(caminho) {
-    try {
-        await access(caminho);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function resolverArquivoRustParaSimbolo(diretorio, relacaoFonte, simbolo) {
-    const partes = simbolo.split(".").filter(Boolean);
-    if (partes.length <= 1) {
-        return path.join(diretorio, relacaoFonte);
-    }
-    const moduloPartes = partes.slice(0, -1);
-    const baseAtual = path.dirname(relacaoFonte);
-    const candidatos = [
-        path.join(baseAtual, ...moduloPartes) + ".rs",
-        path.join(baseAtual, ...moduloPartes, "mod.rs"),
-        path.join("src", ...moduloPartes) + ".rs",
-        path.join("src", ...moduloPartes, "mod.rs"),
-    ];
-    for (const candidato of candidatos) {
-        const absoluto = path.join(diretorio, candidato);
-        if (await existeArquivo(absoluto)) {
-            return absoluto;
-        }
-    }
-    return path.join(diretorio, relacaoFonte);
-}
-async function importarDotnetBase(diretorio, namespaceBase) {
-    const arquivos = (await listarArquivosRecursivos(diretorio, [".cs"]))
-        .filter((arquivo) => !/(^|[\\/])(bin|obj|Test[s]?)([\\/]|$)/i.test(arquivo));
-    const modulos = new Map();
-    for (const arquivo of arquivos) {
-        const texto = await readFile(arquivo, "utf8");
-        const relacao = path.relative(diretorio, arquivo);
-        const contextoSegmentos = inferirContextoPorArquivo(relacao, { preservarUltimo: true, snakeCaseUltimo: true });
-        const nomeModulo = [namespaceBase, ...contextoSegmentos].join(".");
-        const tasks = [];
-        const routes = [];
-        for (const simbolo of extrairSimbolosDotnet(texto)) {
-            const taskNome = paraSnakeCase(simbolo.simbolo.split(".").at(-1) ?? simbolo.simbolo);
-            tasks.push({
-                nome: taskNome,
-                resumo: `Task importada automaticamente de ${relacao}#${simbolo.simbolo}.`,
-                input: simbolo.parametros.map((parametro) => ({
-                    nome: paraSnakeCase(parametro.nome),
-                    tipo: mapearTipoBackendParaSema(parametro.tipoTexto),
-                    obrigatorio: parametro.obrigatorio,
-                })),
-                output: criarCampoResultadoBackend(simbolo.retorno),
-                errors: [],
-                effects: descreverEfeitosPorHeuristica(texto),
-                impl: { cs: caminhoImplGenerico(diretorio, arquivo, simbolo.simbolo, { snakeCaseUltimoArquivo: true }) },
-                origemArquivo: relacao,
-                origemSimbolo: simbolo.simbolo,
-            });
-        }
-        for (const rota of extrairRotasDotnet(texto)) {
-            const taskNome = paraSnakeCase(rota.simbolo.split(".").at(-1) ?? rota.simbolo);
-            const output = criarCampoResultadoBackend(rota.retorno);
-            tasks.push({
-                nome: taskNome,
-                resumo: `Task HTTP ASP.NET Core importada automaticamente de ${relacao}#${rota.simbolo}.`,
-                input: camposDeParametrosRotaBackend(rota.parametros),
-                output,
-                errors: [],
-                effects: [{ categoria: "consulta", alvo: "http", criticidade: "media" }],
-                impl: { cs: caminhoImplGenerico(diretorio, arquivo, rota.simbolo, { snakeCaseUltimoArquivo: true }) },
-                origemArquivo: relacao,
-                origemSimbolo: rota.simbolo,
-            });
-            routes.push({
-                nome: `${taskNome}_publico`,
-                resumo: `Rota ASP.NET Core importada automaticamente de ${relacao}#${rota.simbolo}.`,
-                metodo: rota.metodo,
-                caminho: rota.caminho,
-                task: taskNome,
-                input: camposDeParametrosRotaBackend(rota.parametros),
-                output,
-                errors: [],
-            });
-        }
-        if (tasks.length === 0 && routes.length === 0) {
-            continue;
-        }
-        acumularModuloImportado(modulos, criarModuloImportadoSimples(nomeModulo, `Rascunho Sema importado automaticamente de ${relacao}.`, tasks, routes, [], inferirDatabasesPorHeuristica(texto, relacao)));
-    }
-    return [...modulos.values()];
-}
-async function importarJavaBase(diretorio, namespaceBase) {
-    const arquivos = (await listarArquivosRecursivos(diretorio, [".java"]))
-        .filter((arquivo) => !/(^|[\\/])(target|build|out|Test[s]?)([\\/]|$)/i.test(arquivo));
-    const modulos = new Map();
-    for (const arquivo of arquivos) {
-        const texto = await readFile(arquivo, "utf8");
-        const relacao = path.relative(diretorio, arquivo);
-        const contextoSegmentos = inferirContextoPorArquivo(relacao, { preservarUltimo: true, snakeCaseUltimo: true });
-        const nomeModulo = [namespaceBase, ...contextoSegmentos].join(".");
-        const tasks = [];
-        const routes = [];
-        for (const simbolo of extrairSimbolosJava(texto)) {
-            const taskNome = paraSnakeCase(simbolo.simbolo.split(".").at(-1) ?? simbolo.simbolo);
-            tasks.push({
-                nome: taskNome,
-                resumo: `Task importada automaticamente de ${relacao}#${simbolo.simbolo}.`,
-                input: simbolo.parametros.map((parametro) => ({
-                    nome: paraSnakeCase(parametro.nome),
-                    tipo: mapearTipoBackendParaSema(parametro.tipoTexto),
-                    obrigatorio: parametro.obrigatorio,
-                })),
-                output: criarCampoResultadoBackend(simbolo.retorno),
-                errors: [],
-                effects: descreverEfeitosPorHeuristica(texto),
-                impl: { java: caminhoImplGenerico(diretorio, arquivo, simbolo.simbolo, { snakeCaseUltimoArquivo: true }) },
-                origemArquivo: relacao,
-                origemSimbolo: simbolo.simbolo,
-            });
-        }
-        for (const rota of extrairRotasJava(texto)) {
-            const taskNome = paraSnakeCase(rota.simbolo.split(".").at(-1) ?? rota.simbolo);
-            const output = criarCampoResultadoBackend(rota.retorno);
-            tasks.push({
-                nome: taskNome,
-                resumo: `Task HTTP Spring Boot importada automaticamente de ${relacao}#${rota.simbolo}.`,
-                input: camposDeParametrosRotaBackend(rota.parametros),
-                output,
-                errors: [],
-                effects: [{ categoria: "consulta", alvo: "http", criticidade: "media" }],
-                impl: { java: caminhoImplGenerico(diretorio, arquivo, rota.simbolo, { snakeCaseUltimoArquivo: true }) },
-                origemArquivo: relacao,
-                origemSimbolo: rota.simbolo,
-            });
-            routes.push({
-                nome: `${taskNome}_publico`,
-                resumo: `Rota Spring Boot importada automaticamente de ${relacao}#${rota.simbolo}.`,
-                metodo: rota.metodo,
-                caminho: rota.caminho,
-                task: taskNome,
-                input: camposDeParametrosRotaBackend(rota.parametros),
-                output,
-                errors: [],
-            });
-        }
-        if (tasks.length === 0 && routes.length === 0) {
-            continue;
-        }
-        acumularModuloImportado(modulos, criarModuloImportadoSimples(nomeModulo, `Rascunho Sema importado automaticamente de ${relacao}.`, tasks, routes, [], inferirDatabasesPorHeuristica(texto, relacao)));
-    }
-    return [...modulos.values()];
-}
-async function importarGoBase(diretorio, namespaceBase) {
-    const arquivos = await listarArquivosRecursivos(diretorio, [".go"]);
-    const modulos = new Map();
-    for (const arquivo of arquivos) {
-        const texto = await readFile(arquivo, "utf8");
-        const relacao = path.relative(diretorio, arquivo);
-        const contextoSegmentos = inferirContextoPorArquivo(relacao);
-        const nomeModulo = [namespaceBase, ...contextoSegmentos].join(".");
-        const tasks = [];
-        const routes = [];
-        for (const simbolo of extrairSimbolosGo(texto)) {
-            const taskNome = paraSnakeCase(simbolo.simbolo.split(".").at(-1) ?? simbolo.simbolo);
-            tasks.push({
-                nome: taskNome,
-                resumo: `Task importada automaticamente de ${relacao}#${simbolo.simbolo}.`,
-                input: simbolo.parametros.map((parametro) => ({
-                    nome: paraSnakeCase(parametro.nome),
-                    tipo: mapearTipoBackendParaSema(parametro.tipoTexto),
-                    obrigatorio: parametro.obrigatorio,
-                })),
-                output: criarCampoResultadoBackend(simbolo.retorno),
-                errors: [],
-                effects: descreverEfeitosPorHeuristica(texto),
-                impl: { go: caminhoImplGenerico(diretorio, arquivo, simbolo.simbolo) },
-                origemArquivo: relacao,
-                origemSimbolo: simbolo.simbolo,
-            });
-        }
-        for (const rota of extrairRotasGo(texto)) {
-            const taskNome = paraSnakeCase(rota.simbolo.split(".").at(-1) ?? rota.simbolo);
-            tasks.push({
-                nome: taskNome,
-                resumo: `Task HTTP Go importada automaticamente de ${relacao}#${rota.simbolo}.`,
-                input: camposDeParametrosRotaBackend(rota.parametros),
-                output: [{ nome: "resultado", tipo: "Json", obrigatorio: false }],
-                errors: [],
-                effects: [{ categoria: "consulta", alvo: "http", criticidade: "media" }],
-                impl: { go: caminhoImplGenerico(diretorio, arquivo, rota.simbolo) },
-                origemArquivo: relacao,
-                origemSimbolo: rota.simbolo,
-            });
-            routes.push({
-                nome: `${taskNome}_publico`,
-                resumo: `Rota Go importada automaticamente de ${relacao}#${rota.simbolo}.`,
-                metodo: rota.metodo,
-                caminho: rota.caminho,
-                task: taskNome,
-                input: camposDeParametrosRotaBackend(rota.parametros),
-                output: [{ nome: "resultado", tipo: "Json", obrigatorio: false }],
-                errors: [],
-            });
-        }
-        if (tasks.length === 0 && routes.length === 0) {
-            continue;
-        }
-        modulos.set(nomeModulo, criarModuloImportadoSimples(nomeModulo, `Rascunho Sema importado automaticamente de ${relacao}.`, tasks, routes, [], inferirDatabasesPorHeuristica(texto, relacao)));
-    }
-    return [...modulos.values()];
-}
-async function importarRustBase(diretorio, namespaceBase) {
-    const arquivos = await listarArquivosRecursivos(diretorio, [".rs"]);
-    const modulos = new Map();
-    for (const arquivo of arquivos) {
-        const texto = await readFile(arquivo, "utf8");
-        const relacao = path.relative(diretorio, arquivo);
-        const contextoSegmentos = inferirContextoPorArquivo(relacao);
-        const nomeModulo = [namespaceBase, ...contextoSegmentos].join(".");
-        const tasks = [];
-        const routes = [];
-        for (const simbolo of extrairSimbolosRust(texto)) {
-            const taskNome = paraSnakeCase(simbolo.simbolo.split(".").at(-1) ?? simbolo.simbolo);
-            tasks.push({
-                nome: taskNome,
-                resumo: `Task importada automaticamente de ${relacao}#${simbolo.simbolo}.`,
-                input: simbolo.parametros.map((parametro) => ({
-                    nome: paraSnakeCase(parametro.nome),
-                    tipo: mapearTipoBackendParaSema(parametro.tipoTexto),
-                    obrigatorio: parametro.obrigatorio,
-                })),
-                output: criarCampoResultadoBackend(simbolo.retorno),
-                errors: [],
-                effects: descreverEfeitosPorHeuristica(texto),
-                impl: { rust: caminhoImplGenerico(diretorio, arquivo, simbolo.simbolo) },
-                origemArquivo: relacao,
-                origemSimbolo: simbolo.simbolo,
-            });
-        }
-        acumularModuloImportado(modulos, criarModuloImportadoSimples(nomeModulo, `Rascunho Sema importado automaticamente de ${relacao}.`, tasks, routes, [], inferirDatabasesPorHeuristica(texto, relacao)));
-        for (const rota of extrairRotasRust(texto)) {
-            const simboloLimpo = rota.simbolo.replace(/::/g, ".");
-            const nomeSimbolo = simboloLimpo.split(".").at(-1) ?? simboloLimpo;
-            const arquivoAlvo = await resolverArquivoRustParaSimbolo(diretorio, relacao, simboloLimpo);
-            const relacaoAlvo = path.relative(diretorio, arquivoAlvo);
-            const moduloAlvo = [namespaceBase, ...inferirContextoPorArquivo(relacaoAlvo)].join(".");
-            const taskNome = paraSnakeCase(rota.simbolo.split(".").at(-1) ?? rota.simbolo);
-            const task = {
-                nome: taskNome,
-                resumo: `Task HTTP Axum importada automaticamente de ${relacao}#${rota.simbolo}.`,
-                input: camposDeParametrosRotaBackend(rota.parametros),
-                output: [{ nome: "resultado", tipo: "Json", obrigatorio: false }],
-                errors: [],
-                effects: [{ categoria: "consulta", alvo: "http", criticidade: "media" }],
-                impl: { rust: caminhoImplGenerico(diretorio, arquivoAlvo, nomeSimbolo) },
-                origemArquivo: relacaoAlvo,
-                origemSimbolo: nomeSimbolo,
-            };
-            const route = {
-                nome: `${taskNome}_publico`,
-                resumo: `Rota Axum importada automaticamente de ${relacao}#${rota.simbolo}.`,
-                metodo: rota.metodo,
-                caminho: rota.caminho,
-                task: taskNome,
-                input: camposDeParametrosRotaBackend(rota.parametros),
-                output: [{ nome: "resultado", tipo: "Json", obrigatorio: false }],
-                errors: [],
-            };
-            acumularModuloImportado(modulos, criarModuloImportadoSimples(moduloAlvo, `Rascunho Sema importado automaticamente de ${relacaoAlvo}.`, [task], [route], [], inferirDatabasesPorHeuristica(texto, relacao)));
-        }
-    }
-    return [...modulos.values()];
-}
-async function importarCppBase(diretorio, namespaceBase) {
-    const arquivos = (await listarArquivosRecursivos(diretorio, [".cpp", ".cc", ".cxx", ".hpp", ".h"]))
-        .filter((arquivo) => !/(^|[\\/])(windows|linux|macos|runner|flutter|ephemeral|build|vendor)([\\/]|$)/i.test(arquivo));
-    const modulos = new Map();
-    for (const arquivo of arquivos) {
-        const texto = await readFile(arquivo, "utf8");
-        const relacao = path.relative(diretorio, arquivo);
-        const contextoSegmentos = inferirContextoPorArquivo(relacao);
-        const nomeModulo = [namespaceBase, ...contextoSegmentos].join(".");
-        const tasks = [];
-        for (const simbolo of selecionarSimbolosPreferidos(extrairSimbolosCpp(texto))) {
-            const taskNome = paraSnakeCase(simbolo.simbolo.split(".").at(-1) ?? simbolo.simbolo);
-            tasks.push({
-                nome: taskNome,
-                resumo: `Task importada automaticamente de ${relacao}#${simbolo.simbolo}.`,
-                input: simbolo.parametros.map((parametro) => ({
-                    nome: paraSnakeCase(parametro.nome),
-                    tipo: mapearTipoBackendParaSema(parametro.tipoTexto),
-                    obrigatorio: parametro.obrigatorio,
-                })),
-                output: [{ nome: "resultado", tipo: "Json", obrigatorio: false }],
-                errors: [],
-                effects: descreverEfeitosPorHeuristica(texto),
-                impl: { cpp: caminhoImplGenerico(diretorio, arquivo, simbolo.simbolo) },
-                origemArquivo: relacao,
-                origemSimbolo: simbolo.simbolo,
-            });
-        }
-        if (tasks.length === 0) {
-            continue;
-        }
-        acumularModuloImportado(modulos, criarModuloImportadoSimples(nomeModulo, `Rascunho Sema importado automaticamente de ${relacao}.`, tasks, [], [], inferirDatabasesPorHeuristica(texto, relacao)));
-    }
-    return [...modulos.values()];
-}
-export async function importarProjetoLegado(fonte, diretorio, namespaceBase) {
-    const base = path.resolve(diretorio);
-    const namespace = inferirNamespaceBase(base, namespaceBase);
-    let modulos = [];
-    if (fonte === "nestjs") {
-        modulos = await importarTypeScriptBase(base, namespace, true);
-    }
-    else if (fonte === "nextjs") {
-        modulos = await importarNextJsBase(base, namespace);
-    }
-    else if (fonte === "nextjs-consumer") {
-        modulos = await importarNextJsConsumerBase(base, namespace);
-    }
-    else if (fonte === "react-vite-consumer") {
-        modulos = await importarReactViteConsumerBase(base, namespace);
-    }
-    else if (fonte === "angular-consumer") {
-        modulos = await importarAngularConsumerBase(base, namespace);
-    }
-    else if (fonte === "flutter-consumer") {
-        modulos = await importarFlutterConsumerBase(base, namespace);
-    }
-    else if (fonte === "firebase") {
-        modulos = await importarFirebaseBase(base, namespace);
-    }
-    else if (fonte === "typescript") {
-        modulos = await importarTypeScriptBase(base, namespace, false);
-    }
-    else if (fonte === "fastapi") {
-        modulos = await importarPythonBase(base, namespace, "fastapi");
-    }
-    else if (fonte === "flask") {
-        modulos = await importarPythonBase(base, namespace, "flask");
-    }
-    else if (fonte === "python") {
-        modulos = await importarPythonBase(base, namespace, "nenhum");
-    }
-    else if (fonte === "dart") {
-        modulos = await importarDartBase(base, namespace);
-    }
-    else if (fonte === "dotnet") {
-        modulos = await importarDotnetBase(base, namespace);
-    }
-    else if (fonte === "java") {
-        modulos = await importarJavaBase(base, namespace);
-    }
-    else if (fonte === "go") {
-        modulos = await importarGoBase(base, namespace);
-    }
-    else if (fonte === "rust") {
-        modulos = await importarRustBase(base, namespace);
-    }
-    else if (fonte === "cpp") {
-        modulos = await importarCppBase(base, namespace);
-    }
-    const arquivos = [];
-    for (const modulo of modulos) {
-        const bruto = moduloParaCodigo(modulo);
-        const formatado = await formatarModuloImportado(bruto, `${modulo.nome}.sema`);
-        arquivos.push(montarArquivoImportado(modulo, namespace, formatado));
-    }
-    const diagnosticos = compilarProjeto(arquivos.map((arquivo) => ({
-        caminho: path.join(base, ".tmp", "importado", arquivo.caminhoRelativo),
-        codigo: arquivo.conteudo,
-    }))).diagnosticos;
-    return {
-        fonte,
-        diretorio: base,
-        namespaceBase: namespace,
-        arquivos,
-        diagnosticos,
-    };
-}
-export function resumoImportacao(resultado) {
-    return {
-        modulos: resultado.arquivos.length,
-        tarefas: resultado.arquivos.reduce((total, arquivo) => total + arquivo.tarefas, 0),
-        rotas: resultado.arquivos.reduce((total, arquivo) => total + arquivo.rotas, 0),
-        entidades: resultado.arquivos.reduce((total, arquivo) => total + arquivo.entidades, 0),
-        enums: resultado.arquivos.reduce((total, arquivo) => total + arquivo.enums, 0),
-        databases: resultado.arquivos.reduce((total, arquivo) => total + arquivo.databases, 0),
-        diagnosticos: resultado.diagnosticos.length,
-        sucesso: !temErros(resultado.diagnosticos),
-    };
-}
+// SEMA-GOVERNED: sema.governanca_ia_contexto
+// Descricao: CLI particionada; consulte contratos/sema/governanca_ia_contexto.sema antes de editar.
+export * from "./importador.part01.js";
+export * from "./importador.part02.js";
+export * from "./importador.part03.js";
+export * from "./importador.part04.js";
+export * from "./importador.part05.js";
+export * from "./importador.part06.js";
+export * from "./importador.part07.js";
+export * from "./importador.part08.js";
+export * from "./importador.part09.js";
 //# sourceMappingURL=importador.js.map