@semacode/cli 2.3.1 → 3.0.0

package/dist/driftEscopo.js

@@ -2,18 +2,13 @@
 // Descricao: planeja o conjunto fisico minimo que pode ser indexado antes de qualquer caminhada de drift.
 import { lstat, realpath } from "node:fs/promises";
 import path from "node:path";
-import { resolverDiretoriosCodigoEscopoReal } from "./drift.part02.js";
+import { filtrarCaminhosEscopoReal, resolverDiretoriosCodigoEscopoReal, } from "./drift.part02.js";
 import { candidatosReferenciaLocalDrift, extrairReferenciasLocaisDrift, raizesCodigoLogicasDrift, } from "./driftEscopoReferencias.js";
 export { extrairReferenciasLocaisDrift } from "./driftEscopoReferencias.js";
 const CONCORRENCIA_SONDAGENS_DRIFT = 16;
 const CONCORRENCIA_MAPEAMENTO_DEPENDENCIAS_DRIFT = 8;
 const EXTENSAO_POR_ORIGEM = {
-    // O indexador TypeScript tambem cobre JavaScript legado. Essa compatibilidade
-    // e necessaria para contratos antigos que usam `ts:` para simbolos browser-side.
     ts: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"],
-    // O resolvedor semantico trata JS/TS como a mesma familia. O planejamento
-    // precisa sondar a mesma familia para nao descartar uma implementacao `js:`
-    // escrita fisicamente em TypeScript antes de o resolvedor poder avalia-la.
     js: [".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx"],
     py: [".py"],
     dart: [".dart"],
@@ -25,6 +20,10 @@ const EXTENSAO_POR_ORIGEM = {
     cpp: [".cpp", ".cc", ".cxx", ".hpp", ".h"],
     php: [".php"],
 };
+const EXTENSOES_CODIGO_PLANEJADO = new Set([
+    ...Object.values(EXTENSAO_POR_ORIGEM).flat(),
+    ".sql", ".psql", ".ddl", ".prisma",
+]);
 function chaveCaminho(caminho) {
     const absoluto = path.normalize(path.resolve(caminho));
     return process.platform === "win32" ? absoluto.toLowerCase() : absoluto;
@@ -35,6 +34,17 @@ function caminhoEstaDentro(raiz, alvo) {
         && !relativo.startsWith(`..${path.sep}`)
         && !path.isAbsolute(relativo));
 }
+function identidadesArquivoIguais(a, b) {
+    return a.isFile()
+        && b.isFile()
+        && !a.isSymbolicLink()
+        && !b.isSymbolicLink()
+        && a.dev === b.dev
+        && a.ino === b.ino
+        && a.size === b.size
+        && a.mtimeNs === b.mtimeNs
+        && a.ctimeNs === b.ctimeNs;
+}
 async function mapearComLimite(itens, limite, executar) {
     if (itens.length === 0) {
         return [];
@@ -56,12 +66,14 @@ async function mapearComLimite(itens, limite, executar) {
 }
 async function arquivoRegularContido(caminho, raizReal) {
     try {
-        const informacao = await lstat(caminho);
-        if (!informacao.isFile() || informacao.isSymbolicLink()) {
+        const informacaoAntes = await lstat(caminho, { bigint: true });
+        if (!informacaoAntes.isFile() || informacaoAntes.isSymbolicLink()) {
             return false;
         }
         const caminhoReal = await realpath(caminho);
-        return caminhoEstaDentro(raizReal, caminhoReal);
+        const informacaoDepois = await lstat(caminho, { bigint: true });
+        return caminhoEstaDentro(raizReal, caminhoReal)
+            && identidadesArquivoIguais(informacaoAntes, informacaoDepois);
     }
     catch {
         return false;
@@ -87,17 +99,29 @@ function implementacoesModulo(ir) {
         ...ir.superficies.flatMap((superficie) => superficie.implementacoesExternas),
     ];
 }
+function moduloExigeAncoraCodigo(ir) {
+    return ir.tasks.length > 0
+        || ir.routes.length > 0
+        || ir.superficies.length > 0
+        || implementacoesModulo(ir).length > 0
+        || vinculosModulo(ir).some((vinculo) => Boolean(vinculo.arquivo || vinculo.tipo === "arquivo"));
+}
 function resolverArquivoWorkspace(baseProjeto, valor) {
     const absoluto = path.isAbsolute(valor)
         ? path.resolve(valor)
         : path.resolve(baseProjeto, valor);
     return caminhoEstaDentro(baseProjeto, absoluto) ? absoluto : undefined;
 }
+function descreverArquivoForaWorkspace(valor) {
+    const nome = path.basename(path.normalize(valor)) || "alvo";
+    return `[fora_do_workspace]/${nome}`;
+}
 function variantesSegmentoDiretorio(segmento) {
     const camel = segmento.replace(/_([a-z0-9])/gi, (_ocorrencia, caractere) => caractere.toUpperCase());
     return [...new Set([
             segmento,
             segmento.includes("_") ? segmento.replace(/_/g, "-") : undefined,
+            segmento.includes("_") && camel !== segmento ? camel : undefined,
             /(?:^|_)id$/i.test(segmento) ? `[${segmento}]` : undefined,
             /(?:^|_)id$/i.test(segmento) && camel !== segmento ? `[${camel}]` : undefined,
         ].filter((item) => Boolean(item)))];
@@ -125,6 +149,17 @@ function variantesNomeArquivo(segmento) {
             pascal && pascal !== segmento ? pascal : undefined,
         ].filter((item) => Boolean(item)))];
 }
+function resolverDiretoriosCodigoPlanejados(contexto, irs, configuracao) {
+    const raizesModulo = irs.flatMap((ir) => {
+        const primeiroSegmento = ir.nome.split(".").map((item) => item.trim()).find(Boolean);
+        return primeiroSegmento
+            ? variantesNomeArquivo(primeiroSegmento).map((segmento) => path.resolve(contexto.baseProjeto, segmento))
+            : [];
+    });
+    const candidatos = [...resolverDiretoriosCodigoEscopoReal(contexto, configuracao), ...raizesModulo];
+    return [...new Map(filtrarCaminhosEscopoReal(candidatos, contexto, configuracao)
+            .map((diretorio) => [chaveCaminho(diretorio), diretorio])).values()];
+}
 function variantesCaminhoSegmentos(segmentos) {
     let variantes = [[]];
     for (const segmento of segmentos) {
@@ -133,24 +168,26 @@ function variantesCaminhoSegmentos(segmentos) {
     }
     return variantes.slice(0, 16);
 }
-function candidatosArquivoImpl(contexto, impl) {
-    const candidatos = new Map();
-    const adicionar = (caminho) => {
-        adicionarCandidatoPreservandoForma(candidatos, contexto.baseProjeto, caminho);
-    };
+function candidatosArquivoImpl(contexto, impl, diretoriosCodigo = contexto.diretoriosCodigo) {
+    const grupos = [];
     if (impl.origemArquivo) {
         const declarado = resolverArquivoWorkspace(contexto.baseProjeto, impl.origemArquivo);
         if (declarado) {
-            adicionar(declarado);
+            grupos.push([declarado]);
         }
     }
     const partes = impl.caminho.split(".").map((parte) => parte.trim()).filter(Boolean);
     if (partes.length < 2) {
-        return [...candidatos.values()];
+        return grupos;
     }
-    const bases = [contexto.baseProjeto, ...contexto.diretoriosCodigo];
+    const bases = [...new Map([contexto.baseProjeto, ...diretoriosCodigo]
+            .map((base) => [chaveCaminho(base), base])).values()];
     const extensoes = EXTENSAO_POR_ORIGEM[impl.origem] ?? [];
     for (const removerCauda of [1, 2]) {
+        const candidatos = new Map();
+        const adicionar = (caminho) => {
+            adicionarCandidatoPreservandoForma(candidatos, contexto.baseProjeto, caminho);
+        };
         const segmentosOriginais = partes.slice(0, Math.max(1, partes.length - removerCauda));
         for (const base of bases) {
             const nomeBase = path.basename(base).toLowerCase();
@@ -173,10 +210,13 @@ function candidatosArquivoImpl(contexto, impl) {
                 }
             }
         }
+        if (candidatos.size > 0) {
+            grupos.push([...candidatos.values()]);
+        }
     }
-    return [...candidatos.values()];
+    return grupos;
 }
-function candidatosConsumerDeterministicos(contexto, irs, termosEscopo) {
+function candidatosConsumerDeterministicos(contexto, irs, termosEscopo, diretoriosCodigo) {
     const segmentos = new Set();
     for (const termo of termosEscopo) {
         segmentos.add(termo);
@@ -191,7 +231,7 @@ function candidatosConsumerDeterministicos(contexto, irs, termosEscopo) {
     }
     const candidatos = new Map();
     const extensoes = [".ts", ".tsx", ".js", ".jsx"];
-    for (const raiz of contexto.diretoriosCodigo) {
+    for (const raiz of diretoriosCodigo) {
         for (const segmento of segmentos) {
             for (const extensao of extensoes) {
                 for (const relativo of [
@@ -200,15 +240,14 @@ function candidatosConsumerDeterministicos(contexto, irs, termosEscopo) {
                     ["src", "pages", `${segmento}${extensao}`],
                     ["pages", `${segmento}${extensao}`],
                 ]) {
-                    const absoluto = path.resolve(raiz, ...relativo);
-                    adicionarCandidatoPreservandoForma(candidatos, contexto.baseProjeto, absoluto);
+                    adicionarCandidatoPreservandoForma(candidatos, contexto.baseProjeto, path.resolve(raiz, ...relativo));
                 }
             }
         }
     }
     return [...candidatos.values()];
 }
-function candidatosRotasDeterministicos(contexto, irs) {
+function candidatosRotasDeterministicos(contexto, irs, diretoriosCodigo) {
     const candidatos = new Map();
     const extensoes = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py"];
     const segmentos = new Set();
@@ -219,7 +258,7 @@ function candidatosRotasDeterministicos(contexto, irs) {
             }
         }
     }
-    for (const raiz of contexto.diretoriosCodigo) {
+    for (const raiz of diretoriosCodigo) {
         for (const segmento of segmentos) {
             const nomes = variantesNomeArquivo(segmento);
             for (const nome of nomes) {
@@ -238,7 +277,7 @@ function candidatosRotasDeterministicos(contexto, irs) {
     }
     return [...candidatos.values()];
 }
-function candidatosConvencionaisEscopo(contexto, irs) {
+function candidatosConvencionaisEscopo(contexto, irs, diretoriosCodigo) {
     const candidatos = new Map();
     const adicionar = (caminho) => {
         adicionarCandidatoPreservandoForma(candidatos, contexto.baseProjeto, caminho);
@@ -247,7 +286,7 @@ function candidatosConvencionaisEscopo(contexto, irs) {
     const possuiRotas = irs.some((ir) => ir.routes.length > 0);
     const possuiPersistencia = irs.some((ir) => ir.databases.length > 0
         || ir.tasks.some((task) => task.effects.some((efeito) => /\b(?:db|database|persist|storage)\b/i.test(efeito))));
-    const bases = [contexto.baseProjeto, ...contexto.diretoriosCodigo];
+    const bases = diretoriosCodigo;
     if (possuiRotas && origens.has("rust")) {
         for (const base of bases) {
             adicionar(path.join(base, "main.rs"));
@@ -266,19 +305,21 @@ function candidatosConvencionaisEscopo(contexto, irs) {
     }
     return [...candidatos.values()];
 }
-function escolherDiretoriosLogicos(contexto, arquivos) {
-    const candidatos = [...new Map(contexto.diretoriosCodigo
+function escolherDiretoriosLogicos(contexto, arquivos, diretoriosCodigo = contexto.diretoriosCodigo) {
+    const candidatos = [...new Map(diretoriosCodigo
             .map((diretorio) => path.resolve(diretorio))
             .map((diretorio) => [chaveCaminho(diretorio), diretorio])).values()]
         .sort((a, b) => b.length - a.length || a.localeCompare(b, "pt-BR"));
     const escolhidos = new Map();
     for (const arquivo of arquivos) {
-        const raiz = candidatos.find((diretorio) => caminhoEstaDentro(diretorio, arquivo))
-            ?? path.dirname(arquivo);
-        escolhidos.set(chaveCaminho(raiz), raiz);
+        if (!EXTENSOES_CODIGO_PLANEJADO.has(path.extname(arquivo).toLowerCase())) {
+            continue;
+        }
+        const raiz = candidatos.find((diretorio) => caminhoEstaDentro(diretorio, arquivo));
+        const raizEfetiva = raiz ?? path.dirname(arquivo);
+        escolhidos.set(chaveCaminho(raizEfetiva), raizEfetiva);
     }
-    return [...escolhidos.values()]
-        .sort((a, b) => a.localeCompare(b, "pt-BR"));
+    return [...escolhidos.values()].sort((a, b) => a.localeCompare(b, "pt-BR"));
 }
 export async function planejarEscopoDrift(contexto, configuracao) {
     if (configuracao.escopo === "projeto") {
@@ -308,7 +349,9 @@ export async function planejarEscopoDrift(contexto, configuracao) {
     const declarados = new Map();
     const ausentes = new Map();
     const inferidos = new Map();
+    const bloqueiosPlano = new Set();
     const raizReal = await realpath(contexto.baseProjeto);
+    const diretoriosCodigoPermitidos = resolverDiretoriosCodigoPlanejados(contexto, irs, configuracao);
     const vinculosPlanejados = irs.flatMap((ir) => vinculosModulo(ir))
         .map((vinculo) => vinculo.arquivo ?? (vinculo.tipo === "arquivo" ? vinculo.valor : undefined))
         .filter((valor) => Boolean(valor))
@@ -318,49 +361,70 @@ export async function planejarEscopoDrift(contexto, configuracao) {
     }));
     const implementacoesPlanejadas = irs
         .flatMap((ir) => implementacoesModulo(ir))
-        .map((impl) => candidatosArquivoImpl(contexto, impl));
-    const candidatosDeterministicos = [
-        ...candidatosConsumerDeterministicos(contexto, irs, configuracao.termosEscopo),
-        ...candidatosRotasDeterministicos(contexto, irs),
-        ...candidatosConvencionaisEscopo(contexto, irs),
-    ];
+        .map((impl) => candidatosArquivoImpl(contexto, impl, diretoriosCodigoPermitidos));
     const resultadoSondagens = await sondarArquivosRegularesContidos([
         ...vinculosPlanejados.flatMap((vinculo) => vinculo.absoluto ? [vinculo.absoluto] : []),
-        ...implementacoesPlanejadas.flat(),
-        ...candidatosDeterministicos,
+        ...implementacoesPlanejadas.flat(2),
     ], raizReal);
     const arquivoExiste = (arquivo) => resultadoSondagens.get(chaveCaminho(arquivo)) === true;
     for (const vinculo of vinculosPlanejados) {
         if (!vinculo.absoluto) {
-            ausentes.set(`fora:${vinculo.valor}`, vinculo.valor);
+            const descricaoSegura = descreverArquivoForaWorkspace(vinculo.valor);
+            ausentes.set(`fora:${descricaoSegura}`, descricaoSegura);
             continue;
         }
         if (arquivoExiste(vinculo.absoluto)) {
-            const chave = chaveCaminho(vinculo.absoluto);
-            if (!declarados.has(chave)) {
-                declarados.set(chave, vinculo.absoluto);
-            }
+            declarados.set(chaveCaminho(vinculo.absoluto), vinculo.absoluto);
         }
         else {
             ausentes.set(chaveCaminho(vinculo.absoluto), vinculo.absoluto);
         }
     }
-    for (const candidatos of implementacoesPlanejadas) {
-        const encontrados = candidatos.filter(arquivoExiste);
+    const raizesDeclaradasCodigo = escolherDiretoriosLogicos(contexto, [...declarados.values()]);
+    for (const gruposCandidatos of implementacoesPlanejadas) {
+        const grupoResolvido = gruposCandidatos.find((grupo) => grupo.some(arquivoExiste));
+        let encontrados = grupoResolvido?.filter(arquivoExiste) ?? [];
+        const encontradosDeclarados = encontrados.filter((candidato) => declarados.has(chaveCaminho(candidato)));
+        if (encontradosDeclarados.length > 0) {
+            encontrados = encontradosDeclarados;
+        }
+        else if (raizesDeclaradasCodigo.length > 0) {
+            const proximosDeDeclarados = encontrados.filter((candidato) => raizesDeclaradasCodigo.some((raiz) => caminhoEstaDentro(raiz, candidato)));
+            if (proximosDeDeclarados.length > 0) {
+                encontrados = proximosDeDeclarados;
+            }
+        }
+        if (encontrados.length > 1) {
+            bloqueiosPlano.add("escopo_estreito_ambiguo");
+            continue;
+        }
         for (const candidato of encontrados) {
             const chave = chaveCaminho(candidato);
             if (!declarados.has(chave) && !inferidos.has(chave)) {
                 inferidos.set(chave, candidato);
             }
         }
-        if (encontrados.length === 0 && candidatos[0]) {
-            ausentes.set(chaveCaminho(candidatos[0]), candidatos[0]);
+        const primeiroCandidato = gruposCandidatos[0]?.[0];
+        if (encontrados.length === 0 && primeiroCandidato) {
+            ausentes.set(chaveCaminho(primeiroCandidato), primeiroCandidato);
         }
     }
-    for (const candidato of candidatosDeterministicos.filter(arquivoExiste)) {
-        const chave = chaveCaminho(candidato);
-        if (!declarados.has(chave) && !inferidos.has(chave)) {
-            inferidos.set(chave, candidato);
+    const raizesAncoradas = escolherDiretoriosLogicos(contexto, [...declarados.values(), ...inferidos.values()]);
+    if (raizesAncoradas.length > 0) {
+        const candidatosDeterministicos = [
+            ...candidatosConsumerDeterministicos(contexto, irs, configuracao.termosEscopo, raizesAncoradas),
+            ...candidatosRotasDeterministicos(contexto, irs, raizesAncoradas),
+            ...candidatosConvencionaisEscopo(contexto, irs, raizesAncoradas),
+        ];
+        const sondagensDeterministicas = await sondarArquivosRegularesContidos(candidatosDeterministicos, raizReal);
+        for (const candidato of candidatosDeterministicos) {
+            if (sondagensDeterministicas.get(chaveCaminho(candidato)) !== true) {
+                continue;
+            }
+            const chave = chaveCaminho(candidato);
+            if (!declarados.has(chave) && !inferidos.has(chave)) {
+                inferidos.set(chave, candidato);
+            }
         }
     }
     const arquivosMesclados = new Map(declarados);
@@ -369,13 +433,15 @@ export async function planejarEscopoDrift(contexto, configuracao) {
             arquivosMesclados.set(chave, arquivo);
         }
     }
-    const arquivos = [...arquivosMesclados.values()]
-        .sort((a, b) => a.localeCompare(b, "pt-BR"));
-    const arquivosAusentes = [...ausentes.values()]
-        .sort((a, b) => a.localeCompare(b, "pt-BR"));
-    const bloqueios = arquivos.length === 0
-        ? ["escopo_estreito_sem_vinculos"]
-        : [];
+    const arquivos = [...arquivosMesclados.values()].sort((a, b) => a.localeCompare(b, "pt-BR"));
+    const arquivosAusentes = [...ausentes.values()].sort((a, b) => a.localeCompare(b, "pt-BR"));
+    const exigeAncoraCodigo = irs.some(moduloExigeAncoraCodigo);
+    if (arquivos.length === 0
+        && exigeAncoraCodigo
+        && !bloqueiosPlano.has("escopo_estreito_ambiguo")) {
+        bloqueiosPlano.add("escopo_estreito_sem_vinculos");
+    }
+    const bloqueios = [...bloqueiosPlano].sort((a, b) => a.localeCompare(b, "pt-BR"));
     return {
         escopo: configuracao.escopo,
         estrategia: "arquivos_vinculados",
@@ -417,43 +483,86 @@ async function arquivoRegularConfinadoDependencias(caminho, confinamento) {
         return false;
     }
     try {
-        const informacao = await lstat(absoluto);
-        if (!informacao.isFile() || informacao.isSymbolicLink()) {
+        const informacaoAntes = await lstat(absoluto, { bigint: true });
+        if (!informacaoAntes.isFile() || informacaoAntes.isSymbolicLink()) {
             return false;
         }
         const caminhoReal = await realpath(absoluto);
+        const informacaoDepois = await lstat(absoluto, { bigint: true });
         return caminhoEstaDentro(confinamento.raizWorkspaceReal, caminhoReal)
-            && confinamento.raizesCodigoReais.some((raiz) => caminhoEstaDentro(raiz, caminhoReal));
+            && confinamento.raizesCodigoReais.some((raiz) => caminhoEstaDentro(raiz, caminhoReal))
+            && identidadesArquivoIguais(informacaoAntes, informacaoDepois);
     }
     catch {
         return false;
     }
 }
-async function resolverReferenciaLocalExistente(contexto, arquivoOrigem, referencia, confinamento, catalogados) {
-    for (const candidatoBruto of candidatosReferenciaLocalDrift(contexto, arquivoOrigem, referencia)) {
-        const candidato = catalogados?.get(chaveCaminho(candidatoBruto)) ?? candidatoBruto;
-        if (catalogados && !catalogados.has(chaveCaminho(candidatoBruto))) {
-            continue;
+function candidatoAusenteSeguro(contexto, candidatos, referencia) {
+    const seguro = candidatos.find((candidato) => caminhoEstaDentro(contexto.baseProjeto, candidato));
+    return seguro ?? referencia;
+}
+function referenciaPythonEhLocalObrigatoria(referencia) {
+    return referencia.startsWith("python:.");
+}
+async function resolverReferenciasLocais(contexto, arquivoOrigem, referencias, confinamento) {
+    const resultados = await mapearComLimite(referencias, CONCORRENCIA_SONDAGENS_DRIFT, async (referencia) => {
+        const candidatos = candidatosReferenciaLocalDrift(contexto, arquivoOrigem, referencia);
+        for (const candidato of candidatos) {
+            if (await arquivoRegularConfinadoDependencias(candidato, confinamento)) {
+                return { referencia, resolvida: candidato };
+            }
         }
-        if (await arquivoRegularConfinadoDependencias(candidato, confinamento)) {
-            return candidato;
+        const ehPython = referencia.startsWith("python:");
+        return {
+            referencia,
+            ausente: !ehPython || referenciaPythonEhLocalObrigatoria(referencia)
+                ? candidatoAusenteSeguro(contexto, candidatos, referencia)
+                : undefined,
+        };
+    });
+    const modulosPythonResolvidos = resultados
+        .filter((item) => item.resolvida && item.referencia.startsWith("python:"))
+        .map((item) => item.referencia.slice("python:".length));
+    const dependenciasPythonMarcadas = resultados.map((item) => {
+        if (item.resolvida || !item.referencia.startsWith("python:")) {
+            return item;
         }
-    }
-    return undefined;
+        const modulo = item.referencia.slice("python:".length);
+        const prefixoLocalResolvido = modulosPythonResolvidos.some((prefixo) => prefixo !== modulo && modulo.startsWith(`${prefixo}.`));
+        if (!referenciaPythonEhLocalObrigatoria(item.referencia) && !prefixoLocalResolvido) {
+            return item;
+        }
+        const candidatos = candidatosReferenciaLocalDrift(contexto, arquivoOrigem, item.referencia);
+        return {
+            referencia: item.referencia,
+            ausente: candidatoAusenteSeguro(contexto, candidatos, item.referencia),
+        };
+    });
+    const modulosPythonAusentes = dependenciasPythonMarcadas
+        .filter((item) => item.ausente && item.referencia.startsWith("python:"))
+        .map((item) => item.referencia.slice("python:".length));
+    return dependenciasPythonMarcadas.map((item) => {
+        if (!item.ausente || !item.referencia.startsWith("python:")) {
+            return item;
+        }
+        const modulo = item.referencia.slice("python:".length);
+        const possuiPaiAusente = modulosPythonAusentes.some((prefixo) => prefixo !== modulo && modulo.startsWith(`${prefixo}.`));
+        return possuiPaiAusente ? { referencia: item.referencia } : item;
+    });
 }
-export async function expandirDependenciasPlanoDrift(contexto, plano, catalogo, cache) {
+export async function expandirDependenciasPlanoDrift(contexto, plano, catalogo) {
     if (plano.estrategia !== "arquivos_vinculados" || plano.arquivos.length === 0) {
         return plano;
     }
     const arquivos = new Map(plano.arquivos.map((arquivo) => [chaveCaminho(arquivo), arquivo]));
     const inferidos = new Map(plano.arquivosInferidos.map((arquivo) => [chaveCaminho(arquivo), arquivo]));
+    const ausentes = new Map(plano.arquivosAusentes.map((arquivo) => [chaveCaminho(arquivo), arquivo]));
     const visitados = new Set();
     const fila = [...plano.arquivos];
     const confinamento = await construirConfinamentoDependencias(contexto);
     const dependencias = new Map(Object.entries(plano.dependencias).map(([arquivo, itens]) => [arquivo, new Set(itens)]));
     while (fila.length > 0) {
-        const lote = fila.splice(0)
-            .filter((arquivo) => {
+        const lote = fila.splice(0).filter((arquivo) => {
             const chave = chaveCaminho(arquivo);
             if (visitados.has(chave)) {
                 return false;
@@ -462,102 +571,77 @@ export async function expandirDependenciasPlanoDrift(contexto, plano, catalogo,
             return true;
         });
         const resultadosLote = await mapearComLimite(lote, CONCORRENCIA_MAPEAMENTO_DEPENDENCIAS_DRIFT, async (arquivo) => {
-            let referencias;
             try {
-                if (cache) {
-                    const estado = await cache.resolverArquivo({
-                        arquivo,
-                        analise: "dependencias-v4",
-                        ler: () => catalogo.ler(arquivo),
-                        extrair: (conteudo) => extrairReferenciasLocaisDrift(conteudo.texto),
-                        validar: (valor) => Array.isArray(valor) && valor.every((item) => typeof item === "string"),
-                    });
-                    referencias = estado.valor;
-                }
-                else {
-                    referencias = extrairReferenciasLocaisDrift(await catalogo.lerTexto(arquivo));
-                }
+                const referencias = extrairReferenciasLocaisDrift(await catalogo.lerTexto(arquivo), { contexto, arquivoOrigem: arquivo });
+                return {
+                    arquivo,
+                    referencias: await resolverReferenciasLocais(contexto, arquivo, referencias, confinamento),
+                };
             }
             catch {
-                return { arquivo, resolvidas: [] };
+                return {
+                    arquivo,
+                    referencias: [],
+                    leituraFalhou: true,
+                };
+            }
+        });
+        const candidatosParaIncluir = new Map();
+        for (const resultado of resultadosLote) {
+            if (resultado.leituraFalhou) {
+                ausentes.set(chaveCaminho(resultado.arquivo), resultado.arquivo);
             }
-            const resolvidas = new Map();
-            for (const referencia of referencias) {
-                const candidato = await resolverReferenciaLocalExistente(contexto, arquivo, referencia, confinamento);
-                if (candidato) {
-                    resolvidas.set(chaveCaminho(candidato), candidato);
+            for (const referencia of resultado.referencias) {
+                if (referencia.ausente) {
+                    ausentes.set(chaveCaminho(referencia.ausente), referencia.ausente);
+                }
+                if (referencia.resolvida && !catalogo.contem(referencia.resolvida)) {
+                    candidatosParaIncluir.set(chaveCaminho(referencia.resolvida), referencia.resolvida);
                 }
             }
-            return { arquivo, resolvidas: [...resolvidas.values()] };
-        });
+        }
+        await catalogo.incluir([...candidatosParaIncluir.values()]);
         const novos = new Map();
-        for (const { arquivo, resolvidas } of resultadosLote) {
-            if (resolvidas.length > 0) {
-                const lista = dependencias.get(arquivo) ?? new Set();
-                for (const candidato of resolvidas) {
-                    lista.add(candidato);
-                    const chave = chaveCaminho(candidato);
-                    if (!arquivos.has(chave)) {
-                        novos.set(chave, candidato);
-                    }
+        for (const resultado of resultadosLote) {
+            const lista = dependencias.get(resultado.arquivo) ?? new Set();
+            for (const referencia of resultado.referencias) {
+                if (!referencia.resolvida) {
+                    continue;
+                }
+                if (!catalogo.contem(referencia.resolvida)) {
+                    ausentes.set(chaveCaminho(referencia.resolvida), referencia.resolvida);
+                    continue;
+                }
+                lista.add(referencia.resolvida);
+                const chave = chaveCaminho(referencia.resolvida);
+                if (!arquivos.has(chave)) {
+                    novos.set(chave, referencia.resolvida);
                 }
-                dependencias.set(arquivo, lista);
             }
-        }
-        if (novos.size > 0) {
-            const novosOrdenados = [...novos.values()].sort((a, b) => a.localeCompare(b, "pt-BR"));
-            await catalogo.incluir(novosOrdenados);
-            for (const candidato of novosOrdenados) {
-                const chave = chaveCaminho(candidato);
-                arquivos.set(chave, candidato);
-                inferidos.set(chave, candidato);
-                fila.push(candidato);
+            if (lista.size > 0) {
+                dependencias.set(resultado.arquivo, lista);
             }
         }
+        const novosOrdenados = [...novos.values()].sort((a, b) => a.localeCompare(b, "pt-BR"));
+        for (const candidato of novosOrdenados) {
+            const chave = chaveCaminho(candidato);
+            arquivos.set(chave, candidato);
+            inferidos.set(chave, candidato);
+            fila.push(candidato);
+        }
     }
     const arquivosExpandidos = [...arquivos.values()].sort((a, b) => a.localeCompare(b, "pt-BR"));
+    const arquivosAusentes = [...ausentes.values()].sort((a, b) => a.localeCompare(b, "pt-BR"));
     return {
         ...plano,
         arquivos: arquivosExpandidos,
         arquivosInferidos: [...inferidos.values()].sort((a, b) => a.localeCompare(b, "pt-BR")),
+        arquivosAusentes,
         diretorios: escolherDiretoriosLogicos(contexto, arquivosExpandidos),
+        cobertura: arquivosAusentes.length === 0 && plano.bloqueios.length === 0 ? "completa" : "parcial",
         dependencias: Object.fromEntries([...dependencias.entries()]
             .sort(([a], [b]) => a.localeCompare(b, "pt-BR"))
             .map(([arquivo, itens]) => [arquivo, [...itens].sort((a, b) => a.localeCompare(b, "pt-BR"))])),
     };
 }
-export async function mapearDependenciasCatalogadasDrift(contexto, catalogo, cache, arquivos = catalogo.arquivosCatalogados()) {
-    const confinamento = await construirConfinamentoDependencias(contexto);
-    const catalogados = new Map(catalogo.arquivosCatalogados().map((arquivo) => [chaveCaminho(arquivo), arquivo]));
-    const arquivosOrdenados = [...arquivos].sort((a, b) => a.localeCompare(b, "pt-BR"));
-    const resultados = await mapearComLimite(arquivosOrdenados, CONCORRENCIA_MAPEAMENTO_DEPENDENCIAS_DRIFT, async (arquivo) => {
-        let referencias;
-        try {
-            const estado = await cache.resolverArquivo({
-                arquivo,
-                analise: "dependencias-v4",
-                ler: () => catalogo.ler(arquivo),
-                extrair: (conteudo) => extrairReferenciasLocaisDrift(conteudo.texto),
-                validar: (valor) => Array.isArray(valor) && valor.every((item) => typeof item === "string"),
-            });
-            referencias = estado.valor;
-        }
-        catch {
-            return undefined;
-        }
-        const resolvidas = new Map();
-        for (const referencia of referencias) {
-            const existente = await resolverReferenciaLocalExistente(contexto, arquivo, referencia, confinamento, catalogados);
-            if (existente) {
-                resolvidas.set(chaveCaminho(existente), existente);
-            }
-        }
-        return [
-            arquivo,
-            [...resolvidas.values()].sort((a, b) => a.localeCompare(b, "pt-BR")),
-        ];
-    });
-    const dependencias = new Map(resultados.filter((item) => Boolean(item)));
-    return Object.fromEntries([...dependencias.entries()].sort(([a], [b]) => a.localeCompare(b, "pt-BR")));
-}
 //# sourceMappingURL=driftEscopo.js.map

package/dist/driftEscopoReferencias.d.ts

@@ -1,4 +1,8 @@
 import type { ContextoProjetoCarregado } from "./projeto.js";
-export declare function extrairReferenciasLocaisDrift(codigo: string): string[];
+export interface OpcoesExtracaoReferenciasDrift {
+    contexto?: ContextoProjetoCarregado;
+    arquivoOrigem?: string;
+}
+export declare function extrairReferenciasLocaisDrift(codigo: string, opcoes?: OpcoesExtracaoReferenciasDrift): string[];
 export declare function raizesCodigoLogicasDrift(contexto: ContextoProjetoCarregado): string[];
 export declare function candidatosReferenciaLocalDrift(contexto: ContextoProjetoCarregado, arquivoOrigem: string, referencia: string): string[];