@orkastery/cli 0.5.0 → 0.5.1

package/dist/intelligence-graph-extract-ts.js

@@ -1,7 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OPCOES_TS_DESCRITAS = void 0;
+exports.casaSonda = casaSonda;
 exports.extrairTypeScript = extrairTypeScript;
+/** Extensoes que o extrator TS le; as do `extensaoDe` do KG2. */
+const EXTENSOES_DO_PROGRAMA = ['.cjs', '.cts', '.js', '.jsx', '.mjs', '.mts', '.ts', '.tsx'];
+const DECLARACOES_TS = ['.d.ts', '.d.mts', '.d.cts'];
+/** A base sem a extensao (o TypeScript troca `.js` por `.ts`, e `.d.ts` conta inteira). */
+function semExtensao(base) {
+    const nome = base.slice(base.lastIndexOf('/') + 1);
+    for (const d of DECLARACOES_TS)
+        if (nome.endsWith(d) && nome.length > d.length)
+            return base.slice(0, -d.length);
+    const i = nome.lastIndexOf('.');
+    return i <= 0 ? base : base.slice(0, base.length - (nome.length - i));
+}
+/**
+ * RM-031 KG4 (D3): o caminho `p`, novo ou removido, pode mudar uma resolucao de base `base`? O
+ * TypeScript e o Node so tentam a base exata, a base com extensao, a base como pasta (`index`,
+ * `package.json`) e o mesmo sem a extensao; base vazia (a raiz) casa tudo.
+ */
+function casaSonda(base, p) {
+    if (base === '')
+        return true;
+    if (p === base || p.startsWith(`${base}.`) || p.startsWith(`${base}/`))
+        return true;
+    const sem = semExtensao(base);
+    return sem !== base && (p === sem || p.startsWith(`${sem}.`) || p.startsWith(`${sem}/`));
+}
 /** D2: opcoes fixas do compilador, descritas por nome para entrar no `config_hash`. */
 exports.OPCOES_TS_DESCRITAS = Object.freeze({
     allowJs: true, checkJs: false, esModuleInterop: true, jsx: 'preserve', module: 'commonjs', moduleResolution: 'node10',
@@ -68,7 +94,12 @@ function caminhoLiteral(de, especificador) {
     }
     return r.join('/');
 }
-function criarHost(ts, e) {
+/**
+ * RM-031 KG4 (D3): modulo vazio fora da raiz virtual (nenhum caminho do manifesto o nomeia, e nada o
+ * resolve), so para ler o escopo global do checker sem local que esconda global de mesmo nome.
+ */
+const TEXTO_DO_SINTETICO = 'export {};\n';
+function criarHost(ts, e, sintetico) {
     const arquivos = new Set(e.arquivos), dirs = new Set([e.raiz]);
     for (const p of e.arquivos) {
         const partes = p.split('/');
@@ -83,6 +114,8 @@ function criarHost(ts, e) {
     };
     return {
         getSourceFile: (nome, alvo) => {
+            if (nome === sintetico)
+                return ts.createSourceFile(nome, TEXTO_DO_SINTETICO, alvo, true);
             const p = dentro(nome), t = p === null ? undefined : e.texto(p);
             return t === undefined ? undefined : ts.createSourceFile(nome, t, alvo, true);
         },
@@ -109,13 +142,14 @@ function criarHost(ts, e) {
     };
 }
 function extrairTypeScript(e, ts) {
-    const saida = { nos: [], arestas: [], diagnosticos: [], lacunas: [] };
+    const resultado = { unidades: new Map(), globais: [], faltantes: [] };
     if (e.fontes.length === 0)
-        return saida;
+        return resultado;
     const absoluto = (p) => `${e.raiz}/${p}`;
     const relativo = (p) => (p.startsWith(`${e.raiz}/`) ? p.slice(e.raiz.length + 1) : null);
-    const host = criarHost(ts, e), opts = opcoes(ts);
-    const programa = ts.createProgram(e.fontes.map((f) => absoluto(f.path)), opts, host);
+    const sintetico = `${e.raiz}-escopo-global.ts`;
+    const host = criarHost(ts, e, sintetico), opts = opcoes(ts);
+    const programa = ts.createProgram([...e.fontes.map((f) => absoluto(f.path)), sintetico], opts, host);
     const checker = programa.getTypeChecker();
     const cache = ts.createModuleResolutionCache(e.raiz, (p) => p, opts);
     const arquivos = new Set(e.arquivos);
@@ -473,41 +507,117 @@ function extrairTypeScript(e, ts) {
      * lanca erro). Especificador nao relativo vai a node_modules e fica sem alvo. Em ESM o especificador e
      * URL: so liga o que a URL le como o caminho literal (`urlComoCaminho`).
      */
+    /** KG4 (D3): `bruto` e o caminho que a resolucao do Node achou, antes de conferir se ele carrega. */
     function alvoNoNode(de, chave) {
         const esp = especificadorDaChave(chave), formato = formatoDe(de);
         const relativoAoArquivo = esp === '.' || esp === '..' || esp.startsWith('./') || esp.startsWith('../');
         if (!relativoAoArquivo || formato === 'falha')
-            return null;
+            return { alvo: null, bruto: null };
         let alvo;
         if (chave[0] === 'd' || (chave[0] === 'v' && formato === 'esm'))
             alvo = urlComoCaminho(esp) ? resolverNode(de, esp, true) : null;
         else if (chave[0] === 'r' && formato === 'cjs' && !escopoDe(de).invalido)
             alvo = resolverNode(de, esp, false);
         else
-            return null;
-        return alvo !== null && carregavel(alvo, chave[0] !== 'r') ? alvo : null;
+            return { alvo: null, bruto: null };
+        return { alvo: alvo !== null && carregavel(alvo, chave[0] !== 'r') ? alvo : null, bruto: alvo };
     }
+    /**
+     * KG4 (D3): os nomes de modulo que o TypeScript coleta do arquivo para o programa (import, export,
+     * require, import(), tipo importado, inclusive no JSDoc de JavaScript). Sem a lista, nao ha como provar
+     * as dependencias e a extracao falha, em vez de reaproveitar sem prova.
+     */
+    const nomesDeModulo = (sf) => {
+        const imports = sf.imports;
+        if (!Array.isArray(imports))
+            throw new Error('extracao.interna.typescript-sem-imports');
+        return imports.map((n) => n.text);
+    };
+    /** Caminho relativo a raiz por segmentos; `null` se sobe acima da raiz. */
+    const normalizar = (partes) => {
+        const r = [];
+        for (const p of partes) {
+            if (p === '' || p === '.')
+                continue;
+            if (p === '..') {
+                if (!r.length)
+                    return null;
+                r.pop();
+            }
+            else
+                r.push(p);
+        }
+        return r.join('/');
+    };
+    /** KG4 (D3): base de uma resolucao relativa como o TypeScript a ve (a barra invertida tambem separa); `null` se nao e relativa ou sai da raiz. */
+    const baseDaSonda = (de, nome) => (/^\.\.?($|[\\/])/.test(nome) ? normalizar([...de.split('/').slice(0, -1), ...nome.replace(/\\/g, '/').split('/')]) : null);
+    /** `/// <reference path>`: relativo ao arquivo, com ou sem `./`. */
+    const baseDaReferencia = (de, nome) => (nome.startsWith('/') || nome.startsWith('\\') ? null : normalizar([...de.split('/').slice(0, -1), ...nome.replace(/\\/g, '/').split('/')]));
+    /**
+     * KG4 (D3): a resolucao de uma pasta le o `package.json` dela, e `main`, `types` e `typings` podem
+     * apontar para fora da base: os alvos entram como sondas, tambem com a barra invertida trocada, como o
+     * TypeScript le. `typesVersions` remapeia qualquer caminho, e entao a sonda casa tudo; o mesmo vale
+     * para `package.json` que nao e JSON estrito (CHECK, A1: o TypeScript aceita comentario e virgula
+     * final). Mudanca no proprio `package.json` extrai o TypeScript inteiro.
+     */
+    const sondasDoPacote = (base, sondas) => {
+        for (const pasta of new Set([base, semExtensao(base)])) {
+            const arquivo = junta(pasta, 'package.json');
+            if (!arquivos.has(arquivo))
+                continue;
+            const v = lerJson(arquivo);
+            if (v === null || typeof v !== 'object' || Array.isArray(v)) {
+                sondas.add('');
+                continue;
+            }
+            const o = v;
+            if ('typesVersions' in o)
+                sondas.add('');
+            for (const campo of ['main', 'types', 'typings']) {
+                const alvo = o[campo];
+                if (typeof alvo !== 'string' || !alvo)
+                    continue;
+                for (const forma of new Set([alvo, alvo.replace(/\\/g, '/')])) {
+                    const t = forma.startsWith('/') ? null : caminhoLiteral(arquivo, `./${forma}`);
+                    if (t !== null)
+                        sondas.add(t);
+                }
+            }
+        }
+    };
+    const sondar = (base, sondas) => {
+        if (base === null)
+            return;
+        sondas.add(base);
+        sondasDoPacote(base, sondas);
+    };
     // Primeira passada, em todos os arquivos: o alvo de cada especificador para o compilador e para o
     // runtime. Onde divergem, a aresta de import vai ao que roda e nenhum simbolo passa por ali (D3).
     const resolucoes = new Map();
     const divergentesGlobais = new Set();
+    // KG4 (D3): por fonte, os caminhos a que as referencias de modulo resolvem e as bases das relativas.
+    const dependenciasDe = new Map(), sondasDe = new Map();
     for (const fonte of e.fontes) {
         const sf = programa.getSourceFile(absoluto(fonte.path));
         if (!sf || sf.fileName !== absoluto(fonte.path))
             continue;
         const ext = extensao(fonte.path), mapa = new Map();
+        const dependencias = new Set(), sondas = new Set();
         for (const chave of especificadoresEm(sf)) {
             if (mapa.has(chave))
                 continue;
             const esp = especificadorDaChave(chave), doCompilador = resolver(esp, fonte.path);
+            sondar(baseDaSonda(fonte.path, esp), sondas);
             let alvo = doCompilador, divergente = false;
             // Import so de tipo nao roda: vale o que o compilador liga. Fonte JavaScript roda no Node, e onde
             // o Node falha (formato, escopo, alvo que nao carrega) nao ha aresta.
             if (chave[0] !== 't' && EXTENSOES_JS.includes(ext)) {
                 const runtime = alvoNoNode(fonte.path, chave);
-                if (runtime !== doCompilador) {
+                if (runtime.bruto !== null)
+                    dependencias.add(runtime.bruto);
+                if (runtime.alvo !== doCompilador) {
                     divergente = true;
-                    alvo = runtime;
+                    alvo = runtime.alvo;
                 }
             }
             const impl = chave[0] !== 't' && !divergente && doCompilador !== null ? implementacaoDe(doCompilador) : null;
@@ -515,11 +625,45 @@ function extrairTypeScript(e, ts) {
                 divergente = true;
                 alvo = impl;
             }
+            for (const x of [doCompilador, alvo])
+                if (x !== null)
+                    dependencias.add(x);
             mapa.set(chave, { alvo, divergente, doCompilador });
             if (divergente)
                 divergentesGlobais.add(`${fonte.path}\u0000${chave}`);
         }
+        // O que o TypeScript coleta e a varredura nao ve (tipo importado no JSDoc) tambem liga o checker a outro arquivo.
+        for (const nome of nomesDeModulo(sf)) {
+            sondar(baseDaSonda(fonte.path, nome), sondas);
+            const alvo = resolver(nome, fonte.path);
+            if (alvo !== null)
+                dependencias.add(alvo);
+        }
+        for (const r of sf.referencedFiles) {
+            const base = baseDaReferencia(fonte.path, r.fileName);
+            if (base === null)
+                continue;
+            sondas.add(base);
+            for (const x of [base, `${base}.ts`, `${base}.tsx`, `${base}.d.ts`, `${base}.js`, `${base}.jsx`])
+                if (arquivos.has(x))
+                    dependencias.add(x);
+        }
         resolucoes.set(fonte.path, mapa);
+        dependenciasDe.set(fonte.path, dependencias);
+        sondasDe.set(fonte.path, sondas);
+    }
+    // KG4 (D3): no programa parcial, todo alvo TS/JS das fontes precisa ser fonte, para ter formato e
+    // resolucoes; senao o caminho cresce e a extracao recomeca.
+    if (e.emitir) {
+        const noPrograma = new Set(e.fontes.map((f) => f.path)), faltantes = new Set();
+        for (const dependencias of dependenciasDe.values()) {
+            for (const d of dependencias) {
+                if (!noPrograma.has(d) && EXTENSOES_DO_PROGRAMA.includes(extensao(d)) && e.texto(d) !== undefined)
+                    faltantes.add(d);
+            }
+        }
+        if (faltantes.size)
+            return { ...resultado, faltantes: [...faltantes].sort() };
     }
     // B-N2: modulo que importa, direto ou por outro modulo, um arquivo com import divergente pode reexportar
     // o que o compilador liga e o runtime nao (`export *`, `module.exports = require(...)`). O fecho segue
@@ -577,6 +721,13 @@ function extrairTypeScript(e, ts) {
         return false;
     }
     for (const fonte of e.fontes) {
+        if (e.emitir && !e.emitir.has(fonte.path))
+            continue;
+        // KG4 (D2): os achados ficam por arquivo, com as dependencias e as sondas, para as unidades do indice.
+        const saida = { nos: [], arestas: [], diagnosticos: [], lacunas: [] };
+        resultado.unidades.set(fonte.path, {
+            dependencias: [...(dependenciasDe.get(fonte.path) ?? [])].sort(), sondas: [...(sondasDe.get(fonte.path) ?? [])].sort(), achados: saida,
+        });
         const sf = programa.getSourceFile(absoluto(fonte.path));
         // Fonte que o compilador trocou por outra (pacote duplicado) nao e lida: o no seria do outro arquivo.
         if (!sf || sf.fileName !== absoluto(fonte.path)) {
@@ -806,5 +957,24 @@ function extrairTypeScript(e, ts) {
         for (const st of sf.statements)
             visitar(st, null);
     }
-    return saida;
+    // KG4 (D3): quem declara no escopo global (visto de um modulo vazio, sem local que o esconda) ou
+    // aumenta modulo alcanca arquivo que nao o importa; mudanca nele reextrai o TypeScript inteiro.
+    const doEscopoGlobal = programa.getSourceFile(sintetico);
+    if (!doEscopoGlobal)
+        throw new Error('extracao.interna.escopo-global');
+    const globais = new Set();
+    for (const simbolo of checker.getSymbolsInScope(doEscopoGlobal, -1)) {
+        for (const d of simbolo.declarations ?? []) {
+            const p = relativo(d.getSourceFile().fileName);
+            if (p !== null)
+                globais.add(p);
+        }
+    }
+    for (const sf of programa.getSourceFiles()) {
+        const aumentos = sf.moduleAugmentations, p = relativo(sf.fileName);
+        if (p !== null && aumentos && aumentos.length)
+            globais.add(p);
+    }
+    resultado.globais = [...globais].sort();
+    return resultado;
 }

package/dist/intelligence-graph-extract.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.textoAceito = exports.LACUNAS_SO_CONTAGEM = exports.EXTENSOES_MD = exports.EXTENSOES_TS = exports.CONFIG_SCHEMA = exports.RELATORIO_SCHEMA = exports.VERSAO_KG2 = exports.EXTRATOR_ARQUIVOS = exports.EXTRATOR_ID = exports.EXTRATOR_MD = exports.EXTRATOR_TS = void 0;
+exports.textoAceito = exports.UNIDADES_SCHEMA = exports.LACUNAS_SO_CONTAGEM = exports.EXTENSOES_MD = exports.EXTENSOES_TS = exports.CONFIG_SCHEMA = exports.RELATORIO_SCHEMA = exports.VERSAO_KG2 = exports.EXTRATOR_ARQUIVOS = exports.EXTRATOR_ID = exports.EXTRATOR_MD = exports.EXTRATOR_TS = void 0;
 exports.textoCurto = textoCurto;
 exports.extensaoDe = extensaoDe;
 exports.idDeBlob = idDeBlob;
@@ -34,6 +34,8 @@ exports.LACUNAS_SO_CONTAGEM = new Set([
     'chamada-fora-de-simbolo', 'chamada-nao-resolvida', 'chamada-alvo-fora-do-grafo', 'chamada-por-tipo', 'import-sem-simbolo',
     'id-sem-artefato', 'link-externo',
 ]);
+/** RM-031 KG4 (D2): as unidades por arquivo que o indice guarda para a proxima revisao reaproveitar. */
+exports.UNIDADES_SCHEMA = 'ork.graph-extraction-units/v0';
 function falha(codigo, onde) {
     throw new Error(onde ? `${codigo} em ${onde}` : codigo);
 }
@@ -136,11 +138,144 @@ const zeros = '0'.repeat(64);
 function contagemVazia(chaves) {
     return Object.fromEntries(chaves.map((k) => [k, 0]));
 }
+/**
+ * A mudanca e por conteudo: o hash de cada caminho contra o da base, mais os novos e os removidos
+ * (renome e os dois). No TypeScript, semente e o arquivo mudado ou novo e o nao mudado cuja sonda casa
+ * caminho novo ou removido; afetado e a semente e quem alcanca semente ou caminho mudado pelas
+ * dependencias gravadas na base. `package.json` ou arquivo global na mudanca extrai o TypeScript inteiro.
+ */
+function planejarReuso(base, manifesto, fontesTs, fontesMd) {
+    const porCaminho = new Map(base.arquivos.map((u) => [u.path, u]));
+    const alterados = [], novos = [], removidos = [];
+    for (const [p, m] of manifesto) {
+        const u = porCaminho.get(p);
+        if (!u)
+            novos.push(p);
+        else if (u.source_hash !== m.source_hash)
+            alterados.push(p);
+    }
+    for (const p of porCaminho.keys())
+        if (!manifesto.has(p))
+            removidos.push(p);
+    for (const l of [alterados, novos, removidos])
+        l.sort(intelligence_graph_contract_1.compararUtf8);
+    const mudados = new Set([...alterados, ...novos, ...removidos]);
+    const md = new Map();
+    for (const f of fontesMd) {
+        const u = porCaminho.get(f.path);
+        if (u?.md && !mudados.has(f.path))
+            md.set(f.path, u.md);
+    }
+    const plano = { base, porCaminho, mudanca: { alterados, novos, removidos }, md, ts: { motivo: null, sementes: new Set(), afetados: new Set() } };
+    const ordenados = [...mudados].sort(intelligence_graph_contract_1.compararUtf8), globais = new Set(base.globais_ts), ts1 = new Set(fontesTs.map((f) => f.path));
+    const pacote = ordenados.find((p) => p === 'package.json' || p.endsWith('/package.json'));
+    const global = ordenados.find((p) => globais.has(p));
+    const semUnidade = fontesTs.find((f) => !mudados.has(f.path) && !porCaminho.get(f.path)?.ts);
+    if (pacote !== undefined)
+        plano.ts.motivo = `package.json na mudanca (${pacote})`;
+    else if (global !== undefined)
+        plano.ts.motivo = `arquivo global do TypeScript na mudanca (${global})`;
+    else if (semUnidade !== undefined)
+        plano.ts.motivo = `base sem a unidade TypeScript de ${semUnidade.path}`;
+    if (plano.ts.motivo !== null)
+        return plano;
+    const existencia = [...novos, ...removidos];
+    for (const p of ts1) {
+        if (mudados.has(p))
+            plano.ts.sementes.add(p);
+        else if (existencia.length && (porCaminho.get(p)?.ts).sondas.some((b) => existencia.some((q) => (0, intelligence_graph_extract_ts_1.casaSonda)(b, q))))
+            plano.ts.sementes.add(p);
+    }
+    const dependentes = new Map();
+    for (const u of base.arquivos) {
+        for (const d of u.ts?.dependencias ?? []) {
+            const lista = dependentes.get(d);
+            if (lista)
+                lista.push(u.path);
+            else
+                dependentes.set(d, [u.path]);
+        }
+    }
+    const vistos = new Set(), fila = [...plano.ts.sementes, ...mudados];
+    while (fila.length) {
+        const q = fila.pop();
+        if (vistos.has(q))
+            continue;
+        vistos.add(q);
+        for (const x of dependentes.get(q) ?? [])
+            if (!vistos.has(x))
+                fila.push(x);
+    }
+    // CHECK (B1): quem usa um global nao importa o arquivo dele, e o global depende do que esse arquivo
+    // importa (heranca, tipo importado, `export *` atras de UMD, aumento que estende tipo de outro modulo).
+    const globalAlcancado = [...globais].sort(intelligence_graph_contract_1.compararUtf8).find((g) => vistos.has(g));
+    if (globalAlcancado !== undefined) {
+        plano.ts.motivo = `dependencia de arquivo global na mudanca (${globalAlcancado})`;
+        return plano;
+    }
+    for (const p of vistos)
+        if (ts1.has(p))
+            plano.ts.afetados.add(p);
+    return plano;
+}
+/**
+ * KG4 (D3): extrai os afetados num programa parcial: eles, os globais e o fecho direto pelas
+ * dependencias da base (a semente descobre as suas no programa, que cresce ate fechar). O resto vem
+ * da base. Afetado que passa a declarar global devolve o motivo, e o TypeScript sai inteiro.
+ */
+function extrairTsParcial(plano, entrada, extrair) {
+    const { afetados, sementes } = plano.ts, ts1 = new Set(entrada.fontes.map((f) => f.path));
+    const daBase = (p) => plano.porCaminho.get(p)?.ts;
+    const unidades = new Map(), globais = [...plano.base.globais_ts];
+    const raizes = new Set();
+    const incluir = (inicio) => {
+        const fila = [...inicio];
+        while (fila.length) {
+            const p = fila.pop();
+            if (raizes.has(p) || !ts1.has(p))
+                continue;
+            raizes.add(p);
+            if (!sementes.has(p))
+                for (const d of daBase(p).dependencias)
+                    if (!raizes.has(d))
+                        fila.push(d);
+        }
+    };
+    let r = null;
+    if (afetados.size) {
+        incluir([...afetados, ...globais]);
+        for (;;) {
+            r = extrair({ ...entrada, fontes: entrada.fontes.filter((f) => raizes.has(f.path)), emitir: afetados });
+            if (!r.faltantes.length)
+                break;
+            const antes = raizes.size;
+            incluir(r.faltantes);
+            if (raizes.size === antes)
+                falha('extracao.interna.programa-parcial');
+        }
+        const daBaseGlobal = new Set(globais), doPrograma = new Set(r.globais);
+        const novo = r.globais.find((g) => !daBaseGlobal.has(g));
+        if (novo !== undefined)
+            return { motivo: `arquivo passa a declarar global no TypeScript (${novo})`, unidades, globais, programa: raizes.size };
+        const sumiu = globais.find((g) => ts1.has(g) && !doPrograma.has(g));
+        if (sumiu !== undefined)
+            return { motivo: `global da base fora do escopo global (${sumiu})`, unidades, globais, programa: raizes.size };
+    }
+    for (const f of entrada.fontes) {
+        const u = afetados.has(f.path) ? r?.unidades.get(f.path) : daBase(f.path);
+        if (!u)
+            falha('extracao.interna.unidade-ts-ausente');
+        unidades.set(f.path, u);
+    }
+    return { motivo: null, unidades, globais, programa: raizes.size };
+}
 /**
  * Extrai o grafo das fontes fornecidas. Lanca `extracao.*` para entrada invalida ou teto do
  * contrato estourado (D10), e `grafo.*` se o resultado violar o contrato (defeito do extrator).
+ * RM-031 KG4: com `base` (as unidades do indice de outra revisao, do mesmo extrator), reextrai so o
+ * que a mudanca alcanca; o resultado e o mesmo, byte a byte, da extracao sem base.
  */
-function extrairGrafo(entrada, parser) {
+function extrairGrafo(entrada, parser, base = null) {
     const { ts, unicode, markdown, javascript } = parser;
     if (!/^[0-9]+(\.[0-9]+)*$/.test(unicode))
         falha('extracao.entrada.unicode-invalido');
@@ -224,18 +359,40 @@ function extrairGrafo(entrada, parser) {
     // B1: a raiz virtual do compilador deriva do manifesto; um caminho do repositorio nao a nomeia.
     const raiz = `/ork-${(0, intelligence_graph_contract_1.sha256DoCanonico)([...manifesto.values()].map((m) => [m.path, m.source_hash])).slice(0, 32)}`;
     const aceitaFragmento = (f) => f.length >= 1 && f.length <= intelligence_graph_contract_1.GRAFO_LIMITES.fragmento && (0, exports.textoAceito)(f);
-    juntar(semEstouro(exports.EXTRATOR_TS, () => (0, intelligence_graph_extract_ts_1.extrairTypeScript)({
-        fontes: fontesTs, arquivos: caminhos, texto, raiz, aceitaFragmento, sintaxe: javascript.sintaxe, extrator: exports.EXTRATOR_TS,
-    }, ts)));
+    const entradaTs = { fontes: fontesTs, arquivos: caminhos, texto, raiz, aceitaFragmento, sintaxe: javascript.sintaxe, extrator: exports.EXTRATOR_TS };
+    const extrairTs = (e) => semEstouro(exports.EXTRATOR_TS, () => (0, intelligence_graph_extract_ts_1.extrairTypeScript)(e, ts));
+    // KG4 (D1, D3, D4): com as unidades de uma base, so o que a mudanca alcanca e extraido de novo.
+    const plano = base ? planejarReuso(base, manifesto, fontesTs, fontesMd) : null;
+    let tsDaBase = null;
+    if (plano && plano.ts.motivo === null)
+        tsDaBase = extrairTsParcial(plano, entradaTs, extrairTs);
+    const motivoTs = plano ? plano.ts.motivo ?? tsDaBase?.motivo ?? null : null;
+    let unidadesTs, globaisTs;
+    if (tsDaBase && tsDaBase.motivo === null) {
+        unidadesTs = tsDaBase.unidades;
+        globaisTs = tsDaBase.globais;
+    }
+    else {
+        const r = extrairTs(entradaTs);
+        unidadesTs = r.unidades;
+        globaisTs = r.globais;
+    }
+    for (const f of fontesTs) {
+        const u = unidadesTs.get(f.path);
+        if (!u)
+            falha('extracao.interna.unidade-ts-ausente');
+        juntar(u.achados);
+    }
     // B4: chave `caminho#fragmento` como o frontmatter a escreve; duas refs na mesma chave ficam ambiguas.
     const simbolos = new Map();
     for (const r of achados.nos.filter((x) => x.kind === 'symbol')) {
         const chave = `${r.path}#${r.fragment}`, antes = simbolos.get(chave);
         simbolos.set(chave, antes === undefined || (antes && antes.path === r.path && antes.fragment === r.fragment) ? r : null);
     }
-    juntar(semEstouro(exports.EXTRATOR_MD, () => (0, intelligence_graph_extract_md_1.extrairMarkdown)({
-        fontes: fontesMd, codigo: fontesTs, arquivos: caminhos, simbolos, aceitaFragmento, analisar: markdown.analisar,
-        referencia: markdown.referencia, extratorMd: exports.EXTRATOR_MD, extratorId: exports.EXTRATOR_ID,
+    const estruturas = semEstouro(exports.EXTRATOR_MD, () => fontesMd.map((f) => plano?.md.get(f.path)
+        ?? (0, intelligence_graph_extract_md_1.estruturarMarkdown)(f, { aceitaFragmento, analisar: markdown.analisar, referencia: markdown.referencia })));
+    juntar(semEstouro(exports.EXTRATOR_MD, () => (0, intelligence_graph_extract_md_1.ligarMarkdown)({
+        estruturas, codigo: fontesTs, arquivos: caminhos, simbolos, aceitaFragmento, extratorMd: exports.EXTRATOR_MD, extratorId: exports.EXTRATOR_ID,
     })));
     const extratores = [
         { extractor_id: exports.EXTRATOR_ARQUIVOS, extractor_version: exports.VERSAO_KG2 },
@@ -365,5 +522,25 @@ function extrairGrafo(entrada, parser) {
         lacunas_por_categoria: Object.fromEntries([...porCategoria.entries()].sort((a, b) => (0, intelligence_graph_contract_1.compararUtf8)(a[0], b[0]))),
         lacunas: [...listadas.entries()].sort((a, b) => (0, intelligence_graph_contract_1.compararUtf8)(a[0], b[0])).map(([, l]) => l),
     };
-    return { grafo, digest, relatorio };
+    const estruturaDe = new Map(estruturas.map((x) => [x.path, x]));
+    const unidades = {
+        schema: exports.UNIDADES_SCHEMA, snapshot_id: grafo.snapshot.snapshot_id, graph_digest: digest, globais_ts: globaisTs,
+        arquivos: grafo.snapshot.source_manifest.map((m) => ({
+            path: m.path, source_hash: m.source_hash, ts: unidadesTs.get(m.path) ?? null, md: estruturaDe.get(m.path) ?? null,
+        })),
+    };
+    let reaproveitamento = null;
+    if (plano) {
+        const parcial = motivoTs === null, afetados = [...plano.ts.afetados].sort(intelligence_graph_contract_1.compararUtf8);
+        reaproveitamento = {
+            mudanca: { alterados: plano.mudanca.alterados.length, novos: plano.mudanca.novos.length, removidos: plano.mudanca.removidos.length },
+            ts: {
+                modo: !parcial ? 'inteiro' : afetados.length ? 'parcial' : 'reaproveitado', motivo: motivoTs,
+                reextraidos: parcial ? afetados : fontesTs.map((f) => f.path), programa: parcial ? tsDaBase?.programa ?? 0 : fontesTs.length,
+                reaproveitados: parcial ? fontesTs.length - afetados.length : 0,
+            },
+            md: { reextraidos: fontesMd.filter((f) => !plano.md.has(f.path)).map((f) => f.path), reaproveitados: plano.md.size },
+        };
+    }
+    return { grafo, digest, relatorio, unidades, reaproveitamento };
 }