@semacode/cli 2.3.1 → 3.0.0

package/dist/drift.part13.js

@@ -1,242 +1,432 @@
-// SEMA-GOVERNED: sema.produto.governanca_ia.drift
-// Descricao: planeja antes de catalogar e indexa unidades incrementais com uma unica leitura fisica por arquivo.
-import pacoteCli from "../package.json" with { type: "json" };
+// SEMA-GOVERNED: sema.produto.governanca_ia.drift, sema.produto.governanca_ia.drift.cache.store
+// Descrição: planeja o escopo físico, cataloga uma vez e reutiliza extrações validadas sem escrever no workspace.
 import path from "node:path";
-import { performance } from "node:perf_hooks";
 import ts from "typescript";
-import { resolverDiretoriosIgnoradosAtivos } from "./drift.part01.js";
-import { EXTENSOES_ARQUIVOS_RASTREAVEIS_DRIFT, indexarArquivosRastreaveis } from "./drift.part04.js";
+import pacoteCli from "../package.json" with { type: "json" };
+import { resolverDiretoriosIgnoradosAtivos, } from "./drift.part01.js";
+import { EXTENSOES_ARQUIVOS_RASTREAVEIS_DRIFT, chaveCaminhoCanonicoDrift, } from "./drift.part04.js";
 import { indexarTypeScript } from "./drift.part06.js";
 import { indexarCpp, indexarDart, indexarDotnet, indexarGo, indexarJava, indexarLua, indexarPersistenciaDeclarativa, indexarPhp, indexarPython, indexarRust, } from "./drift.part07.js";
 import { indexarPersistenciaDetalhada } from "./drift.part08.js";
-import { construirMapaRecursos } from "./drift.part10.js";
-import { emitirDiagnosticosArquivosOrcamento, workspaceExigeCabecalhoCodigoGovernado, } from "./driftOrcamento.js";
-import { criarCatalogoPersistenteDrift } from "./driftCatalogoPersistente.js";
-import { CacheIncrementalDrift, FILE_INDEX_SCHEMA, } from "./driftCacheIncremental.js";
-import { expandirDependenciasPlanoDrift, extrairReferenciasLocaisDrift, mapearDependenciasCatalogadasDrift, planejarEscopoDrift, } from "./driftEscopo.js";
-const EXTENSOES_ANALISE_DRIFT = new Set([
-    ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
-    ".py", ".dart", ".lua", ".cs", ".java", ".go", ".rs", ".php",
-    ".cpp", ".cc", ".cxx", ".hpp", ".h",
-    ".sql", ".psql", ".ddl", ".prisma",
-]);
-const EXTENSOES_TYPESCRIPT_DRIFT = new Set([
-    ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
-]);
-const EXTENSOES_DEPENDENCIA_TYPESCRIPT_DRIFT = new Set([
-    ...EXTENSOES_TYPESCRIPT_DRIFT,
-    ".html", ".htm", ".css",
-]);
-function chaveCaminho(caminho) {
-    const absoluto = path.normalize(path.resolve(caminho));
-    return process.platform === "win32" ? absoluto.toLowerCase() : absoluto;
-}
-function chaveRelativa(caminho) {
-    const normalizado = caminho.replace(/\\/g, "/");
-    return process.platform === "win32" ? normalizado.toLowerCase() : normalizado;
-}
-function paraJsonCache(valor) {
-    return JSON.parse(JSON.stringify(valor));
-}
-function registroObjeto(valor) {
-    return typeof valor === "object" && valor !== null && !Array.isArray(valor);
-}
-function textoNaoVazio(valor) {
-    return typeof valor === "string" && valor.length > 0;
-}
-function pertenceAoConjunto(valor, conjunto) {
-    return typeof valor === "string" && conjunto.has(valor);
-}
-function inteiroNaoNegativo(valor) {
-    return typeof valor === "number" && Number.isSafeInteger(valor) && valor >= 0;
-}
-const ORIGENS_SIMBOLO_DRIFT = new Set([
-    "ts", "js", "py", "dart", "lua", "cs", "java", "go", "rust", "cpp", "php", "sql",
-]);
-const ORIGENS_ROTA_DRIFT = new Set([
-    "nestjs", "fastapi", "flask", "nextjs", "nextjs-consumer", "react-vite-consumer",
-    "angular-consumer", "flutter-consumer", "firebase", "dotnet", "java", "go", "rust", "php",
-]);
-const ORIGENS_RECURSO_DRIFT = new Set([
-    "firebase", "postgres", "mysql", "sqlite", "mongodb", "redis", "arquivo",
-]);
-const TIPOS_RECURSO_DRIFT = new Set([
-    "colecao", "arquivo_local", "table", "view", "query", "transaction", "index", "constraint",
-    "relationship", "collection", "document", "keyspace", "stream", "lock", "retention", "replication",
-]);
-const CATEGORIAS_PERSISTENCIA_DRIFT = new Set([
-    "relacional", "documental", "chave_valor", "local_arquivo", "desconhecida",
-]);
-const TIPOS_DIAGNOSTICO_ORCAMENTO = new Set([
-    "contrato_monolitico", "codigo_monolitico", "codigo_governado_sem_cabecalho",
-]);
-function simboloResolvidoValido(valor) {
-    return registroObjeto(valor)
-        && pertenceAoConjunto(valor.origem, ORIGENS_SIMBOLO_DRIFT)
-        && textoNaoVazio(valor.caminho)
-        && textoNaoVazio(valor.arquivo)
-        && textoNaoVazio(valor.simbolo);
-}
-function rotaResolvidaValida(valor) {
-    return registroObjeto(valor)
-        && pertenceAoConjunto(valor.origem, ORIGENS_ROTA_DRIFT)
-        && textoNaoVazio(valor.metodo)
-        && textoNaoVazio(valor.caminho)
-        && textoNaoVazio(valor.arquivo)
-        && textoNaoVazio(valor.simbolo);
-}
-function recursoResolvidoValido(valor) {
-    return registroObjeto(valor)
-        && pertenceAoConjunto(valor.origem, ORIGENS_RECURSO_DRIFT)
-        && textoNaoVazio(valor.nome)
-        && textoNaoVazio(valor.arquivo)
-        && (valor.simbolo === undefined || textoNaoVazio(valor.simbolo))
-        && pertenceAoConjunto(valor.tipo, TIPOS_RECURSO_DRIFT);
-}
-function consumerSurfaceValida(valor) {
-    return registroObjeto(valor)
-        && textoNaoVazio(valor.rota)
-        && textoNaoVazio(valor.arquivo)
-        && textoNaoVazio(valor.tipoArquivo);
-}
-function colunaPersistenciaValida(valor) {
-    return registroObjeto(valor)
-        && pertenceAoConjunto(valor.origem, ORIGENS_RECURSO_DRIFT)
-        && pertenceAoConjunto(valor.categoriaPersistencia, CATEGORIAS_PERSISTENCIA_DRIFT)
-        && textoNaoVazio(valor.recurso)
-        && textoNaoVazio(valor.coluna)
-        && textoNaoVazio(valor.arquivo);
-}
-function repositorioPersistenciaValido(valor) {
-    return registroObjeto(valor)
-        && pertenceAoConjunto(valor.origem, ORIGENS_RECURSO_DRIFT)
-        && pertenceAoConjunto(valor.categoriaPersistencia, CATEGORIAS_PERSISTENCIA_DRIFT)
-        && textoNaoVazio(valor.recurso)
-        && textoNaoVazio(valor.arquivo);
-}
-function diagnosticoOrcamentoValido(valor) {
-    return registroObjeto(valor)
-        && pertenceAoConjunto(valor.tipo, TIPOS_DIAGNOSTICO_ORCAMENTO)
-        && textoNaoVazio(valor.arquivo)
-        && inteiroNaoNegativo(valor.linhas)
-        && (valor.severidade === "aviso" || valor.severidade === "erro")
-        && typeof valor.bloqueia === "boolean"
-        && textoNaoVazio(valor.mensagem)
-        && inteiroNaoNegativo(valor.limite_aviso_linhas)
-        && inteiroNaoNegativo(valor.limite_bloqueio_linhas);
-}
-function listaValida(valor, validar) {
-    return Array.isArray(valor) && valor.every(validar);
-}
-function indiceLinguagemValido(valor) {
-    return registroObjeto(valor)
-        && listaValida(valor.simbolos, simboloResolvidoValido)
-        && listaValida(valor.rotas, rotaResolvidaValida)
-        && listaValida(valor.recursos, recursoResolvidoValido)
-        && Array.isArray(valor.consumerSurfaces)
-        && valor.consumerSurfaces.every(consumerSurfaceValida);
-}
-function validarIndicesSerializaveis(valor) {
-    if (!registroObjeto(valor) || !registroObjeto(valor.detalhesPersistencia)) {
-        return false;
-    }
-    const detalhes = valor.detalhesPersistencia;
-    return listaValida(detalhes.colunas, colunaPersistenciaValida)
-        && listaValida(detalhes.repositorios, repositorioPersistenciaValido)
-        && Array.isArray(valor.arquivosOrcamentoAvaliados)
-        && valor.arquivosOrcamentoAvaliados.every(textoNaoVazio)
-        && listaValida(valor.diagnosticosOrcamento, diagnosticoOrcamentoValido)
-        && indiceLinguagemValido(valor.indexDart)
-        && indiceLinguagemValido(valor.indexTs)
-        && listaValida(valor.todasRotasIndexadas, rotaResolvidaValida)
-        && Array.isArray(valor.todosArquivosConhecidos)
-        && valor.todosArquivosConhecidos.every(textoNaoVazio)
-        && listaValida(valor.todosRecursos, recursoResolvidoValido)
-        && listaValida(valor.todosSimbolos, simboloResolvidoValido);
-}
-function indicesPermanecemNoCatalogo(valor, catalogo) {
-    const registros = [
-        ...valor.detalhesPersistencia.colunas,
-        ...valor.detalhesPersistencia.repositorios,
-        ...valor.indexDart.simbolos,
-        ...valor.indexDart.rotas,
-        ...valor.indexDart.recursos,
-        ...valor.indexDart.consumerSurfaces,
-        ...valor.indexTs.simbolos,
-        ...valor.indexTs.rotas,
-        ...valor.indexTs.recursos,
-        ...valor.indexTs.consumerSurfaces,
-        ...valor.todasRotasIndexadas,
-        ...valor.todosRecursos,
-        ...valor.todosSimbolos,
-    ];
-    return registros.every((item) => catalogo.contem(item.arquivo))
-        && valor.todosArquivosConhecidos.every((arquivo) => catalogo.contem(arquivo))
-        && valor.arquivosOrcamentoAvaliados.every((arquivo) => catalogo.contem(path.resolve(catalogo.baseDiretorio, arquivo)))
-        && valor.diagnosticosOrcamento.every((item) => catalogo.contem(path.resolve(catalogo.baseDiretorio, item.arquivo)));
-}
-function reconstruirIndices(serializaveis, planoEscopo, cache, catalogo, leitorArquivosPlanejados) {
-    const mapaImpl = new Map(serializaveis.todosSimbolos
-        .filter((item) => item.origem !== "sql")
-        .map((item) => [item.caminho, item]));
+import { coletarVinculosIr, construirMapaRecursos } from "./drift.part10.js";
+import { criarCatalogoDrift, } from "./driftCatalogo.js";
+import { expandirDependenciasPlanoDrift, planejarEscopoDrift, } from "./driftEscopo.js";
+import { criarStoreCacheDrift, digestJsonCanonicoCacheDrift, } from "./driftCacheStore.js";
+const SCHEMA_PAYLOAD_INDICES_CACHE_DRIFT = "sema.drift-index-payload/v4";
+const SCHEMA_IDENTIDADE_INDICES_CACHE_DRIFT = "sema.drift-index-identity/v3";
+const SCHEMA_ESTADO_CACHE_DRIFT = "sema.drift-cache/v3";
+const EXTRATOR_INDICES_CACHE_DRIFT = "drift-index-v4-2026-08-16";
+const CHAVES_INDICES_CACHE_DRIFT = [
+    "indexTs", "indexPy", "indexDart", "indexDotnet", "indexJava", "indexGo",
+    "indexRust", "indexLua", "indexCpp", "indexPhp", "indexPersistencia",
+];
+const ORIGENS_SIMBOLO_POR_INDICE = {
+    indexTs: ["ts", "js"],
+    indexPy: ["py"],
+    indexDart: ["dart"],
+    indexDotnet: ["cs"],
+    indexJava: ["java"],
+    indexGo: ["go"],
+    indexRust: ["rust"],
+    indexLua: ["lua"],
+    indexCpp: ["cpp"],
+    indexPhp: ["php"],
+    indexPersistencia: ["sql"],
+};
+const EXTENSOES_POR_INDICE = {
+    indexTs: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"],
+    indexPy: [".py"],
+    indexDart: [".dart"],
+    indexDotnet: [".cs"],
+    indexJava: [".java"],
+    indexGo: [".go"],
+    indexRust: [".rs"],
+    indexLua: [".lua"],
+    indexCpp: [".cpp", ".cc", ".cxx", ".hpp", ".h"],
+    indexPhp: [".php"],
+    indexPersistencia: [
+        ".sql", ".psql", ".ddl", ".prisma", ".ts", ".tsx", ".js", ".jsx",
+        ".mjs", ".cjs", ".py", ".dart", ".lua", ".cs", ".java", ".go",
+        ".rs", ".cpp", ".cc", ".cxx", ".hpp", ".h", ".php",
+    ],
+};
+const METRICAS_CATALOGO_VAZIO = {
+    diretoriosVisitados: 0,
+    arquivosCatalogados: 0,
+    leiturasConteudo: 0,
+    bytesLidos: 0,
+    acertosMemoriaConteudo: 0,
+    origem: "plano_explicito",
+};
+const LEITOR_VAZIO = {
+    contem: () => false,
+    lerTexto: async (caminho) => {
+        throw new Error(`Arquivo fora do plano explicito do drift: ${caminho}`);
+    },
+};
+function estadoCacheInicial(modo, origem, avisos) {
     return {
-        ...serializaveis,
-        mapaImpl,
-        mapaRecursos: construirMapaRecursos(serializaveis.todosRecursos),
-        planoEscopo,
-        cache,
-        catalogo,
-        leitorArquivosPlanejados,
+        modo,
+        origem,
+        schema: SCHEMA_ESTADO_CACHE_DRIFT,
+        metricas: {
+            hits: 0,
+            misses: 0,
+            corruptos: 0,
+            gravacoes: 0,
+            errosGravacao: 0,
+        },
+        avisos,
     };
 }
-function indicesVazios() {
+function indicesVazios(planoEscopo, modoCache, avisosModoCache) {
     return {
-        arquivosOrcamentoAvaliados: [],
         detalhesPersistencia: { colunas: [], repositorios: [] },
-        diagnosticosOrcamento: [],
         indexDart: { simbolos: [], rotas: [], recursos: [], consumerSurfaces: [] },
         indexTs: { simbolos: [], rotas: [], recursos: [], consumerSurfaces: [] },
+        mapaImpl: new Map(),
+        mapaRecursos: new Map(),
         todasRotasIndexadas: [],
         todosArquivosConhecidos: [],
         todosRecursos: [],
         todosSimbolos: [],
+        planoEscopo,
+        cache: estadoCacheInicial(modoCache, "nao_aplicavel", avisosModoCache),
+        catalogo: { ...METRICAS_CATALOGO_VAZIO },
+        leitorArquivosPlanejados: LEITOR_VAZIO,
     };
 }
-function deduplicar(itens, chave) {
-    return [...new Map(itens.map((item) => [chave(item), item])).values()];
+function coletarArquivosFisicosDeclarados(contexto) {
+    const arquivos = new Set();
+    for (const modulo of contexto.modulosSelecionados) {
+        const ir = modulo.resultado.ir;
+        if (!ir) {
+            continue;
+        }
+        for (const { vinculo } of coletarVinculosIr(ir)) {
+            const arquivo = vinculo.arquivo ?? (vinculo.tipo === "arquivo" ? vinculo.valor : undefined);
+            if (arquivo) {
+                arquivos.add(arquivo);
+            }
+        }
+    }
+    return [...arquivos].sort((a, b) => a.localeCompare(b, "pt-BR"));
+}
+function caminhoContidoCache(baseProjeto, arquivo) {
+    const relativo = path.relative(path.resolve(baseProjeto), path.resolve(arquivo));
+    return relativo === "" || (relativo !== ".."
+        && !relativo.startsWith(`..${path.sep}`)
+        && !path.isAbsolute(relativo));
 }
-function filtrarAoCatalogo(itens, catalogo) {
-    return itens.filter((item) => catalogo.contem(item.arquivo));
+function resolverArquivoCache(baseProjeto, arquivo) {
+    if (!path.isAbsolute(arquivo) && arquivo.includes(":")) {
+        throw new Error("cache_indice_arquivo_fora_workspace");
+    }
+    const absoluto = path.isAbsolute(arquivo)
+        ? path.resolve(arquivo)
+        : path.resolve(baseProjeto, arquivo);
+    if (!caminhoContidoCache(baseProjeto, absoluto)) {
+        throw new Error("cache_indice_arquivo_fora_workspace");
+    }
+    return absoluto;
 }
-function sanitizarIndices(indices, catalogo) {
-    const diagnosticosOrcamento = indices.diagnosticosOrcamento.filter((item) => catalogo.contem(path.resolve(catalogo.baseDiretorio, item.arquivo)));
+function caminhoRelativoSeguroCache(baseProjeto, arquivo) {
+    const relativo = path.relative(path.resolve(baseProjeto), resolverArquivoCache(baseProjeto, arquivo)).replace(/\\/g, "/");
+    if (!caminhoRelativoValidoCache(relativo)) {
+        throw new Error("cache_indice_arquivo_fora_workspace");
+    }
+    return relativo;
+}
+function caminhoRelativoValidoCache(valor) {
+    return typeof valor === "string"
+        && valor.length > 0
+        && valor !== "."
+        && valor !== ".."
+        && !valor.startsWith("../")
+        && !valor.includes("\\")
+        && !valor.includes(":")
+        && !valor.includes("\0")
+        && !path.posix.isAbsolute(valor)
+        && valor.split("/").every((segmento) => segmento.length > 0 && segmento !== "." && segmento !== "..");
+}
+function resolverCaminhoRelativoCache(baseProjeto, relativo) {
+    if (!caminhoRelativoValidoCache(relativo)) {
+        throw new Error("cache_indice_arquivo_fora_workspace");
+    }
+    const absoluto = path.resolve(baseProjeto, ...relativo.split("/"));
+    if (!caminhoContidoCache(baseProjeto, absoluto)) {
+        throw new Error("cache_indice_arquivo_fora_workspace");
+    }
+    return absoluto;
+}
+function registroJson(valor) {
+    return typeof valor === "object" && valor !== null && !Array.isArray(valor);
+}
+function textoNaoVazio(valor) {
+    return typeof valor === "string" && valor.length > 0;
+}
+function normalizarJsonCache(valor) {
+    return JSON.parse(JSON.stringify(valor));
+}
+function serializarSimboloCache(baseProjeto, registro) {
     return {
-        arquivosOrcamentoAvaliados: indices.arquivosOrcamentoAvaliados.filter((arquivo) => catalogo.contem(path.resolve(catalogo.baseDiretorio, arquivo))),
-        detalhesPersistencia: {
-            colunas: filtrarAoCatalogo(indices.detalhesPersistencia.colunas, catalogo),
-            repositorios: filtrarAoCatalogo(indices.detalhesPersistencia.repositorios, catalogo),
-        },
-        diagnosticosOrcamento,
-        indexDart: {
-            simbolos: filtrarAoCatalogo(indices.indexDart.simbolos, catalogo),
-            rotas: filtrarAoCatalogo(indices.indexDart.rotas, catalogo),
-            recursos: filtrarAoCatalogo(indices.indexDart.recursos, catalogo),
-            consumerSurfaces: filtrarAoCatalogo(indices.indexDart.consumerSurfaces, catalogo),
-        },
-        indexTs: {
-            simbolos: filtrarAoCatalogo(indices.indexTs.simbolos, catalogo),
-            rotas: filtrarAoCatalogo(indices.indexTs.rotas, catalogo),
-            recursos: filtrarAoCatalogo(indices.indexTs.recursos, catalogo),
-            consumerSurfaces: filtrarAoCatalogo(indices.indexTs.consumerSurfaces, catalogo),
-        },
-        todasRotasIndexadas: filtrarAoCatalogo(indices.todasRotasIndexadas, catalogo),
-        todosArquivosConhecidos: indices.todosArquivosConhecidos.filter((arquivo) => catalogo.contem(arquivo)),
-        todosRecursos: filtrarAoCatalogo(indices.todosRecursos, catalogo),
-        todosSimbolos: filtrarAoCatalogo(indices.todosSimbolos, catalogo),
+        origem: registro.origem,
+        caminho: registro.caminho,
+        arquivo: caminhoRelativoSeguroCache(baseProjeto, registro.arquivo),
+        simbolo: registro.simbolo,
+    };
+}
+function serializarRotaCache(baseProjeto, registro) {
+    return {
+        origem: registro.origem,
+        metodo: registro.metodo,
+        caminho: registro.caminho,
+        arquivo: caminhoRelativoSeguroCache(baseProjeto, registro.arquivo),
+        simbolo: registro.simbolo,
     };
 }
-async function calcularIndices(diretorios, catalogo, exigirCabecalhoCodigoGovernado) {
-    const [indexTs, indexPy, indexDart, indexDotnet, indexJava, indexGo, indexRust, indexLua, indexPhp, indexPersistencia, detalhesPersistencia, indexCpp, arquivosRastreaveis,] = await Promise.all([
+function serializarRecursoCache(baseProjeto, registro) {
+    const serializado = {
+        origem: registro.origem,
+        nome: registro.nome,
+        arquivo: caminhoRelativoSeguroCache(baseProjeto, registro.arquivo),
+        tipo: registro.tipo,
+    };
+    if (registro.simbolo !== undefined) {
+        serializado.simbolo = registro.simbolo;
+    }
+    return serializado;
+}
+function serializarConsumerSurfaceCache(baseProjeto, registro) {
+    return {
+        rota: registro.rota,
+        arquivo: caminhoRelativoSeguroCache(baseProjeto, registro.arquivo),
+        tipoArquivo: registro.tipoArquivo,
+    };
+}
+function serializarColunaPersistenciaCache(baseProjeto, registro) {
+    return {
+        origem: registro.origem,
+        categoriaPersistencia: registro.categoriaPersistencia,
+        recurso: registro.recurso,
+        coluna: registro.coluna,
+        arquivo: caminhoRelativoSeguroCache(baseProjeto, registro.arquivo),
+    };
+}
+function serializarRepositorioPersistenciaCache(baseProjeto, registro) {
+    return {
+        origem: registro.origem,
+        categoriaPersistencia: registro.categoriaPersistencia,
+        recurso: registro.recurso,
+        arquivo: caminhoRelativoSeguroCache(baseProjeto, registro.arquivo),
+    };
+}
+function serializarIndiceCache(baseProjeto, indice) {
+    return {
+        simbolos: indice.simbolos.map((item) => serializarSimboloCache(baseProjeto, item)),
+        rotas: indice.rotas.map((item) => serializarRotaCache(baseProjeto, item)),
+        recursos: indice.recursos.map((item) => serializarRecursoCache(baseProjeto, item)),
+        consumerSurfaces: indice.consumerSurfaces
+            .map((item) => serializarConsumerSurfaceCache(baseProjeto, item)),
+    };
+}
+function derivarIntegridadePayloadCache(indices, detalhesPersistencia) {
+    const agregar = (campo) => CHAVES_INDICES_CACHE_DRIFT
+        .flatMap((chave) => {
+        const indice = indices[chave];
+        return indice[campo];
+    });
+    return {
+        simbolosDigest: digestJsonCanonicoCacheDrift(agregar("simbolos")),
+        rotasDigest: digestJsonCanonicoCacheDrift(agregar("rotas")),
+        recursosDigest: digestJsonCanonicoCacheDrift(agregar("recursos")),
+        consumerSurfacesDigest: digestJsonCanonicoCacheDrift(agregar("consumerSurfaces")),
+        persistenciaDigest: digestJsonCanonicoCacheDrift(detalhesPersistencia),
+    };
+}
+function serializarIndicesCache(baseProjeto, extracoes) {
+    const indices = Object.fromEntries(CHAVES_INDICES_CACHE_DRIFT.map((chave) => [
+        chave,
+        serializarIndiceCache(baseProjeto, extracoes.indices[chave]),
+    ]));
+    const detalhesPersistencia = {
+        colunas: extracoes.detalhesPersistencia.colunas
+            .map((item) => serializarColunaPersistenciaCache(baseProjeto, item)),
+        repositorios: extracoes.detalhesPersistencia.repositorios
+            .map((item) => serializarRepositorioPersistenciaCache(baseProjeto, item)),
+    };
+    return normalizarJsonCache({
+        schema: SCHEMA_PAYLOAD_INDICES_CACHE_DRIFT,
+        detalhesPersistencia,
+        indices,
+        integridadeDerivada: derivarIntegridadePayloadCache(indices, detalhesPersistencia),
+    });
+}
+function possuiCamposExatos(valor, obrigatorios, opcionais = []) {
+    const permitidos = new Set([...obrigatorios, ...opcionais]);
+    return obrigatorios.every((campo) => Object.prototype.hasOwnProperty.call(valor, campo))
+        && Object.keys(valor).every((campo) => permitidos.has(campo));
+}
+function validarRegistroArquivoCache(valor, camposTexto, camposOpcionais = []) {
+    return registroJson(valor)
+        && possuiCamposExatos(valor, ["arquivo", ...camposTexto], camposOpcionais)
+        && caminhoRelativoValidoCache(valor.arquivo)
+        && camposTexto.every((campo) => textoNaoVazio(valor[campo]))
+        && camposOpcionais.every((campo) => valor[campo] === undefined || textoNaoVazio(valor[campo]));
+}
+function validarListaRegistrosCache(valor, camposTexto, camposOpcionais = []) {
+    return Array.isArray(valor)
+        && valor.every((item) => validarRegistroArquivoCache(item, camposTexto, camposOpcionais));
+}
+function arquivoCompativelComIndiceCache(chave, arquivo) {
+    const extensao = path.posix.extname(arquivo).toLowerCase();
+    return EXTENSOES_POR_INDICE[chave].includes(extensao);
+}
+function validarIndiceLinguagemCache(valor, chave) {
+    if (!(registroJson(valor)
+        && possuiCamposExatos(valor, ["simbolos", "rotas", "recursos", "consumerSurfaces"])
+        && validarListaRegistrosCache(valor.simbolos, ["origem", "caminho", "simbolo"])
+        && validarListaRegistrosCache(valor.rotas, ["origem", "metodo", "caminho", "simbolo"])
+        && validarListaRegistrosCache(valor.recursos, ["origem", "nome", "tipo"], ["simbolo"])
+        && validarListaRegistrosCache(valor.consumerSurfaces, ["rota", "tipoArquivo"]))) {
+        return false;
+    }
+    const registros = [valor.simbolos, valor.rotas, valor.recursos, valor.consumerSurfaces]
+        .flat();
+    if (!registros.every((item) => arquivoCompativelComIndiceCache(chave, item.arquivo)))
+        return false;
+    if (!valor.simbolos
+        .every((item) => ORIGENS_SIMBOLO_POR_INDICE[chave].includes(item.origem)))
+        return false;
+    if (["indexLua", "indexCpp", "indexPersistencia"].includes(chave)
+        && (valor.rotas.length > 0 || valor.consumerSurfaces.length > 0))
+        return false;
+    if (!["indexTs", "indexDart"].includes(chave) && valor.consumerSurfaces.length > 0)
+        return false;
+    const caminhosRotas = new Set(valor.rotas
+        .map((rota) => rota.caminho));
+    return valor.consumerSurfaces
+        .every((surface) => caminhosRotas.has(surface.rota));
+}
+function validarPayloadIndicesCache(valor) {
+    if (!registroJson(valor)
+        || !possuiCamposExatos(valor, [
+            "schema",
+            "detalhesPersistencia",
+            "indices",
+            "integridadeDerivada",
+        ])
+        || valor.schema !== SCHEMA_PAYLOAD_INDICES_CACHE_DRIFT
+        || !registroJson(valor.detalhesPersistencia)
+        || !possuiCamposExatos(valor.detalhesPersistencia, ["colunas", "repositorios"])
+        || !registroJson(valor.indices)
+        || !possuiCamposExatos(valor.indices, CHAVES_INDICES_CACHE_DRIFT)
+        || !CHAVES_INDICES_CACHE_DRIFT.every((chave) => validarIndiceLinguagemCache(valor.indices[chave], chave))
+        || !registroJson(valor.integridadeDerivada)
+        || !possuiCamposExatos(valor.integridadeDerivada, [
+            "simbolosDigest",
+            "rotasDigest",
+            "recursosDigest",
+            "consumerSurfacesDigest",
+            "persistenciaDigest",
+        ])) {
+        return false;
+    }
+    const estruturaValida = validarListaRegistrosCache(valor.detalhesPersistencia.colunas, ["origem", "categoriaPersistencia", "recurso", "coluna"]) && validarListaRegistrosCache(valor.detalhesPersistencia.repositorios, ["origem", "categoriaPersistencia", "recurso"]);
+    if (!estruturaValida)
+        return false;
+    const integridadeEsperada = derivarIntegridadePayloadCache(valor.indices, valor.detalhesPersistencia);
+    return Object.entries(integridadeEsperada).every(([campo, esperado]) => (valor.integridadeDerivada[campo] === esperado));
+}
+function restaurarRegistroArquivoCache(baseProjeto, catalogo, registro) {
+    const arquivo = resolverCaminhoRelativoCache(baseProjeto, registro.arquivo);
+    if (!catalogo.contem(arquivo)) {
+        throw new Error("cache_indice_arquivo_fora_catalogo");
+    }
+    return { ...registro, arquivo };
+}
+function restaurarIndicesCache(baseProjeto, catalogo, payload) {
+    if (!validarPayloadIndicesCache(payload))
+        return null;
+    const restaurar = (valor) => valor.map((item) => restaurarRegistroArquivoCache(baseProjeto, catalogo, item));
+    try {
+        const detalhes = payload.detalhesPersistencia;
+        const indicesPayload = payload.indices;
+        const indices = Object.fromEntries(CHAVES_INDICES_CACHE_DRIFT.map((chave) => {
+            const indice = indicesPayload[chave];
+            return [chave, {
+                    simbolos: restaurar(indice.simbolos),
+                    rotas: restaurar(indice.rotas),
+                    recursos: restaurar(indice.recursos),
+                    consumerSurfaces: restaurar(indice.consumerSurfaces),
+                }];
+        }));
+        return derivarIndicesExtraidos({
+            detalhesPersistencia: {
+                colunas: restaurar(detalhes.colunas),
+                repositorios: restaurar(detalhes.repositorios),
+            },
+            indices,
+        }, catalogo);
+    }
+    catch {
+        return null;
+    }
+}
+function criarMapaImplDrift(todosSimbolos, arquivosPrioritarios) {
+    const prioritarios = new Set(arquivosPrioritarios.map(chaveCaminhoCanonicoDrift));
+    const mapaImpl = new Map();
+    for (const simbolo of todosSimbolos.filter((item) => item.origem !== "sql")) {
+        const existente = mapaImpl.get(simbolo.caminho);
+        if (!existente) {
+            mapaImpl.set(simbolo.caminho, simbolo);
+            continue;
+        }
+        const prioridadeExistente = prioritarios.has(chaveCaminhoCanonicoDrift(existente.arquivo));
+        const prioridadeNova = prioritarios.has(chaveCaminhoCanonicoDrift(simbolo.arquivo));
+        if ((prioridadeNova && !prioridadeExistente)
+            || (prioridadeNova === prioridadeExistente
+                && simbolo.arquivo.localeCompare(existente.arquivo, "pt-BR") < 0)) {
+            mapaImpl.set(simbolo.caminho, simbolo);
+        }
+    }
+    return mapaImpl;
+}
+function montarIndicesPreparados(extraidos, arquivosPrioritarios, planoEscopo, cache, catalogo) {
+    return {
+        ...extraidos,
+        mapaImpl: criarMapaImplDrift(extraidos.todosSimbolos, arquivosPrioritarios),
+        mapaRecursos: construirMapaRecursos(extraidos.todosRecursos),
+        planoEscopo,
+        cache,
+        catalogo: catalogo.metricas(),
+        leitorArquivosPlanejados: catalogo,
+    };
+}
+function derivarIndicesExtraidos(extracoes, catalogo) {
+    const agregar = (campo) => CHAVES_INDICES_CACHE_DRIFT
+        .flatMap((chave) => extracoes.indices[chave][campo]);
+    const todosSimbolos = agregar("simbolos");
+    const todasRotasIndexadas = agregar("rotas");
+    const todosRecursos = agregar("recursos");
+    const todosArquivosConhecidos = [...new Set([
+            ...catalogo.arquivosCatalogados(),
+            ...todosSimbolos.map((item) => item.arquivo),
+            ...todasRotasIndexadas.map((item) => item.arquivo),
+            ...todosRecursos.map((item) => item.arquivo),
+        ])].sort((a, b) => a.localeCompare(b, "pt-BR"));
+    return {
+        detalhesPersistencia: extracoes.detalhesPersistencia,
+        indexDart: extracoes.indices.indexDart,
+        indexTs: extracoes.indices.indexTs,
+        todasRotasIndexadas,
+        todosArquivosConhecidos,
+        todosRecursos,
+        todosSimbolos,
+    };
+}
+async function calcularIndices(diretorios, catalogo) {
+    const [indexTs, indexPy, indexDart, indexDotnet, indexJava, indexGo, indexRust, indexLua, indexPhp, indexPersistencia, detalhesPersistencia, indexCpp,] = await Promise.all([
         indexarTypeScript(diretorios, catalogo),
         indexarPython(diretorios, catalogo),
         indexarDart(diretorios, catalogo),
@@ -249,467 +439,231 @@ async function calcularIndices(diretorios, catalogo, exigirCabecalhoCodigoGovern
         indexarPersistenciaDeclarativa(diretorios, catalogo),
         indexarPersistenciaDetalhada(diretorios, catalogo),
         indexarCpp(diretorios, catalogo),
-        indexarArquivosRastreaveis(diretorios, catalogo),
     ]);
-    const todosSimbolos = [
-        ...indexTs.simbolos,
-        ...indexPy.simbolos,
-        ...indexDart.simbolos,
-        ...indexDotnet.simbolos,
-        ...indexJava.simbolos,
-        ...indexGo.simbolos,
-        ...indexRust.simbolos,
-        ...indexLua.simbolos,
-        ...indexCpp.simbolos,
-        ...indexPhp.simbolos,
-        ...indexPersistencia.simbolos,
-    ];
-    const todosRecursos = [
-        ...indexTs.recursos,
-        ...indexPy.recursos,
-        ...indexDart.recursos,
-        ...indexDotnet.recursos,
-        ...indexJava.recursos,
-        ...indexGo.recursos,
-        ...indexRust.recursos,
-        ...indexLua.recursos,
-        ...indexCpp.recursos,
-        ...indexPhp.recursos,
-        ...indexPersistencia.recursos,
-    ];
-    const todasRotasIndexadas = [
-        ...indexTs.rotas,
-        ...indexPy.rotas,
-        ...indexDart.rotas,
-        ...indexDotnet.rotas,
-        ...indexJava.rotas,
-        ...indexGo.rotas,
-        ...indexRust.rotas,
-        ...indexPhp.rotas,
-    ];
-    const todosArquivosConhecidos = [...new Set([
-            ...arquivosRastreaveis,
-            ...todosSimbolos.map((item) => item.arquivo),
-            ...todasRotasIndexadas.map((item) => item.arquivo),
-            ...todosRecursos.map((item) => item.arquivo),
-        ])].sort((a, b) => a.localeCompare(b, "pt-BR"));
-    const diagnosticosOrcamento = await emitirDiagnosticosArquivosOrcamento({
-        arquivos: catalogo.arquivosCatalogados(),
-        baseProjeto: catalogo.baseDiretorio,
-        exigirCabecalhoCodigoGovernado,
-        leitorArquivos: catalogo,
-    });
-    return sanitizarIndices(paraJsonCache({
-        arquivosOrcamentoAvaliados: catalogo.arquivosCatalogados()
-            .map((arquivo) => pathRelativo(catalogo.baseDiretorio, arquivo)),
+    const extracoes = {
         detalhesPersistencia,
-        diagnosticosOrcamento,
-        indexDart,
-        indexTs,
-        todasRotasIndexadas,
-        todosArquivosConhecidos,
-        todosRecursos,
-        todosSimbolos,
-    }), catalogo);
-}
-function mesclarIndices(resumos, todosArquivosCatalogados) {
-    const simbolos = deduplicar(resumos.flatMap((item) => item.todosSimbolos), (item) => item.caminho);
-    const rotas = deduplicar(resumos.flatMap((item) => item.todasRotasIndexadas), (item) => `${item.origem}:${item.metodo}:${item.caminho}:${item.arquivo}:${item.simbolo}`);
-    const recursos = deduplicar(resumos.flatMap((item) => item.todosRecursos), (item) => `${item.origem}:${item.tipo}:${item.nome}:${item.arquivo}:${item.simbolo ?? ""}`);
-    const simbolosTs = deduplicar(resumos.flatMap((item) => item.indexTs.simbolos), (item) => item.caminho);
-    const rotasTs = deduplicar(resumos.flatMap((item) => item.indexTs.rotas), (item) => `${item.origem}:${item.metodo}:${item.caminho}:${item.arquivo}:${item.simbolo}`);
-    const recursosTs = deduplicar(resumos.flatMap((item) => item.indexTs.recursos), (item) => `${item.origem}:${item.tipo}:${item.nome}:${item.arquivo}:${item.simbolo ?? ""}`);
-    const surfacesTs = deduplicar(resumos.flatMap((item) => item.indexTs.consumerSurfaces), (item) => `${item.rota}:${item.arquivo}:${item.tipoArquivo}`);
-    const simbolosDart = deduplicar(resumos.flatMap((item) => item.indexDart.simbolos), (item) => item.caminho);
-    const rotasDart = deduplicar(resumos.flatMap((item) => item.indexDart.rotas), (item) => `${item.origem}:${item.metodo}:${item.caminho}:${item.arquivo}:${item.simbolo}`);
-    const recursosDart = deduplicar(resumos.flatMap((item) => item.indexDart.recursos), (item) => `${item.origem}:${item.tipo}:${item.nome}:${item.arquivo}:${item.simbolo ?? ""}`);
-    const surfacesDart = deduplicar(resumos.flatMap((item) => item.indexDart.consumerSurfaces), (item) => `${item.rota}:${item.arquivo}:${item.tipoArquivo}`);
-    const colunas = deduplicar(resumos.flatMap((item) => item.detalhesPersistencia.colunas), (item) => `${item.origem}:${item.recurso}:${item.coluna}:${item.arquivo}`);
-    const repositorios = deduplicar(resumos.flatMap((item) => item.detalhesPersistencia.repositorios), (item) => `${item.origem}:${item.recurso}:${item.arquivo}`);
-    const diagnosticosOrcamento = deduplicar(resumos.flatMap((item) => item.diagnosticosOrcamento), (item) => `${item.tipo}:${item.arquivo}:${item.severidade}:${item.mensagem}`);
-    return paraJsonCache({
-        arquivosOrcamentoAvaliados: [...new Set(resumos.flatMap((item) => item.arquivosOrcamentoAvaliados))].sort((a, b) => a.localeCompare(b, "pt-BR")),
-        detalhesPersistencia: { colunas, repositorios },
-        diagnosticosOrcamento,
-        indexDart: {
-            simbolos: simbolosDart,
-            rotas: rotasDart,
-            recursos: recursosDart,
-            consumerSurfaces: surfacesDart,
-        },
-        indexTs: {
-            simbolos: simbolosTs,
-            rotas: rotasTs,
-            recursos: recursosTs,
-            consumerSurfaces: surfacesTs,
+        indices: {
+            indexTs,
+            indexPy: { ...indexPy, consumerSurfaces: [] },
+            indexDart,
+            indexDotnet: { ...indexDotnet, consumerSurfaces: [] },
+            indexJava: { ...indexJava, consumerSurfaces: [] },
+            indexGo: { ...indexGo, consumerSurfaces: [] },
+            indexRust: { ...indexRust, consumerSurfaces: [] },
+            indexLua: { ...indexLua, rotas: [], consumerSurfaces: [] },
+            indexCpp: { ...indexCpp, rotas: [], consumerSurfaces: [] },
+            indexPhp: { ...indexPhp, consumerSurfaces: [] },
+            indexPersistencia: { ...indexPersistencia, rotas: [], consumerSurfaces: [] },
         },
-        todasRotasIndexadas: rotas,
-        todosArquivosConhecidos: [...new Set(todosArquivosCatalogados)].sort((a, b) => a.localeCompare(b, "pt-BR")),
-        todosRecursos: recursos,
-        todosSimbolos: simbolos,
+    };
+    return [extracoes, derivarIndicesExtraidos(extracoes, catalogo)];
+}
+function relativoIdentidade(baseProjeto, alvo) {
+    const absoluto = resolverArquivoCache(baseProjeto, alvo);
+    const relativo = path.relative(path.resolve(baseProjeto), absoluto).replace(/\\/g, "/");
+    if (relativo === "")
+        return ".";
+    if (relativo === ".."
+        || relativo.startsWith("../")
+        || relativo.includes(":")
+        || relativo.includes("\0")
+        || path.posix.isAbsolute(relativo)) {
+        throw new Error("cache_identidade_fora_workspace");
+    }
+    return relativo;
+}
+function digestValorCache(valor) {
+    return digestJsonCanonicoCacheDrift(normalizarJsonCache(valor));
+}
+function representarPlanoCache(contexto, configuracao, plano) {
+    const relativo = (alvo) => relativoIdentidade(contexto.baseProjeto, alvo);
+    const ordenar = (itens) => [...new Set(itens.map(relativo))]
+        .sort((a, b) => a.localeCompare(b, "pt-BR"));
+    const dependencias = Object.entries(plano.dependencias)
+        .map(([arquivo, destinos]) => [
+        relativo(arquivo),
+        ordenar(destinos),
+    ])
+        .sort(([a], [b]) => a.localeCompare(b, "pt-BR"));
+    return normalizarJsonCache({
+        escopo: configuracao.escopo,
+        estrategia: plano.estrategia,
+        cobertura: plano.cobertura,
+        termos: [...configuracao.termosEscopo].sort((a, b) => a.localeCompare(b, "pt-BR")),
+        modulos: [...plano.modulos].sort((a, b) => a.localeCompare(b, "pt-BR")),
+        arquivos: ordenar(plano.arquivos),
+        arquivosDeclarados: ordenar(plano.arquivosDeclarados),
+        arquivosInferidos: ordenar(plano.arquivosInferidos),
+        arquivosAusentes: ordenar(plano.arquivosAusentes),
+        diretorios: ordenar(plano.diretorios),
+        diretoriosCodigo: ordenar(contexto.diretoriosCodigo),
+        ignorarWorktrees: configuracao.ignorarWorktrees,
+        ignorarConsumidoresLaterais: configuracao.ignorarConsumidoresLaterais,
+        dependencias,
     });
 }
-class CatalogoFiltradoDrift {
-    origem;
-    baseDiretorio;
-    raizes;
-    permitidos;
-    constructor(origem, arquivos) {
-        this.origem = origem;
-        this.baseDiretorio = origem.baseDiretorio;
-        this.raizes = origem.raizes;
-        this.permitidos = new Set(arquivos.map(chaveCaminho));
-    }
-    listar(extensoesOuFiltro = [], raizes) {
-        const arquivos = Array.isArray(extensoesOuFiltro)
-            ? this.origem.listar(extensoesOuFiltro, raizes)
-            : this.origem.listar(extensoesOuFiltro);
-        return arquivos.filter((arquivo) => this.permitidos.has(chaveCaminho(arquivo)));
-    }
-    listarEntradas(filtro = {}) {
-        return this.origem.listarEntradas(filtro)
-            .filter((arquivo) => this.permitidos.has(chaveCaminho(arquivo.caminho)));
-    }
-    listarPorExtensoes(extensoes, raiz) {
-        return this.listarEntradas({ extensoes, raiz }).map((arquivo) => arquivo.caminho);
-    }
-    listarPorRaiz(raiz, extensoes) {
-        return this.listarEntradas({ raiz, extensoes }).map((arquivo) => arquivo.caminho);
-    }
-    arquivosCatalogados() {
-        return this.listar();
-    }
-    async incluir(arquivos) {
-        const fora = arquivos.find((arquivo) => !this.permitidos.has(chaveCaminho(arquivo)));
-        if (fora) {
-            throw new Error(`Arquivo fora da unidade incremental do drift: ${fora}`);
-        }
-    }
-    contem(caminho) {
-        return this.permitidos.has(chaveCaminho(caminho)) && this.origem.contem(caminho);
-    }
-    ler(caminho) {
-        return this.contem(caminho)
-            ? this.origem.ler(caminho)
-            : Promise.reject(new Error(`Arquivo fora da unidade incremental do drift: ${caminho}`));
-    }
-    async lerTexto(caminho) {
-        return (await this.ler(caminho)).texto;
-    }
-    async digest(caminho) {
-        return (await this.ler(caminho)).digest;
-    }
-    fingerprint(caminhos) {
-        const selecionados = (caminhos ?? this.arquivosCatalogados())
-            .filter((arquivo) => this.contem(arquivo));
-        return this.origem.fingerprint(selecionados);
+async function criarChaveIndicesCache(contexto, configuracao, plano, catalogo, store, arquivosExplicitos) {
+    const candidatos = new Map();
+    const adicionarCandidato = (arquivo) => {
+        const absoluto = resolverArquivoCache(contexto.baseProjeto, arquivo);
+        candidatos.set(chaveCaminhoCanonicoDrift(absoluto), absoluto);
+    };
+    for (const entrada of catalogo.listarEntradas().filter((item) => configuracao.escopo === "projeto" || item.explicito)) {
+        adicionarCandidato(entrada.caminho);
     }
-    obterFingerprint(caminhos) {
-        return this.fingerprint(caminhos);
+    for (const arquivo of [
+        ...arquivosExplicitos,
+        ...plano.arquivos,
+        ...plano.arquivosDeclarados,
+        ...plano.arquivosInferidos,
+        ...plano.arquivosAusentes,
+    ]) {
+        adicionarCandidato(arquivo);
     }
-    emitir(tipo, arquivo) {
-        if (tipo === "ast.create") {
-            this.origem.emitir(tipo, arquivo);
+    const membros = await Promise.all([...candidatos.values()].map(async (arquivo) => {
+        const relativo = caminhoRelativoSeguroCache(contexto.baseProjeto, arquivo);
+        if (!catalogo.contem(arquivo)) {
+            return { arquivo: relativo, estado: "ausente" };
         }
-    }
-    metricas() {
-        return this.origem.metricas();
-    }
-    snapshot() {
-        const snapshot = this.origem.snapshot();
         return {
-            ...snapshot,
-            arquivos: snapshot.arquivos.filter((arquivo) => this.permitidos.has(chaveCaminho(path.resolve(this.baseDiretorio, arquivo.caminho)))),
+            arquivo: relativo,
+            estado: "presente",
+            digest: await catalogo.digest(arquivo),
         };
-    }
+    }));
+    membros.sort((a, b) => a.arquivo.localeCompare(b.arquivo, "pt-BR"));
+    const contratos = contexto.modulosSelecionados
+        .map((modulo) => ({
+        arquivo: caminhoRelativoSeguroCache(contexto.baseProjeto, modulo.caminho),
+        modulo: modulo.resultado.ir ?? null,
+        diagnosticos: modulo.resultado.diagnosticos,
+    }))
+        .sort((a, b) => a.arquivo.localeCompare(b.arquivo, "pt-BR"));
+    return digestJsonCanonicoCacheDrift({
+        schema: SCHEMA_IDENTIDADE_INDICES_CACHE_DRIFT,
+        cliVersion: pacoteCli.version,
+        typescriptVersion: ts.version,
+        extrator: EXTRATOR_INDICES_CACHE_DRIFT,
+        workspaceId: store.workspaceId,
+        gitHead: store.gitHead,
+        planoDigest: digestValorCache(representarPlanoCache(contexto, configuracao, plano)),
+        contratosDigest: digestValorCache(contratos),
+        configuracaoDigest: digestValorCache(contexto.configCarregada?.config ?? null),
+        membros,
+    });
 }
-function extrairPerfilAgrupamentoTypeScript(arquivo, codigo) {
-    const relacao = arquivo.replace(/\\/g, "/");
-    const motivos = new Set();
-    if (/(?:^|\n)\s*export\s+(?:type\s+)?(?:\*|\{[\s\S]{0,4000}?\})\s+from\s*["'`][^"'`]+["'`]/mu.test(codigo)) {
-        motivos.add("reexportacao");
-    }
-    if (/(?:^|\/)(?:app\.)?(?:routes?|router|routing)(?:\.[^/]*)?\.(?:ts|tsx|js|jsx|mjs|cjs)$/iu.test(relacao)
-        || /\b(?:createBrowserRouter|useRoutes|loadChildren|loadComponent)\s*[:(]/u.test(codigo)
-        || /\bRouterModule\.(?:forRoot|forChild)\s*\(/u.test(codigo)
-        || /<Routes?\b/u.test(codigo)) {
-        motivos.add("roteamento_consumer");
-    }
-    if (/(?:^|\/)(?:src\/)?(?:app\/)?app\.component\.(?:ts|js)$/iu.test(relacao)) {
-        motivos.add("angular_standalone_raiz");
-    }
+function adaptarEventoStoreCache(observador) {
+    if (!observador)
+        return undefined;
+    return (evento) => {
+        const tipo = evento.tipo === "cache.read.hit"
+            ? "cache.hit"
+            : evento.tipo === "cache.read.miss"
+                ? "cache.miss"
+                : evento.tipo === "cache.read.corrupt"
+                    ? "cache.corrupt"
+                    : evento.tipo === "cache.write.published" || evento.tipo === "cache.write.reused"
+                        ? "cache.write"
+                        : evento.tipo === "cache.store.unavailable" || evento.tipo === "cache.write.error"
+                            ? "cache.unavailable"
+                            : null;
+        if (!tipo)
+            return;
+        try {
+            observador({
+                tipo,
+                ...(evento.caminhoVirtual ? { caminho: evento.caminhoVirtual } : {}),
+                ...(evento.chave ? { chave: evento.chave } : {}),
+                ...(evento.codigo ? { motivo: evento.codigo } : {}),
+            });
+        }
+        catch {
+            // Observabilidade não altera o resultado funcional do drift.
+        }
+    };
+}
+function estadoCacheDoStore(modo, origem, avisos, store) {
+    const metricas = store.metricas();
     return {
-        acoplarDependencias: motivos.size > 0,
-        motivos: [...motivos].sort((a, b) => a.localeCompare(b, "pt-BR")),
+        modo,
+        origem,
+        schema: SCHEMA_ESTADO_CACHE_DRIFT,
+        ...(store.workspaceId ? { workspaceId: store.workspaceId } : {}),
+        metricas: {
+            hits: metricas.hits,
+            misses: metricas.misses,
+            corruptos: metricas.corruptos,
+            gravacoes: metricas.publicacoes,
+            errosGravacao: metricas.erros,
+        },
+        avisos,
     };
 }
-function perfilAgrupamentoTypeScriptValido(valor) {
-    return registroObjeto(valor)
-        && typeof valor.acoplarDependencias === "boolean"
-        && Array.isArray(valor.motivos)
-        && valor.motivos.every(textoNaoVazio);
-}
-function construirGruposIncrementais(arquivos, dependencias, perfisTypeScript) {
-    const porChave = new Map(arquivos.map((arquivo) => [chaveCaminho(arquivo), arquivo]));
-    const analisaveis = arquivos.filter((arquivo) => EXTENSOES_ANALISE_DRIFT.has(path.extname(arquivo).toLowerCase()));
-    const typescript = analisaveis.filter((arquivo) => EXTENSOES_TYPESCRIPT_DRIFT.has(path.extname(arquivo).toLowerCase()));
-    const dependenciasPorChave = new Map();
-    for (const arquivo of typescript) {
-        const destinos = (dependencias[arquivo] ?? [])
-            .map((dependencia) => porChave.get(chaveCaminho(dependencia)))
-            .filter((dependencia) => Boolean(dependencia))
-            .filter((dependencia) => EXTENSOES_DEPENDENCIA_TYPESCRIPT_DRIFT.has(path.extname(dependencia).toLowerCase()));
-        dependenciasPorChave.set(chaveCaminho(arquivo), destinos);
+async function resolverIndicesComCache(contexto, configuracaoEscopo, planoEscopo, catalogo, arquivosPrioritarios, arquivosExplicitos, modoCache, avisosModoCache, observador) {
+    const store = await criarStoreCacheDrift({
+        baseProjeto: contexto.baseProjeto,
+        observador: adaptarEventoStoreCache(observador),
+    });
+    if (!store.disponivel) {
+        const [, extraidos] = await calcularIndices(planoEscopo.diretorios, catalogo);
+        return montarIndicesPreparados(extraidos, arquivosPrioritarios, planoEscopo, estadoCacheDoStore(modoCache, "indisponivel", avisosModoCache, store), catalogo);
     }
-    const pai = new Map();
-    const encontrar = (chave) => {
-        const atual = pai.get(chave) ?? chave;
-        if (atual === chave) {
-            pai.set(chave, chave);
-            return chave;
-        }
-        const raiz = encontrar(atual);
-        pai.set(chave, raiz);
-        return raiz;
-    };
-    const unir = (a, b) => {
-        const raizA = encontrar(a);
-        const raizB = encontrar(b);
-        if (raizA !== raizB) {
-            pai.set(raizB, raizA.localeCompare(raizB, "en") <= 0 ? raizA : raizB);
-            pai.set(raizA, raizA.localeCompare(raizB, "en") <= 0 ? raizA : raizB);
-        }
+    let chave;
+    try {
+        chave = await criarChaveIndicesCache(contexto, configuracaoEscopo, planoEscopo, catalogo, store, arquivosExplicitos);
+    }
+    catch {
+        const [, extraidos] = await calcularIndices(planoEscopo.diretorios, catalogo);
+        return montarIndicesPreparados(extraidos, arquivosPrioritarios, planoEscopo, estadoCacheDoStore(modoCache, "indisponivel", avisosModoCache, store), catalogo);
+    }
+    const validarPayloadAplicavel = (valor) => {
+        if (!validarPayloadIndicesCache(valor))
+            return false;
+        return restaurarIndicesCache(contexto.baseProjeto, catalogo, valor) !== null;
     };
-    for (const semente of typescript) {
-        if (!perfisTypeScript.get(chaveCaminho(semente))?.acoplarDependencias) {
-            continue;
-        }
-        const chaveSemente = chaveCaminho(semente);
-        const fila = [chaveSemente];
-        const fechamento = new Set();
-        while (fila.length > 0) {
-            const atual = fila.shift();
-            if (fechamento.has(atual)) {
-                continue;
+    if (modoCache === "cache") {
+        const leitura = await store.ler(chave, validarPayloadAplicavel);
+        if (leitura.estado === "hit") {
+            const restaurados = restaurarIndicesCache(contexto.baseProjeto, catalogo, leitura.valor);
+            if (restaurados) {
+                return montarIndicesPreparados(restaurados, arquivosPrioritarios, planoEscopo, estadoCacheDoStore(modoCache, "cache", avisosModoCache, store), catalogo);
             }
-            fechamento.add(atual);
-            for (const dependencia of dependenciasPorChave.get(atual) ?? []) {
-                const chaveDependencia = chaveCaminho(dependencia);
-                if (!fechamento.has(chaveDependencia)) {
-                    fila.push(chaveDependencia);
-                }
-            }
-        }
-        for (const membro of fechamento) {
-            unir(chaveSemente, membro);
         }
     }
-    const gruposPorRaiz = new Map();
-    const usados = new Set();
-    for (const arquivo of arquivos) {
-        const chave = chaveCaminho(arquivo);
-        if (!pai.has(chave)) {
-            continue;
-        }
-        usados.add(chave);
-        const raiz = encontrar(chave);
-        const grupo = gruposPorRaiz.get(raiz) ?? [];
-        grupo.push(arquivo);
-        gruposPorRaiz.set(raiz, grupo);
+    const [extracoes, extraidos] = await calcularIndices(planoEscopo.diretorios, catalogo);
+    try {
+        const payload = serializarIndicesCache(contexto.baseProjeto, extracoes);
+        await store.publicar(chave, payload, validarPayloadAplicavel);
     }
-    const grupos = [...gruposPorRaiz.values()]
-        .map((grupo) => grupo.sort((a, b) => a.localeCompare(b, "pt-BR")));
-    for (const arquivo of analisaveis.sort((a, b) => a.localeCompare(b, "pt-BR"))) {
-        const chave = chaveCaminho(arquivo);
-        if (!usados.has(chave)) {
-            usados.add(chave);
-            grupos.push([arquivo]);
-        }
+    catch {
+        // Cache é aceleração descartável; a extração recém-calculada continua autoritativa.
     }
-    return grupos
-        .filter((grupo) => grupo.length > 0)
-        .sort((a, b) => a[0].localeCompare(b[0], "pt-BR"));
-}
-async function mapearComLimite(itens, limite, executar) {
-    const resultados = new Array(itens.length);
-    let proximo = 0;
-    const trabalhador = async () => {
-        for (;;) {
-            const indice = proximo;
-            proximo += 1;
-            if (indice >= itens.length) {
-                return;
-            }
-            resultados[indice] = await executar(itens[indice]);
-        }
-    };
-    await Promise.all(Array.from({ length: Math.min(limite, itens.length) }, trabalhador));
-    return resultados;
-}
-function pathRelativo(baseProjeto, alvo) {
-    const relativo = path.relative(baseProjeto, alvo).replace(/\\/g, "/");
-    return relativo || ".";
-}
-function criarIdentidadeCache(contexto, configuracaoEscopo, plano, exigirCabecalhoCodigoGovernado) {
-    const ordenarCaminhos = (caminhos) => [...new Set(caminhos.map((caminho) => path.normalize(path.resolve(caminho))))].sort((a, b) => a.localeCompare(b, "pt-BR"));
-    const representarDiretorios = (diretorios) => {
-        const fisicos = ordenarCaminhos(diretorios);
-        return {
-            fisicos,
-            semanticos: fisicos.map((diretorio) => pathRelativo(contexto.baseProjeto, diretorio)),
-        };
-    };
-    return paraJsonCache({
-        cliVersion: pacoteCli.version,
-        typescriptVersion: ts.version,
-        fileIndexSchema: FILE_INDEX_SCHEMA,
-        extractorBuild: "drift-file-index-v4-2026-07-21",
-        escopo: {
-            solicitado: configuracaoEscopo.escopo,
-            estrategia: plano.estrategia,
-            cobertura: plano.cobertura,
-            termos: [...configuracaoEscopo.termosEscopo].sort((a, b) => a.localeCompare(b, "pt-BR")),
-            modulos: [...plano.modulos].sort((a, b) => a.localeCompare(b, "pt-BR")),
-            arquivosFisicos: ordenarCaminhos(plano.arquivos),
-            arquivosSemanticos: plano.arquivos
-                .map((arquivo) => pathRelativo(contexto.baseProjeto, arquivo))
-                .sort((a, b) => a.localeCompare(b, "pt-BR")),
-        },
-        diretoriosPlano: representarDiretorios(plano.diretorios),
-        diretoriosContexto: representarDiretorios(contexto.diretoriosCodigo),
-        exigirCabecalhoCodigoGovernado,
-        ignorarWorktrees: configuracaoEscopo.ignorarWorktrees,
-        ignorarConsumidoresLaterais: configuracaoEscopo.ignorarConsumidoresLaterais,
-        fontesLegado: contexto.fontesLegado,
-        configuracao: contexto.configCarregada?.config ?? null,
-    });
+    return montarIndicesPreparados(extraidos, arquivosPrioritarios, planoEscopo, estadoCacheDoStore(modoCache, "calculado", avisosModoCache, store), catalogo);
 }
 export async function prepararIndicesDrift(contexto, configuracaoEscopo, opcoes = {}) {
-    const inicioTotal = performance.now();
+    const modoCache = opcoes.modoCache ?? "none";
+    const avisosModoCache = opcoes.avisosModoCache ?? [];
     let planoEscopo = await planejarEscopoDrift(contexto, configuracaoEscopo);
-    const fimPlanejamento = performance.now();
-    const politicaCache = opcoes.politicaCache ?? "auto";
     if (planoEscopo.bloqueios.length > 0) {
-        return reconstruirIndices(indicesVazios(), planoEscopo, {
-            politica: politicaCache,
-            origem: "nao_aplicavel",
-            fasesMs: {
-                planejamento: Number((fimPlanejamento - inicioTotal).toFixed(3)),
-                catalogacao: 0,
-                dependencias: 0,
-                assinaturas: 0,
-                indexacao: 0,
-                total: Number((performance.now() - inicioTotal).toFixed(3)),
-            },
-        }, {
-            diretoriosVisitados: 0,
-            arquivosCatalogados: 0,
-            leiturasConteudo: 0,
-            bytesLidos: 0,
-            acertosMemoriaConteudo: 0,
-            origem: "plano_explicito",
-            diretoriosValidadosCache: 0,
-        });
+        return indicesVazios(planoEscopo, modoCache, avisosModoCache);
     }
-    const exigirCabecalhoCodigoGovernado = await workspaceExigeCabecalhoCodigoGovernado(contexto.baseProjeto, contexto.configCarregada?.config.modoEstrito === true);
-    const identidadeCache = criarIdentidadeCache(contexto, configuracaoEscopo, planoEscopo, exigirCabecalhoCodigoGovernado);
-    const cache = new CacheIncrementalDrift({
-        baseProjeto: contexto.baseProjeto,
-        politica: politicaCache,
-        identidade: identidadeCache,
-        observador: opcoes.observador,
-    });
-    const catalogo = await criarCatalogoPersistenteDrift({
+    const arquivosExplicitos = planoEscopo.estrategia === "arquivos_vinculados"
+        ? planoEscopo.arquivos
+        : coletarArquivosFisicosDeclarados(contexto);
+    const catalogo = await criarCatalogoDrift({
         baseDiretorio: contexto.baseProjeto,
-        arquivos: planoEscopo.estrategia === "arquivos_vinculados" ? planoEscopo.arquivos : [],
+        arquivos: arquivosExplicitos,
         raizes: planoEscopo.estrategia === "projeto" ? planoEscopo.diretorios : [],
         extensoes: EXTENSOES_ARQUIVOS_RASTREAVEIS_DRIFT,
-        diretoriosIgnorados: resolverDiretoriosIgnoradosAtivos({
-            escopo: configuracaoEscopo.escopo,
-            ignorarWorktrees: configuracaoEscopo.ignorarWorktrees,
-            ignorarConsumidoresLaterais: configuracaoEscopo.ignorarConsumidoresLaterais,
-        }),
+        diretoriosIgnorados: resolverDiretoriosIgnoradosAtivos(configuracaoEscopo),
         observador: opcoes.observador,
-    }, { politica: politicaCache, identidade: identidadeCache });
-    const fimCatalogacao = performance.now();
-    try {
-        planoEscopo = await expandirDependenciasPlanoDrift(contexto, planoEscopo, catalogo, cache);
-        if (planoEscopo.estrategia === "projeto") {
-            const arquivosTypeScript = catalogo.arquivosCatalogados()
-                .filter((arquivo) => EXTENSOES_TYPESCRIPT_DRIFT.has(path.extname(arquivo).toLowerCase()));
-            planoEscopo.dependencias = await mapearDependenciasCatalogadasDrift(contexto, catalogo, cache, arquivosTypeScript);
-        }
-        const fimDependencias = performance.now();
-        const membrosUnicos = catalogo.arquivosCatalogados()
-            .filter((arquivo) => {
-            const extensao = path.extname(arquivo).toLowerCase();
-            return EXTENSOES_ANALISE_DRIFT.has(extensao)
-                || EXTENSOES_DEPENDENCIA_TYPESCRIPT_DRIFT.has(extensao);
-        });
-        const estados = await mapearComLimite(membrosUnicos, 8, async (arquivo) => 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"),
-        }));
-        const arquivosTypeScript = membrosUnicos
-            .filter((arquivo) => EXTENSOES_TYPESCRIPT_DRIFT.has(path.extname(arquivo).toLowerCase()));
-        const perfis = await mapearComLimite(arquivosTypeScript, 8, async (arquivo) => cache.resolverArquivo({
-            arquivo,
-            analise: "agrupamento-semantico-ts-v1",
-            ler: () => catalogo.ler(arquivo),
-            extrair: (conteudo) => extrairPerfilAgrupamentoTypeScript(arquivo, conteudo.texto),
-            validar: perfilAgrupamentoTypeScriptValido,
-        }));
-        const perfisPorArquivo = new Map(perfis.map((perfil) => [
-            chaveCaminho(path.resolve(contexto.baseProjeto, perfil.caminho)),
-            perfil.valor,
-        ]));
-        const grupos = construirGruposIncrementais(catalogo.arquivosCatalogados(), planoEscopo.dependencias, perfisPorArquivo);
-        const estadoPorArquivo = new Map(estados.map((estado) => [chaveRelativa(estado.caminho), estado]));
-        const fimAssinaturas = performance.now();
-        const resultadosGrupos = await mapearComLimite(grupos, 8, async (grupo) => {
-            const membros = grupo.map((arquivo) => {
-                const estado = estadoPorArquivo.get(chaveRelativa(pathRelativo(contexto.baseProjeto, arquivo)));
-                if (!estado) {
-                    throw new Error(`estado_cache_arquivo_ausente:${arquivo}`);
-                }
-                return { caminho: arquivo, contentHash: estado.contentHash };
-            });
-            const catalogoGrupo = new CatalogoFiltradoDrift(catalogo, grupo);
-            return cache.resolverGrupo({
-                membros,
-                calcular: () => calcularIndices(planoEscopo.diretorios, catalogoGrupo, exigirCabecalhoCodigoGovernado),
-                validar: (valor) => (validarIndicesSerializaveis(valor)
-                    && indicesPermanecemNoCatalogo(valor, catalogoGrupo)),
-            });
-        });
-        await cache.finalizar();
-        const fimIndexacao = performance.now();
-        const serializaveis = mesclarIndices(resultadosGrupos.map((resultado) => resultado.valor), catalogo.arquivosCatalogados());
-        const metricasIncrementais = cache.metricas();
-        const origem = resultadosGrupos.length > 0
-            && resultadosGrupos.every((resultado) => resultado.origem === "cache")
-            ? "cache"
-            : "calculado";
-        return reconstruirIndices(serializaveis, planoEscopo, {
-            politica: politicaCache,
-            origem,
-            chave: cache.identidadeDigest,
-            incremental: metricasIncrementais,
-            fasesMs: {
-                planejamento: Number((fimPlanejamento - inicioTotal).toFixed(3)),
-                catalogacao: Number((fimCatalogacao - fimPlanejamento).toFixed(3)),
-                dependencias: Number((fimDependencias - fimCatalogacao).toFixed(3)),
-                assinaturas: Number((fimAssinaturas - fimDependencias).toFixed(3)),
-                indexacao: Number((fimIndexacao - fimAssinaturas).toFixed(3)),
-                total: Number((fimIndexacao - inicioTotal).toFixed(3)),
-            },
-        }, catalogo.metricas(), catalogo);
-    }
-    finally {
-        await cache.finalizar();
+    });
+    const arquivosPrioritarios = [...planoEscopo.arquivos];
+    planoEscopo = await expandirDependenciasPlanoDrift(contexto, planoEscopo, catalogo);
+    if (modoCache === "none") {
+        const [, extraidos] = await calcularIndices(planoEscopo.diretorios, catalogo);
+        return montarIndicesPreparados(extraidos, arquivosPrioritarios, planoEscopo, estadoCacheInicial(modoCache, "calculado", avisosModoCache), catalogo);
     }
+    return resolverIndicesComCache(contexto, configuracaoEscopo, planoEscopo, catalogo, arquivosPrioritarios, arquivosExplicitos, modoCache, avisosModoCache, opcoes.observador);
 }
 //# sourceMappingURL=drift.part13.js.map