@semacode/cli 2.3.0 → 3.0.0

package/dist/drift.part13.js

@@ -1,91 +1,669 @@
-// SEMA-GOVERNED: sema.governanca_ia_contexto
-// Descricao: prepara indices vivos para drift; consulte contratos/sema/governanca_ia_contexto.sema antes de editar.
-import { resolverDiretoriosCodigoEscopoReal } from "./drift.part02.js";
-import { indexarArquivosRastreaveis } from "./drift.part04.js";
+// 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 ts from "typescript";
+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 { 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";
-export async function prepararIndicesDrift(contexto, configuracaoEscopo) {
-    const diretoriosCodigoAtivos = resolverDiretoriosCodigoEscopoReal(contexto, configuracaoEscopo);
-    const indexTs = await indexarTypeScript(diretoriosCodigoAtivos);
-    const indexPy = await indexarPython(diretoriosCodigoAtivos);
-    const indexDart = await indexarDart(diretoriosCodigoAtivos);
-    const indexDotnet = await indexarDotnet(diretoriosCodigoAtivos);
-    const indexJava = await indexarJava(diretoriosCodigoAtivos);
-    const indexGo = await indexarGo(diretoriosCodigoAtivos);
-    const indexRust = await indexarRust(diretoriosCodigoAtivos);
-    const indexLua = await indexarLua(diretoriosCodigoAtivos);
-    const indexPhp = await indexarPhp(diretoriosCodigoAtivos);
-    const indexPersistencia = await indexarPersistenciaDeclarativa(diretoriosCodigoAtivos);
-    const detalhesPersistencia = await indexarPersistenciaDetalhada(diretoriosCodigoAtivos);
-    const indexCpp = await indexarCpp(diretoriosCodigoAtivos);
-    const arquivosRastreaveis = await indexarArquivosRastreaveis(diretoriosCodigoAtivos);
-    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 mapaImpl = new Map([
-        ...indexTs.simbolos.map((item) => [item.caminho, item]),
-        ...indexPy.simbolos.map((item) => [item.caminho, item]),
-        ...indexDart.simbolos.map((item) => [item.caminho, item]),
-        ...indexDotnet.simbolos.map((item) => [item.caminho, item]),
-        ...indexJava.simbolos.map((item) => [item.caminho, item]),
-        ...indexGo.simbolos.map((item) => [item.caminho, item]),
-        ...indexRust.simbolos.map((item) => [item.caminho, item]),
-        ...indexLua.simbolos.map((item) => [item.caminho, item]),
-        ...indexCpp.simbolos.map((item) => [item.caminho, item]),
-        ...indexPhp.simbolos.map((item) => [item.caminho, item]),
-    ]);
-    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 mapaRecursos = construirMapaRecursos(todosRecursos);
-    const todasRotasIndexadas = [
-        ...indexTs.rotas,
-        ...indexPy.rotas,
-        ...indexDart.rotas,
-        ...indexDotnet.rotas,
-        ...indexJava.rotas,
-        ...indexGo.rotas,
-        ...indexRust.rotas,
-        ...indexPhp.rotas,
-    ];
+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 {
+        modo,
+        origem,
+        schema: SCHEMA_ESTADO_CACHE_DRIFT,
+        metricas: {
+            hits: 0,
+            misses: 0,
+            corruptos: 0,
+            gravacoes: 0,
+            errosGravacao: 0,
+        },
+        avisos,
+    };
+}
+function indicesVazios(planoEscopo, modoCache, avisosModoCache) {
+    return {
+        detalhesPersistencia: { colunas: [], repositorios: [] },
+        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 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 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 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 {
+        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,
+    };
+}
+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([
-            ...arquivosRastreaveis,
+            ...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,
-        indexDart,
-        indexTs,
-        mapaImpl,
-        mapaRecursos,
+        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),
+        indexarDotnet(diretorios, catalogo),
+        indexarJava(diretorios, catalogo),
+        indexarGo(diretorios, catalogo),
+        indexarRust(diretorios, catalogo),
+        indexarLua(diretorios, catalogo),
+        indexarPhp(diretorios, catalogo),
+        indexarPersistenciaDeclarativa(diretorios, catalogo),
+        indexarPersistenciaDetalhada(diretorios, catalogo),
+        indexarCpp(diretorios, catalogo),
+    ]);
+    const extracoes = {
+        detalhesPersistencia,
+        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: [] },
+        },
+    };
+    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,
+    });
+}
+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);
+    }
+    for (const arquivo of [
+        ...arquivosExplicitos,
+        ...plano.arquivos,
+        ...plano.arquivosDeclarados,
+        ...plano.arquivosInferidos,
+        ...plano.arquivosAusentes,
+    ]) {
+        adicionarCandidato(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" };
+        }
+        return {
+            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 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 {
+        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,
+    };
+}
+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);
+    }
+    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;
+    };
+    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);
+            }
+        }
+    }
+    const [extracoes, extraidos] = await calcularIndices(planoEscopo.diretorios, catalogo);
+    try {
+        const payload = serializarIndicesCache(contexto.baseProjeto, extracoes);
+        await store.publicar(chave, payload, validarPayloadAplicavel);
+    }
+    catch {
+        // Cache é aceleração descartável; a extração recém-calculada continua autoritativa.
+    }
+    return montarIndicesPreparados(extraidos, arquivosPrioritarios, planoEscopo, estadoCacheDoStore(modoCache, "calculado", avisosModoCache, store), catalogo);
+}
+export async function prepararIndicesDrift(contexto, configuracaoEscopo, opcoes = {}) {
+    const modoCache = opcoes.modoCache ?? "none";
+    const avisosModoCache = opcoes.avisosModoCache ?? [];
+    let planoEscopo = await planejarEscopoDrift(contexto, configuracaoEscopo);
+    if (planoEscopo.bloqueios.length > 0) {
+        return indicesVazios(planoEscopo, modoCache, avisosModoCache);
+    }
+    const arquivosExplicitos = planoEscopo.estrategia === "arquivos_vinculados"
+        ? planoEscopo.arquivos
+        : coletarArquivosFisicosDeclarados(contexto);
+    const catalogo = await criarCatalogoDrift({
+        baseDiretorio: contexto.baseProjeto,
+        arquivos: arquivosExplicitos,
+        raizes: planoEscopo.estrategia === "projeto" ? planoEscopo.diretorios : [],
+        extensoes: EXTENSOES_ARQUIVOS_RASTREAVEIS_DRIFT,
+        diretoriosIgnorados: resolverDiretoriosIgnoradosAtivos(configuracaoEscopo),
+        observador: opcoes.observador,
+    });
+    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