@semacode/cli 2.3.1 → 3.5.0

package/dist/driftCacheIncremental.js

@@ -1,596 +0,0 @@
-// SEMA-GOVERNED: sema.produto.governanca_ia.drift
-// Descricao: cache persistente incremental por arquivo e por grupo semantico, com validacao runtime e fast path por metadados.
-import { createHash } from "node:crypto";
-import { lstat, readFile, realpath } from "node:fs/promises";
-import path from "node:path";
-import { digestJsonCanonicoCacheDrift, serializarJsonCanonicoCacheDrift, } from "./driftCache.js";
-import { escreverArquivoWorkspaceSeguro, validarDestinosEscritaWorkspace, } from "./workspaceWrite.js";
-export const FILE_INDEX_SCHEMA = 2;
-export const SCHEMA_MANIFESTO_ARQUIVOS_DRIFT = "sema.drift-file-cache/v2";
-export const SCHEMA_GRUPO_INDICE_DRIFT = "sema.drift-index-group-cache/v2";
-export const DIRETORIO_CACHE_INCREMENTAL_DRIFT = path.join(".tmp", "sema-cache", "drift-index", "v2");
-export const DIRETORIO_IDENTIDADES_CACHE_INCREMENTAL_DRIFT = path.join(DIRETORIO_CACHE_INCREMENTAL_DRIFT, "identities");
-const LIMITE_BYTES_CACHE = 64 * 1024 * 1024;
-const PADRAO_DIGEST = /^sha256:[a-f0-9]{64}$/u;
-function sufixoSeguroIdentidade(identidadeDigest) {
-    if (!PADRAO_DIGEST.test(identidadeDigest)) {
-        throw new TypeError(`identidade_digest_cache_drift_invalida:${identidadeDigest}`);
-    }
-    return identidadeDigest.slice("sha256:".length);
-}
-export function caminhoManifestoArquivosDrift(identidadeDigest) {
-    return path.join(DIRETORIO_IDENTIDADES_CACHE_INCREMENTAL_DRIFT, sufixoSeguroIdentidade(identidadeDigest), "files.json");
-}
-export function caminhoManifestoGruposDrift(identidadeDigest) {
-    return path.join(DIRETORIO_IDENTIDADES_CACHE_INCREMENTAL_DRIFT, sufixoSeguroIdentidade(identidadeDigest), "groups.json");
-}
-function registroObjeto(valor) {
-    return typeof valor === "object" && valor !== null && !Array.isArray(valor);
-}
-function emitirEvento(observador, evento) {
-    try {
-        observador?.(evento);
-    }
-    catch {
-        // Observabilidade nao altera o resultado funcional do drift.
-    }
-}
-function paraJson(valor) {
-    return JSON.parse(JSON.stringify(valor));
-}
-function assinaturasIguais(a, b) {
-    return a.size === b.size
-        && a.mtimeNs === b.mtimeNs
-        && a.ctimeNs === b.ctimeNs
-        && a.dev === b.dev
-        && a.ino === b.ino;
-}
-function assinaturaValida(valor) {
-    if (!registroObjeto(valor)) {
-        return false;
-    }
-    return ["size", "mtimeNs", "ctimeNs", "dev", "ino"]
-        .every((campo) => typeof valor[campo] === "string" && /^\d+$/u.test(valor[campo]));
-}
-function caminhoRelativoSeguro(baseProjeto, arquivo) {
-    const relativo = path.relative(baseProjeto, path.resolve(arquivo)).replace(/\\/g, "/");
-    if (!relativo || relativo === "." || relativo === ".." || relativo.startsWith("../") || path.isAbsolute(relativo)) {
-        throw new Error(`arquivo_cache_drift_fora_workspace:${arquivo}`);
-    }
-    return relativo;
-}
-function caminhoRelativoValido(caminho) {
-    return typeof caminho === "string"
-        && caminho.length > 0
-        && caminho !== "."
-        && caminho !== ".."
-        && !caminho.startsWith("../")
-        && !caminho.includes("\\")
-        && !path.posix.isAbsolute(caminho);
-}
-function chaveEstavel(valor) {
-    return createHash("sha256")
-        .update(serializarJsonCanonicoCacheDrift(valor))
-        .digest("hex");
-}
-function analiseValida(valor) {
-    return registroObjeto(valor)
-        && typeof valor.payloadDigest === "string"
-        && PADRAO_DIGEST.test(valor.payloadDigest)
-        && digestJsonCanonicoCacheDrift(valor.payload) === valor.payloadDigest;
-}
-function entradaArquivoValida(chave, valor) {
-    if (!registroObjeto(valor)
-        || valor.caminho !== chave
-        || !caminhoRelativoValido(valor.caminho)
-        || !assinaturaValida(valor.assinatura)
-        || typeof valor.contentHash !== "string"
-        || !PADRAO_DIGEST.test(valor.contentHash)
-        || !registroObjeto(valor.analises)) {
-        return false;
-    }
-    return Object.values(valor.analises).every(analiseValida);
-}
-function manifestoValido(valor, identidadeDigest) {
-    if (!registroObjeto(valor)
-        || valor.identidadeDigest !== identidadeDigest
-        || !registroObjeto(valor.arquivos)) {
-        return false;
-    }
-    return Object.entries(valor.arquivos).every(([chave, entrada]) => entradaArquivoValida(chave, entrada));
-}
-function membrosGrupoValidos(valor) {
-    return Array.isArray(valor)
-        && valor.every((item) => registroObjeto(item)
-            && caminhoRelativoValido(item.caminho)
-            && typeof item.contentHash === "string"
-            && PADRAO_DIGEST.test(item.contentHash));
-}
-function membrosIguais(a, b) {
-    return a.length === b.length
-        && a.every((item, indice) => (item.caminho === b[indice]?.caminho
-            && item.contentHash === b[indice]?.contentHash));
-}
-function entradaGrupoValida(valor, identidadeDigest) {
-    return registroObjeto(valor)
-        && valor.identidadeDigest === identidadeDigest
-        && membrosGrupoValidos(valor.membros)
-        && typeof valor.resumoDigest === "string"
-        && PADRAO_DIGEST.test(valor.resumoDigest)
-        && digestJsonCanonicoCacheDrift(valor.resumo) === valor.resumoDigest;
-}
-function manifestoGruposValido(valor, identidadeDigest) {
-    return registroObjeto(valor)
-        && valor.identidadeDigest === identidadeDigest
-        && registroObjeto(valor.grupos)
-        && Object.entries(valor.grupos).every(([chave, entrada]) => (/^[a-f0-9]{64}$/u.test(chave)
-            && entradaGrupoValida(entrada, identidadeDigest)));
-}
-function erroEhAusencia(erro) {
-    return ["ENOENT", "ENOTDIR"].includes(erro.code ?? "");
-}
-async function lerEnvelope(baseProjeto, caminhoRelativo, schema, key) {
-    try {
-        const [destino] = await validarDestinosEscritaWorkspace(baseProjeto, [caminhoRelativo]);
-        if (!destino.existe) {
-            return { estado: "miss", motivo: "arquivo_ausente" };
-        }
-        const info = await lstat(destino.caminhoAbsoluto);
-        if (!info.isFile() || info.isSymbolicLink() || info.size > LIMITE_BYTES_CACHE) {
-            return { estado: "corrupt", motivo: "arquivo_cache_invalido" };
-        }
-        const bytes = await readFile(destino.caminhoAbsoluto);
-        if (bytes.byteLength > LIMITE_BYTES_CACHE) {
-            return { estado: "corrupt", motivo: "limite_bytes_excedido" };
-        }
-        let bruto;
-        try {
-            bruto = JSON.parse(bytes.toString("utf8"));
-        }
-        catch {
-            return { estado: "corrupt", motivo: "json_invalido" };
-        }
-        if (!registroObjeto(bruto)
-            || bruto.schema !== schema
-            || bruto.key !== key
-            || typeof bruto.payloadDigest !== "string"
-            || !PADRAO_DIGEST.test(bruto.payloadDigest)) {
-            return { estado: "corrupt", motivo: "envelope_invalido" };
-        }
-        let digest;
-        try {
-            digest = digestJsonCanonicoCacheDrift(bruto.payload);
-        }
-        catch {
-            return { estado: "corrupt", motivo: "payload_nao_canonico" };
-        }
-        if (digest !== bruto.payloadDigest) {
-            return { estado: "corrupt", motivo: "payload_digest_divergente" };
-        }
-        return { estado: "hit", payload: bruto.payload };
-    }
-    catch (erro) {
-        return {
-            estado: "miss",
-            motivo: erroEhAusencia(erro) ? "arquivo_ausente" : "cache_indisponivel",
-        };
-    }
-}
-async function escreverEnvelope(baseProjeto, caminhoRelativo, schema, key, payload) {
-    const envelope = {
-        schema,
-        key,
-        payload,
-        payloadDigest: digestJsonCanonicoCacheDrift(payload),
-    };
-    const conteudo = JSON.stringify(envelope);
-    if (Buffer.byteLength(conteudo, "utf8") > LIMITE_BYTES_CACHE) {
-        throw new Error("limite_bytes_cache_incremental_excedido");
-    }
-    await escreverArquivoWorkspaceSeguro(baseProjeto, caminhoRelativo, conteudo, { sobrescrever: true });
-}
-export async function obterAssinaturaArquivoDrift(arquivo) {
-    const info = await lstat(arquivo, { bigint: true });
-    if (!info.isFile() || info.isSymbolicLink()) {
-        throw new Error(`arquivo_cache_drift_nao_regular:${arquivo}`);
-    }
-    return {
-        size: info.size.toString(),
-        mtimeNs: info.mtimeNs.toString(),
-        ctimeNs: info.ctimeNs.toString(),
-        dev: info.dev.toString(),
-        ino: info.ino.toString(),
-    };
-}
-export class CacheIncrementalDrift {
-    identidadeDigest;
-    politica;
-    baseProjeto;
-    baseProjetoReal;
-    observador;
-    caminhoManifestoArquivos;
-    caminhoManifestoGrupos;
-    manifesto;
-    manifestoEmVoo;
-    manifestoSujo = false;
-    arquivosSujos = new Set();
-    manifestoGrupos;
-    manifestoGruposEmVoo;
-    manifestoGruposSujo = false;
-    gruposSujos = new Set();
-    arquivosEmVoo = new Map();
-    metricasAtuais = {
-        metadataHits: 0,
-        contentHits: 0,
-        fileMisses: 0,
-        groupHits: 0,
-        groupMisses: 0,
-        corruptos: 0,
-        extracoesArquivo: 0,
-        extracoesGrupo: 0,
-        gravacoes: 0,
-        errosGravacao: 0,
-    };
-    constructor(opcoes) {
-        this.baseProjeto = path.resolve(opcoes.baseProjeto);
-        this.baseProjetoReal = realpath(this.baseProjeto);
-        this.politica = opcoes.politica;
-        this.identidadeDigest = digestJsonCanonicoCacheDrift(opcoes.identidade);
-        this.caminhoManifestoArquivos = caminhoManifestoArquivosDrift(this.identidadeDigest);
-        this.caminhoManifestoGrupos = caminhoManifestoGruposDrift(this.identidadeDigest);
-        this.observador = opcoes.observador;
-    }
-    metricas() {
-        return { ...this.metricasAtuais };
-    }
-    async resolverArquivo(opcoes) {
-        const chaveExecucao = `${process.platform === "win32" ? path.resolve(opcoes.arquivo).toLowerCase() : path.resolve(opcoes.arquivo)}\0${opcoes.analise}`;
-        const existenteEmVoo = this.arquivosEmVoo.get(chaveExecucao);
-        if (existenteEmVoo) {
-            return existenteEmVoo;
-        }
-        const execucao = this.resolverArquivoInterno(opcoes);
-        this.arquivosEmVoo.set(chaveExecucao, execucao);
-        void execucao.catch(() => {
-            if (this.arquivosEmVoo.get(chaveExecucao) === execucao) {
-                this.arquivosEmVoo.delete(chaveExecucao);
-            }
-        });
-        return execucao;
-    }
-    async resolverArquivoInterno(opcoes) {
-        await this.validarArquivoNoWorkspace(opcoes.arquivo);
-        const caminho = caminhoRelativoSeguro(this.baseProjeto, opcoes.arquivo);
-        const assinar = opcoes.assinar ?? (() => obterAssinaturaArquivoDrift(opcoes.arquivo));
-        const assinaturaAntes = await assinar();
-        const manifesto = await this.obterManifesto();
-        const existente = manifesto.arquivos[caminho];
-        const analiseExistente = existente?.analises[opcoes.analise];
-        const payloadExistente = analiseExistente?.payload;
-        const payloadValido = analiseExistente !== undefined && opcoes.validar(payloadExistente);
-        if (analiseExistente && !payloadValido) {
-            this.registrarCorrupto(opcoes.arquivo, "payload_schema_invalido");
-        }
-        if (this.politica === "auto"
-            && existente
-            && payloadValido
-            && assinaturasIguais(existente.assinatura, assinaturaAntes)) {
-            this.metricasAtuais.metadataHits += 1;
-            emitirEvento(this.observador, {
-                tipo: "cache.hit",
-                caminho: path.resolve(opcoes.arquivo),
-                motivo: "metadata_hit",
-            });
-            return {
-                caminho,
-                contentHash: existente.contentHash,
-                valor: payloadExistente,
-                origem: "metadata_hit",
-            };
-        }
-        this.metricasAtuais.fileMisses += 1;
-        emitirEvento(this.observador, {
-            tipo: "cache.miss",
-            caminho: path.resolve(opcoes.arquivo),
-            motivo: this.politica === "refresh" ? "politica_refresh" : this.politica === "off" ? "politica_off" : "metadata_miss",
-        });
-        const conteudo = await opcoes.ler();
-        if (this.politica === "auto"
-            && existente
-            && payloadValido
-            && existente.contentHash === conteudo.digest) {
-            const assinaturaDepois = await assinar();
-            if (assinaturasIguais(assinaturaAntes, assinaturaDepois)) {
-                existente.assinatura = assinaturaDepois;
-                this.manifestoSujo = true;
-                this.arquivosSujos.add(caminho);
-            }
-            this.metricasAtuais.contentHits += 1;
-            emitirEvento(this.observador, {
-                tipo: "cache.hit",
-                caminho: path.resolve(opcoes.arquivo),
-                motivo: "content_hit",
-            });
-            return {
-                caminho,
-                contentHash: conteudo.digest,
-                valor: payloadExistente,
-                origem: "content_hit",
-            };
-        }
-        this.metricasAtuais.extracoesArquivo += 1;
-        emitirEvento(this.observador, {
-            tipo: "extractor.run",
-            caminho: path.resolve(opcoes.arquivo),
-            motivo: `arquivo:${opcoes.analise}`,
-        });
-        const valor = paraJson(await opcoes.extrair(conteudo));
-        if (!opcoes.validar(valor)) {
-            throw new Error(`extrator_cache_drift_payload_invalido:${opcoes.analise}:${caminho}`);
-        }
-        if (this.politica !== "off") {
-            const assinaturaDepois = await assinar();
-            if (assinaturasIguais(assinaturaAntes, assinaturaDepois)) {
-                const analises = existente?.contentHash === conteudo.digest
-                    ? { ...existente.analises }
-                    : {};
-                analises[opcoes.analise] = {
-                    payload: valor,
-                    payloadDigest: digestJsonCanonicoCacheDrift(valor),
-                };
-                manifesto.arquivos[caminho] = {
-                    caminho,
-                    assinatura: assinaturaDepois,
-                    contentHash: conteudo.digest,
-                    analises,
-                };
-                this.manifestoSujo = true;
-                this.arquivosSujos.add(caminho);
-            }
-        }
-        return {
-            caminho,
-            contentHash: conteudo.digest,
-            valor,
-            origem: "calculado",
-        };
-    }
-    async resolverGrupo(opcoes) {
-        const membros = opcoes.membros
-            .map((membro) => ({
-            caminho: caminhoRelativoSeguro(this.baseProjeto, membro.caminho),
-            contentHash: membro.contentHash,
-        }))
-            .sort((a, b) => a.caminho.localeCompare(b.caminho, "en"));
-        // A chave e ancorada no primeiro arquivo, nao no conteudo nem na composicao
-        // atual do grupo. Mudancas sobrescrevem a mesma entrada e evitam crescimento
-        // infinito do cache; a lista completa de membros continua validada no envelope.
-        const chave = chaveEstavel({ ancora: membros[0]?.caminho ?? "grupo-vazio" });
-        const caminhoRelativo = this.caminhoManifestoGrupos;
-        if (this.politica === "auto") {
-            const manifesto = await this.obterManifestoGrupos();
-            const payload = manifesto.grupos[chave];
-            if (payload) {
-                const identidadeAtual = payload.identidadeDigest === this.identidadeDigest;
-                const membrosAtuais = membrosIguais(payload.membros, membros);
-                if (identidadeAtual && membrosAtuais) {
-                    if (opcoes.validar(payload.resumo)) {
-                        this.metricasAtuais.groupHits += 1;
-                        emitirEvento(this.observador, {
-                            tipo: "cache.hit",
-                            chave,
-                            caminho: path.resolve(this.baseProjeto, caminhoRelativo),
-                            motivo: "group_content_hit",
-                        });
-                        return { chave, valor: payload.resumo, origem: "cache" };
-                    }
-                    this.registrarCorrupto(path.resolve(this.baseProjeto, caminhoRelativo), "payload_schema_invalido");
-                }
-            }
-        }
-        this.metricasAtuais.groupMisses += 1;
-        emitirEvento(this.observador, {
-            tipo: "cache.miss",
-            chave,
-            caminho: path.resolve(this.baseProjeto, caminhoRelativo),
-            motivo: this.politica === "refresh" ? "politica_refresh" : this.politica === "off" ? "politica_off" : "group_miss",
-        });
-        this.metricasAtuais.extracoesGrupo += 1;
-        emitirEvento(this.observador, {
-            tipo: "extractor.run",
-            chave,
-            caminho: opcoes.membros[0]?.caminho,
-            motivo: `grupo:${membros.length}`,
-        });
-        const valor = paraJson(await opcoes.calcular());
-        if (!opcoes.validar(valor)) {
-            throw new Error(`extrator_grupo_cache_drift_payload_invalido:${chave}`);
-        }
-        if (this.politica !== "off") {
-            const payload = {
-                identidadeDigest: this.identidadeDigest,
-                membros,
-                resumo: valor,
-                resumoDigest: digestJsonCanonicoCacheDrift(valor),
-            };
-            const manifesto = await this.obterManifestoGrupos();
-            manifesto.grupos[chave] = payload;
-            this.manifestoGruposSujo = true;
-            this.gruposSujos.add(chave);
-        }
-        return { chave, valor, origem: "calculado" };
-    }
-    async finalizar() {
-        if (this.politica === "off") {
-            return;
-        }
-        if (this.manifestoSujo && this.manifesto) {
-            try {
-                this.manifesto = await this.gravarManifestoArquivosComMerge(this.manifesto);
-                this.metricasAtuais.gravacoes += 1;
-                this.manifestoSujo = false;
-                this.arquivosSujos.clear();
-            }
-            catch {
-                this.metricasAtuais.errosGravacao += 1;
-            }
-        }
-        if (this.manifestoGruposSujo && this.manifestoGrupos) {
-            try {
-                this.manifestoGrupos = await this.gravarManifestoGruposComMerge(this.manifestoGrupos);
-                this.metricasAtuais.gravacoes += 1;
-                this.manifestoGruposSujo = false;
-                this.gruposSujos.clear();
-            }
-            catch {
-                this.metricasAtuais.errosGravacao += 1;
-            }
-        }
-    }
-    chaveEnvelope(tipo) {
-        return `${tipo}:${this.identidadeDigest}`;
-    }
-    async lerManifestoArquivosAtual() {
-        const leitura = await lerEnvelope(this.baseProjeto, this.caminhoManifestoArquivos, SCHEMA_MANIFESTO_ARQUIVOS_DRIFT, this.chaveEnvelope("files"));
-        return leitura.estado === "hit" && manifestoValido(leitura.payload, this.identidadeDigest)
-            ? leitura.payload
-            : undefined;
-    }
-    async lerManifestoGruposAtual() {
-        const leitura = await lerEnvelope(this.baseProjeto, this.caminhoManifestoGrupos, SCHEMA_GRUPO_INDICE_DRIFT, this.chaveEnvelope("groups"));
-        return leitura.estado === "hit" && manifestoGruposValido(leitura.payload, this.identidadeDigest)
-            ? leitura.payload
-            : undefined;
-    }
-    async gravarManifestoArquivosComMerge(local) {
-        let ultimoErro;
-        for (let tentativa = 0; tentativa < 2; tentativa += 1) {
-            const publicado = await this.lerManifestoArquivosAtual();
-            const mesclado = {
-                identidadeDigest: this.identidadeDigest,
-                arquivos: publicado ? { ...publicado.arquivos } : {},
-            };
-            for (const caminho of this.arquivosSujos) {
-                const entrada = local.arquivos[caminho];
-                if (entrada) {
-                    mesclado.arquivos[caminho] = entrada;
-                }
-            }
-            try {
-                await escreverEnvelope(this.baseProjeto, this.caminhoManifestoArquivos, SCHEMA_MANIFESTO_ARQUIVOS_DRIFT, this.chaveEnvelope("files"), mesclado);
-                return mesclado;
-            }
-            catch (erro) {
-                ultimoErro = erro;
-            }
-        }
-        throw ultimoErro;
-    }
-    async gravarManifestoGruposComMerge(local) {
-        let ultimoErro;
-        for (let tentativa = 0; tentativa < 2; tentativa += 1) {
-            const publicado = await this.lerManifestoGruposAtual();
-            const mesclado = {
-                identidadeDigest: this.identidadeDigest,
-                grupos: publicado ? { ...publicado.grupos } : {},
-            };
-            for (const chave of this.gruposSujos) {
-                const entrada = local.grupos[chave];
-                if (entrada) {
-                    mesclado.grupos[chave] = entrada;
-                }
-            }
-            try {
-                await escreverEnvelope(this.baseProjeto, this.caminhoManifestoGrupos, SCHEMA_GRUPO_INDICE_DRIFT, this.chaveEnvelope("groups"), mesclado);
-                return mesclado;
-            }
-            catch (erro) {
-                ultimoErro = erro;
-            }
-        }
-        throw ultimoErro;
-    }
-    async obterManifesto() {
-        if (this.manifesto) {
-            return this.manifesto;
-        }
-        if (this.manifestoEmVoo) {
-            return this.manifestoEmVoo;
-        }
-        this.manifestoEmVoo = this.carregarManifesto();
-        try {
-            return await this.manifestoEmVoo;
-        }
-        finally {
-            this.manifestoEmVoo = undefined;
-        }
-    }
-    async carregarManifesto() {
-        if (this.politica === "auto") {
-            const leitura = await lerEnvelope(this.baseProjeto, this.caminhoManifestoArquivos, SCHEMA_MANIFESTO_ARQUIVOS_DRIFT, this.chaveEnvelope("files"));
-            if (leitura.estado === "hit" && manifestoValido(leitura.payload, this.identidadeDigest)) {
-                this.manifesto = leitura.payload;
-                return this.manifesto;
-            }
-            if (leitura.estado === "corrupt" || leitura.estado === "hit") {
-                this.registrarCorrupto(path.resolve(this.baseProjeto, this.caminhoManifestoArquivos), leitura.estado === "hit" ? "payload_schema_invalido" : leitura.motivo);
-            }
-        }
-        this.manifesto = {
-            identidadeDigest: this.identidadeDigest,
-            arquivos: {},
-        };
-        return this.manifesto;
-    }
-    async obterManifestoGrupos() {
-        if (this.manifestoGrupos) {
-            return this.manifestoGrupos;
-        }
-        if (this.manifestoGruposEmVoo) {
-            return this.manifestoGruposEmVoo;
-        }
-        this.manifestoGruposEmVoo = this.carregarManifestoGrupos();
-        try {
-            return await this.manifestoGruposEmVoo;
-        }
-        finally {
-            this.manifestoGruposEmVoo = undefined;
-        }
-    }
-    async carregarManifestoGrupos() {
-        if (this.politica === "auto") {
-            const leitura = await lerEnvelope(this.baseProjeto, this.caminhoManifestoGrupos, SCHEMA_GRUPO_INDICE_DRIFT, this.chaveEnvelope("groups"));
-            if (leitura.estado === "hit" && manifestoGruposValido(leitura.payload, this.identidadeDigest)) {
-                this.manifestoGrupos = leitura.payload;
-                return this.manifestoGrupos;
-            }
-            if (leitura.estado === "corrupt" || leitura.estado === "hit") {
-                this.registrarCorrupto(path.resolve(this.baseProjeto, this.caminhoManifestoGrupos), leitura.estado === "hit" ? "payload_schema_invalido" : leitura.motivo);
-            }
-        }
-        this.manifestoGrupos = {
-            identidadeDigest: this.identidadeDigest,
-            grupos: {},
-        };
-        return this.manifestoGrupos;
-    }
-    registrarCorrupto(caminho, motivo) {
-        this.metricasAtuais.corruptos += 1;
-        emitirEvento(this.observador, {
-            tipo: "cache.corrupt",
-            caminho,
-            motivo,
-        });
-    }
-    async validarArquivoNoWorkspace(arquivo) {
-        const [baseReal, arquivoReal] = await Promise.all([
-            this.baseProjetoReal,
-            realpath(arquivo),
-        ]);
-        const relativo = path.relative(baseReal, arquivoReal);
-        if (relativo === ".." || relativo.startsWith(`..${path.sep}`) || path.isAbsolute(relativo)) {
-            throw new Error(`arquivo_cache_drift_fora_workspace_real:${arquivo}`);
-        }
-    }
-}
-//# sourceMappingURL=driftCacheIncremental.js.map

package/dist/driftCatalogoPersistente.d.ts

@@ -1,8 +0,0 @@
-import { type PoliticaCacheDrift, type ValorJson } from "./driftCache.js";
-import { type CatalogoDrift, type OpcoesCatalogoDrift } from "./driftCatalogo.js";
-export declare const SCHEMA_CACHE_CATALOGO_DRIFT: "sema.drift-catalog-cache/v1";
-export interface OpcoesCatalogoPersistenteDrift {
-    politica: PoliticaCacheDrift;
-    identidade: ValorJson;
-}
-export declare function criarCatalogoPersistenteDrift(opcoes: OpcoesCatalogoDrift, opcoesCache: OpcoesCatalogoPersistenteDrift): Promise<CatalogoDrift>;

package/dist/driftCatalogoPersistente.js

@@ -1,77 +0,0 @@
-// SEMA-GOVERNED: sema.produto.governanca_ia.drift
-// Descricao: reutiliza um snapshot validado do catalogo global sem transformar escopo estreito em varredura ampla.
-import path from "node:path";
-import { criarCacheDrift, digestJsonCanonicoCacheDrift, } from "./driftCache.js";
-import { criarCatalogoDrift, } from "./driftCatalogo.js";
-export const SCHEMA_CACHE_CATALOGO_DRIFT = "sema.drift-catalog-cache/v1";
-function chaveRelativa(base, alvo) {
-    const relativo = path.relative(base, path.resolve(base, alvo)).replace(/\\/g, "/");
-    return relativo || ".";
-}
-function identidadePlanoCatalogo(opcoes) {
-    const base = path.resolve(opcoes.baseDiretorio ?? process.cwd());
-    const ignorados = [...(opcoes.diretoriosIgnorados ?? [])]
-        .map((item) => item.trim().toLowerCase())
-        .filter(Boolean)
-        .sort((a, b) => a.localeCompare(b, "en"));
-    return {
-        schema: SCHEMA_CACHE_CATALOGO_DRIFT,
-        arquivos: [...(opcoes.arquivos ?? [])]
-            .map((arquivo) => chaveRelativa(base, arquivo))
-            .sort((a, b) => a.localeCompare(b, "en")),
-        raizes: [...(opcoes.raizes ?? [])]
-            .map((raiz) => chaveRelativa(base, raiz))
-            .sort((a, b) => a.localeCompare(b, "en")),
-        extensoes: opcoes.extensoes
-            ? [...opcoes.extensoes].map((item) => item.toLowerCase()).sort((a, b) => a.localeCompare(b, "en"))
-            : null,
-        diretoriosIgnorados: ignorados,
-    };
-}
-export async function criarCatalogoPersistenteDrift(opcoes, opcoesCache) {
-    const baseProjeto = path.resolve(opcoes.baseDiretorio ?? process.cwd());
-    if (opcoesCache.politica === "off" || (opcoes.raizes?.length ?? 0) === 0) {
-        return criarCatalogoDrift(opcoes);
-    }
-    const plano = identidadePlanoCatalogo(opcoes);
-    const entrada = {
-        fingerprintConteudo: digestJsonCanonicoCacheDrift(plano),
-        identidade: {
-            schema: SCHEMA_CACHE_CATALOGO_DRIFT,
-            executor: opcoesCache.identidade,
-            plano,
-        },
-    };
-    let catalogoCalculado;
-    const cache = criarCacheDrift({
-        baseProjeto,
-        politica: opcoesCache.politica,
-        observador: opcoes.observador,
-    });
-    const resultado = await cache.obterOuCalcular(entrada, async () => {
-        catalogoCalculado = await criarCatalogoDrift(opcoes);
-        return catalogoCalculado.snapshot();
-    });
-    if (catalogoCalculado) {
-        return catalogoCalculado;
-    }
-    const restauradoOuRecalculado = await criarCatalogoDrift({
-        ...opcoes,
-        snapshot: resultado.valor,
-    });
-    if (restauradoOuRecalculado.metricas().origem === "snapshot") {
-        return restauradoOuRecalculado;
-    }
-    // O envelope estava integro, mas o snapshot ficou obsoleto ou falhou na
-    // validacao runtime. A caminhada ja executada acima e reaproveitada; apenas
-    // substituimos atomicamente a entrada persistente.
-    const refresh = criarCacheDrift({
-        baseProjeto,
-        politica: "refresh",
-        observador: opcoes.observador,
-    });
-    const snapshotAtual = restauradoOuRecalculado.snapshot();
-    await refresh.obterOuCalcular(entrada, async () => snapshotAtual);
-    return restauradoOuRecalculado;
-}
-//# sourceMappingURL=driftCatalogoPersistente.js.map