@semacode/cli 2.3.1 → 3.5.0

package/dist/driftCatalogo.js

@@ -1,9 +1,8 @@
-// SEMA-GOVERNED: sema.produto.governanca_ia.drift
-// Descrição: cataloga somente o plano explícito do drift e compartilha leituras e fingerprints de conteúdo.
+// SEMA-GOVERNED: sema.produto.governanca_ia.drift, sema.produto.governanca_ia.drift.cache.store
+// Descrição: cataloga somente o plano físico do drift e compartilha uma leitura estável por arquivo.
 import { createHash } from "node:crypto";
 import { lstat, open, readdir, realpath } from "node:fs/promises";
 import path from "node:path";
-export const SCHEMA_SNAPSHOT_CATALOGO_DRIFT = "sema.drift-catalog/v1";
 const CONCORRENCIA_PADRAO = 8;
 const CONCORRENCIA_MAXIMA = 64;
 function emitirEvento(observador, evento) {
@@ -35,7 +34,7 @@ function chaveCaminho(caminho) {
     return process.platform === "win32" ? normalizado.toLowerCase() : normalizado;
 }
 function caminhoEstaDentro(raiz, alvo) {
-    const relativo = path.relative(raiz, alvo);
+    const relativo = path.relative(path.resolve(raiz), path.resolve(alvo));
     return relativo === "" || (relativo !== ".."
         && !relativo.startsWith(`..${path.sep}`)
         && !path.isAbsolute(relativo));
@@ -45,10 +44,10 @@ function erroEhAusencia(erro) {
 }
 function assinaturaDiretorio(info) {
     return {
-        mtimeNs: info.mtimeNs.toString(),
-        ctimeNs: info.ctimeNs.toString(),
-        dev: info.dev.toString(),
-        ino: info.ino.toString(),
+        mtimeNs: info.mtimeNs,
+        ctimeNs: info.ctimeNs,
+        dev: info.dev,
+        ino: info.ino,
     };
 }
 function assinaturasDiretorioIguais(a, b) {
@@ -62,31 +61,49 @@ function identidadeArquivoEstavel(a, b) {
         && b.isFile()
         && !a.isSymbolicLink()
         && !b.isSymbolicLink()
+        && a.nlink === 1n
+        && b.nlink === 1n
         && a.dev === b.dev
         && a.ino === b.ino
         && a.size === b.size
         && a.mtimeNs === b.mtimeNs
         && a.ctimeNs === b.ctimeNs;
 }
-function registroObjeto(valor) {
-    return typeof valor === "object" && valor !== null && !Array.isArray(valor);
+function criarIdentidadeArquivoCatalogado(caminhoReal, informacao) {
+    return {
+        caminhoReal: path.resolve(caminhoReal),
+        dev: informacao.dev,
+        ino: informacao.ino,
+        nlink: informacao.nlink,
+        size: informacao.size,
+        mtimeNs: informacao.mtimeNs,
+        ctimeNs: informacao.ctimeNs,
+    };
 }
-function caminhoRelativoSeguro(valor) {
-    return typeof valor === "string"
-        && valor.length > 0
-        && valor !== "."
-        && valor !== ".."
-        && !valor.startsWith("../")
-        && !valor.includes("\\")
-        && !path.posix.isAbsolute(valor);
+function identidadeCatalogadaCorresponde(identidade, caminhoReal, informacao) {
+    return chaveCaminho(identidade.caminhoReal) === chaveCaminho(caminhoReal)
+        && informacao.isFile()
+        && !informacao.isSymbolicLink()
+        && identidade.nlink === 1n
+        && informacao.nlink === 1n
+        && identidade.dev === informacao.dev
+        && identidade.ino === informacao.ino
+        && identidade.size === informacao.size
+        && identidade.mtimeNs === informacao.mtimeNs
+        && identidade.ctimeNs === informacao.ctimeNs;
 }
-function diretorioRelativoSeguro(valor) {
-    return valor === "." || caminhoRelativoSeguro(valor);
+function chavesFisicasArquivo(identidade) {
+    const chaves = [`real:${chaveCaminho(identidade.caminhoReal)}`];
+    if (identidade.dev !== 0n || identidade.ino !== 0n) {
+        chaves.push(`id:${identidade.dev.toString()}:${identidade.ino.toString()}`);
+    }
+    return chaves;
 }
-function assinaturaDiretorioValida(valor) {
-    return registroObjeto(valor)
-        && ["mtimeNs", "ctimeNs", "dev", "ino"]
-            .every((campo) => typeof valor[campo] === "string" && /^\d+$/u.test(valor[campo]));
+function mesmoObjetoFisico(a, b) {
+    const possuiIdentidadeInode = (a.dev !== 0n || a.ino !== 0n) && (b.dev !== 0n || b.ino !== 0n);
+    return possuiIdentidadeInode
+        ? a.dev === b.dev && a.ino === b.ino
+        : chaveCaminho(a.caminhoReal) === chaveCaminho(b.caminhoReal);
 }
 async function mapearComLimite(itens, limite, executar) {
     if (itens.length === 0) {
@@ -111,14 +128,12 @@ class CatalogoDriftImplementacao {
     baseDiretorio;
     raizes;
     registros = new Map();
+    registrosFisicos = new Map();
     conteudos = new Map();
     extensoesPermitidas;
     concorrencia;
     observador;
     baseDiretorioReal;
-    extensoesSnapshot;
-    diretoriosVisitados = new Map();
-    diretoriosIgnoradosSnapshot = [];
     contadores = {
         diretoriosVisitados: 0,
         arquivosCatalogados: 0,
@@ -126,13 +141,13 @@ class CatalogoDriftImplementacao {
         bytesLidos: 0,
         acertosMemoriaConteudo: 0,
         origem: "plano_explicito",
-        diretoriosValidadosCache: 0,
     };
     constructor(opcoes) {
         this.baseDiretorio = path.resolve(opcoes.baseDiretorio ?? process.cwd());
         this.baseDiretorioReal = realpath(this.baseDiretorio);
         this.raizes = [...new Map((opcoes.raizes ?? [])
                 .map((raiz) => path.resolve(this.baseDiretorio, raiz))
+                .filter((raiz) => caminhoEstaDentro(this.baseDiretorio, raiz))
                 .map((raiz) => [chaveCaminho(raiz), raiz])).values()].sort((a, b) => a.localeCompare(b, "pt-BR"));
         const extensoes = opcoes.extensoes
             ?.map(normalizarExtensao)
@@ -140,21 +155,13 @@ class CatalogoDriftImplementacao {
         this.extensoesPermitidas = extensoes?.length
             ? new Set(extensoes)
             : undefined;
-        this.extensoesSnapshot = this.extensoesPermitidas
-            ? [...this.extensoesPermitidas].sort((a, b) => a.localeCompare(b, "en"))
-            : null;
         this.concorrencia = normalizarConcorrencia(opcoes.concorrencia);
         this.observador = opcoes.observador;
     }
-    async construir(arquivosExplicitos, diretoriosIgnorados, snapshot) {
+    async construir(arquivosExplicitos, diretoriosIgnorados) {
         await this.baseDiretorioReal;
-        this.diretoriosIgnoradosSnapshot = [...diretoriosIgnorados]
-            .sort((a, b) => a.localeCompare(b, "en"));
-        const restaurado = snapshot
-            ? await this.restaurarSnapshot(snapshot, diretoriosIgnorados, arquivosExplicitos)
-            : false;
-        if (!restaurado) {
-            this.contadores.origem = this.raizes.length > 0 ? "caminhada" : "plano_explicito";
+        if (this.raizes.length > 0) {
+            this.contadores.origem = "caminhada";
             await this.caminharRaizes(diretoriosIgnorados);
         }
         await this.incluir(arquivosExplicitos);
@@ -163,25 +170,12 @@ class CatalogoDriftImplementacao {
         const explicitos = [...new Map(arquivosExplicitos
                 .map((arquivo) => path.resolve(this.baseDiretorio, arquivo))
                 .map((arquivo) => [chaveCaminho(arquivo), arquivo])).values()].sort((a, b) => a.localeCompare(b, "pt-BR"));
-        await mapearComLimite(explicitos, this.concorrencia, async (arquivo) => {
-            if (!await this.caminhoPermaneceNoWorkspace(arquivo)) {
-                return;
-            }
-            let informacao;
-            try {
-                informacao = await lstat(arquivo);
-            }
-            catch (erro) {
-                if (erroEhAusencia(erro)) {
-                    return;
-                }
-                throw erro;
-            }
-            if (!informacao.isFile() || informacao.isSymbolicLink()) {
-                return;
-            }
-            this.adicionarArquivo(arquivo, true);
-        });
+        const sondagens = await mapearComLimite(explicitos, this.concorrencia, async (arquivo) => this.sondarArquivoSeguro(arquivo));
+        for (const sondagem of sondagens
+            .filter((item) => Boolean(item))
+            .sort((a, b) => a.caminho.localeCompare(b.caminho, "pt-BR"))) {
+            this.adicionarArquivo(sondagem, true);
+        }
     }
     listar(extensoesOuFiltro = [], raizes) {
         if (ehFiltroCatalogoDrift(extensoesOuFiltro)) {
@@ -192,9 +186,7 @@ class CatalogoDriftImplementacao {
             return this.listarEntradas({ extensoes }).map((arquivo) => arquivo.caminho);
         }
         const raizesAbsolutas = raizes.map((raiz) => path.resolve(this.baseDiretorio, raiz));
-        return this.listarEntradas({ extensoes })
-            .filter((arquivo) => raizesAbsolutas.some((raiz) => caminhoEstaDentro(raiz, arquivo.caminho)))
-            .map((arquivo) => arquivo.caminho);
+        return [...new Map(raizesAbsolutas.flatMap((raiz) => this.listarEntradas({ extensoes, raiz }).map((arquivo) => [chaveCaminho(arquivo.caminho), arquivo.caminho]))).values()].sort((a, b) => a.localeCompare(b, "pt-BR"));
     }
     listarEntradas(filtro = {}) {
         const extensoes = filtro.extensoes
@@ -203,9 +195,9 @@ class CatalogoDriftImplementacao {
         const raiz = filtro.raiz
             ? path.resolve(this.baseDiretorio, filtro.raiz)
             : undefined;
-        return [...this.registros.values()]
+        return [...new Set(this.registros.values())]
             .filter((registro) => !extensoes || extensoes.has(registro.extensao))
-            .filter((registro) => !raiz || caminhoEstaDentro(raiz, registro.caminho))
+            .filter((registro) => !raiz || [...registro.aliases].some((alias) => caminhoEstaDentro(raiz, alias)))
             .map((registro) => ({
             caminho: registro.caminho,
             extensao: registro.extensao,
@@ -231,18 +223,21 @@ class CatalogoDriftImplementacao {
         const chave = chaveCaminho(absoluto);
         const registro = this.registros.get(chave);
         if (!registro) {
-            return Promise.reject(new Error(`Arquivo fora do plano explicito do drift: ${absoluto}`));
+            const descricao = caminhoEstaDentro(this.baseDiretorio, absoluto)
+                ? absoluto
+                : `[fora_do_workspace]/${path.basename(absoluto)}`;
+            return Promise.reject(new Error(`Arquivo fora do plano explicito do drift: ${descricao}`));
         }
-        const existente = this.conteudos.get(chave);
+        const existente = this.conteudos.get(registro);
         if (existente) {
             this.contadores.acertosMemoriaConteudo += 1;
             return existente;
         }
-        const leitura = this.lerFisicamente(registro.caminho);
-        this.conteudos.set(chave, leitura);
+        const leitura = this.lerFisicamente(registro);
+        this.conteudos.set(registro, leitura);
         void leitura.catch(() => {
-            if (this.conteudos.get(chave) === leitura) {
-                this.conteudos.delete(chave);
+            if (this.conteudos.get(registro) === leitura) {
+                this.conteudos.delete(registro);
             }
         });
         return leitura;
@@ -253,23 +248,6 @@ class CatalogoDriftImplementacao {
     async digest(caminho) {
         return (await this.ler(caminho)).digest;
     }
-    async fingerprint(caminhos) {
-        const selecionados = caminhos
-            ? [...new Map(caminhos.map((caminho) => {
-                    const absoluto = path.resolve(this.baseDiretorio, caminho);
-                    return [chaveCaminho(absoluto), absoluto];
-                })).values()]
-            : this.arquivosCatalogados();
-        selecionados.sort((a, b) => chaveCaminho(a).localeCompare(chaveCaminho(b), "en"));
-        const itens = await mapearComLimite(selecionados, this.concorrencia, async (arquivo) => ({
-            caminho: chaveCaminho(arquivo).replace(/\\/g, "/"),
-            digest: await this.digest(arquivo),
-        }));
-        return `sha256:${createHash("sha256").update(JSON.stringify(itens)).digest("hex")}`;
-    }
-    obterFingerprint(caminhos) {
-        return this.fingerprint(caminhos);
-    }
     emitir(tipo, arquivo) {
         emitirEvento(this.observador, {
             tipo,
@@ -279,26 +257,6 @@ class CatalogoDriftImplementacao {
     metricas() {
         return { ...this.contadores };
     }
-    snapshot() {
-        return {
-            schema: SCHEMA_SNAPSHOT_CATALOGO_DRIFT,
-            raizes: this.raizes.map((raiz) => this.relativoSeguro(raiz, true)),
-            extensoes: this.extensoesSnapshot ? [...this.extensoesSnapshot] : null,
-            diretoriosIgnorados: [...this.diretoriosIgnoradosSnapshot],
-            diretorios: [...this.diretoriosVisitados.entries()]
-                .map(([caminho, assinatura]) => ({
-                caminho: this.relativoSeguro(caminho, true),
-                assinatura: { ...assinatura },
-            }))
-                .sort((a, b) => a.caminho.localeCompare(b.caminho, "en")),
-            arquivos: [...this.registros.values()]
-                .map((registro) => ({
-                caminho: this.relativoSeguro(registro.caminho),
-                explicito: registro.explicito,
-            }))
-                .sort((a, b) => a.caminho.localeCompare(b.caminho, "en")),
-        };
-    }
     async caminharRaizes(diretoriosIgnorados) {
         let nivel = [...this.raizes];
         const visitados = new Set();
@@ -335,22 +293,16 @@ class CatalogoDriftImplementacao {
             return [];
         }
         if (informacao.isFile()) {
-            this.adicionarArquivo(diretorio, false);
+            const sondagem = await this.sondarArquivoSeguro(diretorio);
+            if (sondagem) {
+                this.adicionarArquivo(sondagem, false);
+            }
             return [];
         }
         if (!informacao.isDirectory()) {
             return [];
         }
-        let entradas;
-        try {
-            entradas = await readdir(diretorio, { withFileTypes: true });
-        }
-        catch (erro) {
-            if (erroEhAusencia(erro)) {
-                return [];
-            }
-            throw erro;
-        }
+        const entradas = await readdir(diretorio, { withFileTypes: true });
         const informacaoDepois = await lstat(diretorio, { bigint: true });
         if (!informacaoDepois.isDirectory()
             || informacaoDepois.isSymbolicLink()
@@ -358,13 +310,13 @@ class CatalogoDriftImplementacao {
             throw new Error(`catalogo_diretorio_instavel:${diretorio}`);
         }
         this.contadores.diretoriosVisitados += 1;
-        this.diretoriosVisitados.set(path.resolve(diretorio), assinaturaDiretorio(informacaoDepois));
         emitirEvento(this.observador, {
             tipo: "catalog.visit",
             caminho: diretorio,
             categoria: "diretorio",
         });
         const proximos = [];
+        const arquivos = [];
         for (const entrada of entradas.sort((a, b) => a.name.localeCompare(b.name, "pt-BR"))) {
             if (entrada.isSymbolicLink()) {
                 continue;
@@ -374,205 +326,111 @@ class CatalogoDriftImplementacao {
                 if (!diretoriosIgnorados.has(entrada.name.toLowerCase())) {
                     proximos.push(caminhoAtual);
                 }
-                continue;
             }
-            if (entrada.isFile()) {
-                this.adicionarArquivo(caminhoAtual, false);
+            else if (entrada.isFile()) {
+                arquivos.push(caminhoAtual);
             }
         }
+        const sondagens = await mapearComLimite(arquivos, this.concorrencia, async (arquivo) => this.sondarArquivoSeguro(arquivo));
+        for (const sondagem of sondagens
+            .filter((item) => Boolean(item))
+            .sort((a, b) => a.caminho.localeCompare(b.caminho, "pt-BR"))) {
+            this.adicionarArquivo(sondagem, false);
+        }
         return proximos;
     }
-    adicionarArquivo(caminho, explicito, emitirVisita = true) {
-        const absoluto = path.resolve(caminho);
+    adicionarArquivo(sondagem, explicito) {
+        const absoluto = path.resolve(sondagem.caminho);
         const extensao = path.extname(absoluto).toLowerCase();
-        if (this.extensoesPermitidas && !this.extensoesPermitidas.has(extensao)) {
+        if (!explicito && this.extensoesPermitidas && !this.extensoesPermitidas.has(extensao)) {
             return;
         }
         const chave = chaveCaminho(absoluto);
-        const existente = this.registros.get(chave);
+        const chavesFisicas = chavesFisicasArquivo(sondagem.identidade);
+        const existentePorCaminho = this.registros.get(chave);
+        if (existentePorCaminho && !mesmoObjetoFisico(existentePorCaminho.identidade, sondagem.identidade)) {
+            throw new Error(`Arquivo catalogado mudou de identidade fisica: ${absoluto}`);
+        }
+        const existente = existentePorCaminho
+            ?? chavesFisicas.map((chaveFisica) => this.registrosFisicos.get(chaveFisica)).find(Boolean);
         const raizes = this.raizes.filter((raiz) => caminhoEstaDentro(raiz, absoluto));
         if (existente) {
             existente.explicito = existente.explicito || explicito;
+            existente.aliases.add(absoluto);
+            this.registros.set(chave, existente);
             for (const raiz of raizes) {
                 existente.raizes.add(raiz);
             }
+            for (const chaveFisica of chavesFisicas) {
+                this.registrosFisicos.set(chaveFisica, existente);
+            }
+            if (absoluto.localeCompare(existente.caminho, "pt-BR") < 0) {
+                existente.caminho = absoluto;
+                existente.extensao = extensao;
+                existente.identidade = sondagem.identidade;
+            }
             return;
         }
-        this.registros.set(chave, {
+        const registro = {
             caminho: absoluto,
             extensao,
             explicito,
             raizes: new Set(raizes),
-        });
-        this.contadores.arquivosCatalogados += 1;
-        if (emitirVisita) {
-            emitirEvento(this.observador, {
-                tipo: "catalog.visit",
-                caminho: absoluto,
-                categoria: "arquivo",
-            });
+            aliases: new Set([absoluto]),
+            identidade: sondagem.identidade,
+        };
+        this.registros.set(chave, registro);
+        for (const chaveFisica of chavesFisicas) {
+            this.registrosFisicos.set(chaveFisica, registro);
         }
+        this.contadores.arquivosCatalogados += 1;
+        emitirEvento(this.observador, {
+            tipo: "catalog.visit",
+            caminho: absoluto,
+            categoria: "arquivo",
+        });
     }
-    async restaurarSnapshot(snapshot, diretoriosIgnorados, arquivosExplicitos) {
-        if (!registroObjeto(snapshot)
-            || snapshot.schema !== SCHEMA_SNAPSHOT_CATALOGO_DRIFT
-            || !Array.isArray(snapshot.raizes)
-            || !snapshot.raizes.every(diretorioRelativoSeguro)
-            || !Array.isArray(snapshot.diretoriosIgnorados)
-            || !snapshot.diretoriosIgnorados.every((item) => typeof item === "string")
-            || !(snapshot.extensoes === null
-                || (Array.isArray(snapshot.extensoes) && snapshot.extensoes.every((item) => typeof item === "string")))
-            || !Array.isArray(snapshot.diretorios)
-            || !Array.isArray(snapshot.arquivos)) {
-            return false;
-        }
-        const raizesAtuais = this.raizes.map((raiz) => this.relativoSeguro(raiz, true));
-        const ignoradosAtuais = [...diretoriosIgnorados].sort((a, b) => a.localeCompare(b, "en"));
-        if (JSON.stringify(snapshot.raizes) !== JSON.stringify(raizesAtuais)
-            || JSON.stringify(snapshot.extensoes) !== JSON.stringify(this.extensoesSnapshot)
-            || JSON.stringify(snapshot.diretoriosIgnorados) !== JSON.stringify(ignoradosAtuais)) {
-            return false;
+    async sondarArquivoSeguro(caminho) {
+        const absoluto = path.resolve(caminho);
+        if (!caminhoEstaDentro(this.baseDiretorio, absoluto)) {
+            return undefined;
         }
-        const diretorios = snapshot.diretorios.map((entrada) => {
-            if (!registroObjeto(entrada)
-                || !diretorioRelativoSeguro(entrada.caminho)
-                || !assinaturaDiretorioValida(entrada.assinatura)) {
+        try {
+            const informacaoAntes = await lstat(absoluto, { bigint: true });
+            if (!informacaoAntes.isFile() || informacaoAntes.isSymbolicLink() || informacaoAntes.nlink !== 1n) {
                 return undefined;
             }
-            return {
-                caminho: path.resolve(this.baseDiretorio, entrada.caminho),
-                assinatura: entrada.assinatura,
-            };
-        });
-        if (diretorios.some((entrada) => !entrada)) {
-            return false;
-        }
-        if (diretorios.some((entrada) => entrada
-            && !this.caminhoPertenceRaizCatalogavel(entrada.caminho, diretoriosIgnorados, true))) {
-            return false;
-        }
-        const estadosDiretorios = await mapearComLimite(diretorios, this.concorrencia, async (entrada) => {
-            if (!await this.caminhoPermaneceNoWorkspace(entrada.caminho)) {
-                return false;
-            }
-            try {
-                const info = await lstat(entrada.caminho, { bigint: true });
-                this.contadores.diretoriosValidadosCache += 1;
-                return info.isDirectory()
-                    && !info.isSymbolicLink()
-                    && assinaturasDiretorioIguais(entrada.assinatura, assinaturaDiretorio(info));
-            }
-            catch {
-                return false;
-            }
-        });
-        if (estadosDiretorios.some((valido) => !valido)) {
-            this.contadores.diretoriosValidadosCache = 0;
-            return false;
-        }
-        const arquivos = snapshot.arquivos.map((entrada) => {
-            if (!registroObjeto(entrada)
-                || !caminhoRelativoSeguro(entrada.caminho)
-                || typeof entrada.explicito !== "boolean") {
+            const [baseReal, caminhoReal] = await Promise.all([
+                this.baseDiretorioReal,
+                realpath(absoluto),
+            ]);
+            const informacaoDepois = await lstat(absoluto, { bigint: true });
+            if (!caminhoEstaDentro(baseReal, caminhoReal)
+                || !identidadeArquivoEstavel(informacaoAntes, informacaoDepois)) {
                 return undefined;
             }
             return {
-                caminho: path.resolve(this.baseDiretorio, entrada.caminho),
-                explicito: entrada.explicito,
+                caminho: absoluto,
+                identidade: criarIdentidadeArquivoCatalogado(caminhoReal, informacaoDepois),
             };
-        });
-        if (arquivos.some((entrada) => !entrada)) {
-            return false;
-        }
-        const arquivosTipados = arquivos;
-        const explicitosPermitidos = new Set(arquivosExplicitos.map((arquivo) => chaveCaminho(path.resolve(this.baseDiretorio, arquivo))));
-        if (arquivosTipados.some((entrada) => entrada.explicito
-            ? !explicitosPermitidos.has(chaveCaminho(entrada.caminho))
-            : !this.caminhoPertenceRaizCatalogavel(entrada.caminho, diretoriosIgnorados))) {
-            return false;
-        }
-        const caminhosRepresentados = new Set([
-            ...diretorios
-                .filter((entrada) => Boolean(entrada))
-                .map((entrada) => chaveCaminho(entrada.caminho)),
-            ...arquivosTipados.map((entrada) => chaveCaminho(entrada.caminho)),
-        ]);
-        if (this.raizes.some((raiz) => !caminhosRepresentados.has(chaveCaminho(raiz)))) {
-            // Uma raiz ausente nao pode produzir um snapshot eterno: a criacao
-            // posterior dessa raiz precisa forcar uma nova caminhada.
-            return false;
-        }
-        const estadosArquivos = await mapearComLimite(arquivosTipados, this.concorrencia, async (entrada) => {
-            if (!caminhoEstaDentro(this.baseDiretorio, entrada.caminho)
-                || !await this.caminhoPermaneceNoWorkspace(entrada.caminho)) {
-                return false;
-            }
-            try {
-                const info = await lstat(entrada.caminho);
-                return info.isFile()
-                    && !info.isSymbolicLink()
-                    && (!this.extensoesPermitidas
-                        || this.extensoesPermitidas.has(path.extname(entrada.caminho).toLowerCase()));
-            }
-            catch {
-                return false;
-            }
-        });
-        if (estadosArquivos.some((valido) => !valido)) {
-            return false;
         }
-        const diretoriosTipados = diretorios;
-        const diretoriosAindaEstaveis = await mapearComLimite(diretoriosTipados, this.concorrencia, async (entrada) => {
-            try {
-                const info = await lstat(entrada.caminho, { bigint: true });
-                return info.isDirectory()
-                    && !info.isSymbolicLink()
-                    && assinaturasDiretorioIguais(entrada.assinatura, assinaturaDiretorio(info));
-            }
-            catch {
-                return false;
+        catch (erro) {
+            if (erroEhAusencia(erro)) {
+                return undefined;
             }
-        });
-        if (diretoriosAindaEstaveis.some((valido) => !valido)) {
-            return false;
-        }
-        for (const entrada of arquivosTipados) {
-            this.adicionarArquivo(entrada.caminho, entrada.explicito, false);
-        }
-        for (const entrada of diretoriosTipados) {
-            this.diretoriosVisitados.set(entrada.caminho, { ...entrada.assinatura });
-        }
-        this.contadores.origem = "snapshot";
-        return true;
-    }
-    relativoSeguro(caminho, permitirBase = false) {
-        const relativo = path.relative(this.baseDiretorio, path.resolve(caminho)).replace(/\\/g, "/");
-        if (!(permitirBase ? diretorioRelativoSeguro(relativo || ".") : caminhoRelativoSeguro(relativo))) {
-            throw new Error(`caminho_snapshot_catalogo_invalido:${caminho}`);
+            throw erro;
         }
-        return relativo || ".";
     }
-    caminhoPertenceRaizCatalogavel(caminho, diretoriosIgnorados, incluirUltimoSegmento = false) {
-        return this.raizes.some((raiz) => {
-            if (!caminhoEstaDentro(raiz, caminho)) {
-                return false;
-            }
-            const segmentos = path.relative(raiz, caminho)
-                .split(path.sep)
-                .filter(Boolean);
-            if (!incluirUltimoSegmento) {
-                segmentos.pop();
-            }
-            return segmentos.every((segmento) => !diretoriosIgnorados.has(segmento.toLowerCase()));
-        });
-    }
-    async lerFisicamente(caminho) {
-        if (!await this.caminhoPermaneceNoWorkspace(caminho)) {
-            throw new Error(`Arquivo catalogado saiu do workspace real: ${caminho}`);
-        }
+    async lerFisicamente(registro) {
+        const caminho = registro.caminho;
         const informacaoAntes = await lstat(caminho, { bigint: true });
-        if (!informacaoAntes.isFile() || informacaoAntes.isSymbolicLink()) {
-            throw new Error(`Arquivo catalogado deixou de ser arquivo regular: ${caminho}`);
+        const [baseReal, caminhoRealAntes] = await Promise.all([
+            this.baseDiretorioReal,
+            realpath(caminho),
+        ]);
+        if (!caminhoEstaDentro(baseReal, caminhoRealAntes)
+            || !identidadeCatalogadaCorresponde(registro.identidade, caminhoRealAntes, informacaoAntes)) {
+            throw new Error(`Arquivo catalogado mudou entre catalogacao e primeira leitura: ${caminho}`);
         }
         const handle = await open(caminho, "r");
         let bytes;
@@ -587,8 +445,8 @@ class CatalogoDriftImplementacao {
                 lstat(caminho, { bigint: true }),
                 realpath(caminho),
             ]);
-            const baseReal = await this.baseDiretorioReal;
             if (!caminhoEstaDentro(baseReal, caminhoRealAberto)
+                || !identidadeCatalogadaCorresponde(registro.identidade, caminhoRealAberto, informacaoCaminhoAberto)
                 || !identidadeArquivoEstavel(informacaoAntes, informacaoHandleAntes)
                 || !identidadeArquivoEstavel(informacaoHandleAntes, informacaoCaminhoAberto)) {
                 throw new Error(`Arquivo catalogado mudou durante abertura segura: ${caminho}`);
@@ -600,6 +458,7 @@ class CatalogoDriftImplementacao {
                 realpath(caminho),
             ]);
             if (!caminhoEstaDentro(baseReal, caminhoRealDepois)
+                || !identidadeCatalogadaCorresponde(registro.identidade, caminhoRealDepois, informacaoCaminhoDepois)
                 || !identidadeArquivoEstavel(informacaoHandleAntes, informacaoHandleDepois)
                 || !identidadeArquivoEstavel(informacaoHandleDepois, informacaoCaminhoDepois)) {
                 throw new Error(`Arquivo catalogado mudou durante leitura segura: ${caminho}`);
@@ -651,7 +510,7 @@ export async function criarCatalogoDrift(opcoes) {
         .map((diretorio) => diretorio.trim().toLowerCase())
         .filter(Boolean));
     const catalogo = new CatalogoDriftImplementacao(opcoes);
-    await catalogo.construir(opcoes.arquivos ?? [], ignorados, opcoes.snapshot);
+    await catalogo.construir(opcoes.arquivos ?? [], ignorados);
     return catalogo;
 }
 //# sourceMappingURL=driftCatalogo.js.map

package/dist/driftEscopo.d.ts

@@ -1,7 +1,6 @@
 import type { ContextoProjetoCarregado } from "./projeto.js";
 import type { ConfiguracaoEscopoDriftAplicada, EscopoDriftReal } from "./drift.part01.js";
 import type { CatalogoDrift } from "./driftCatalogo.js";
-import type { CacheIncrementalDrift } from "./driftCacheIncremental.js";
 export { extrairReferenciasLocaisDrift } from "./driftEscopoReferencias.js";
 export type EstrategiaEscopoDrift = "arquivos_vinculados" | "projeto";
 export type CoberturaEscopoDrift = "completa" | "parcial";
@@ -19,5 +18,4 @@ export interface PlanoEscopoDrift {
     dependencias: Record<string, string[]>;
 }
 export declare function planejarEscopoDrift(contexto: ContextoProjetoCarregado, configuracao: ConfiguracaoEscopoDriftAplicada): Promise<PlanoEscopoDrift>;
-export declare function expandirDependenciasPlanoDrift(contexto: ContextoProjetoCarregado, plano: PlanoEscopoDrift, catalogo: CatalogoDrift, cache?: CacheIncrementalDrift): Promise<PlanoEscopoDrift>;
-export declare function mapearDependenciasCatalogadasDrift(contexto: ContextoProjetoCarregado, catalogo: CatalogoDrift, cache: CacheIncrementalDrift, arquivos?: readonly string[]): Promise<Record<string, string[]>>;
+export declare function expandirDependenciasPlanoDrift(contexto: ContextoProjetoCarregado, plano: PlanoEscopoDrift, catalogo: CatalogoDrift): Promise<PlanoEscopoDrift>;