@orkastery/cli 0.5.0 → 0.5.3

package/dist/intelligence-graph-contract.js

@@ -10,6 +10,7 @@ exports.derivarIds = derivarIds;
 exports.caminhoValido = caminhoValido;
 exports.validarGrafo = validarGrafo;
 exports.conferirFontes = conferirFontes;
+exports.conferirFontesDoGrafoValidado = conferirFontesDoGrafoValidado;
 /**
  * I-31 KG1 (D1 a D5, D9, D10): contrato `ork.code-artifact-graph/v1` do grafo deterministico
  * de codigo e artefatos.
@@ -134,19 +135,70 @@ function compararUtf8(a, b) {
     }
     return a.length - b.length;
 }
-/** D2: JSON canonico. Chaves na ordem de bytes UTF-8, sem espaco, so numero finito. */
+const FORMAS = new Map();
+const TETO_DE_FORMAS = 4096;
+let formasGuardadas = 0;
+function formaDe(chaves) {
+    const primeira = chaves.length ? chaves[0] : '', candidatas = FORMAS.get(primeira);
+    if (candidatas) {
+        for (const f of candidatas) {
+            if (f.chaves.length !== chaves.length)
+                continue;
+            let igual = true;
+            for (let i = 1; i < chaves.length && igual; i++)
+                igual = f.chaves[i] === chaves[i];
+            if (igual)
+                return f.ordem;
+        }
+    }
+    const ordem = [...chaves].sort(compararUtf8).map((k) => [k, `${JSON.stringify(k)}:`]);
+    if (formasGuardadas < TETO_DE_FORMAS) {
+        formasGuardadas++;
+        if (candidatas)
+            candidatas.push({ chaves: [...chaves], ordem });
+        else
+            FORMAS.set(primeira, [{ chaves: [...chaves], ordem }]);
+    }
+    return ordem;
+}
+/**
+ * D2: JSON canonico. Chaves na ordem de bytes UTF-8, sem espaco, so numero finito. KG4 (D6): mesma
+ * saida da forma original (`map` e `join`, com o buraco de array esparso vazio), sem ordenar as
+ * chaves a cada objeto; a ordem de visita, e com ela o primeiro erro, e a mesma.
+ */
 function canonico(v) {
-    if (v === null || typeof v === 'boolean' || typeof v === 'string')
-        return JSON.stringify(v);
-    if (typeof v === 'number')
-        return Number.isFinite(v) ? JSON.stringify(v) : falha('grafo.canonico.numero-invalido');
-    if (Array.isArray(v))
-        return `[${v.map(canonico).join(',')}]`;
-    if (typeof v === 'object') {
-        const o = v;
-        return `{${Object.keys(o).sort(compararUtf8).map((k) => `${JSON.stringify(k)}:${canonico(o[k])}`).join(',')}}`;
+    if (v === null)
+        return 'null';
+    switch (typeof v) {
+        case 'string':
+            return JSON.stringify(v);
+        case 'boolean':
+            return v ? 'true' : 'false';
+        case 'number':
+            return Number.isFinite(v) ? JSON.stringify(v) : falha('grafo.canonico.numero-invalido');
+        case 'object': {
+            if (Array.isArray(v)) {
+                let s = '[';
+                for (let i = 0; i < v.length; i++) {
+                    if (i > 0)
+                        s += ',';
+                    if (i in v)
+                        s += canonico(v[i]);
+                }
+                return `${s}]`;
+            }
+            const o = v, forma = formaDe(Object.keys(o));
+            let s = '{';
+            for (let i = 0; i < forma.length; i++) {
+                if (i > 0)
+                    s += ',';
+                s += forma[i][1] + canonico(o[forma[i][0]]);
+            }
+            return `${s}}`;
+        }
+        default:
+            return falha('grafo.canonico.tipo-invalido');
     }
-    return falha('grafo.canonico.tipo-invalido');
 }
 /** SHA-256 sobre os bytes UTF-8 do conteudo canonico. */
 const sha256DoCanonico = (v) => (0, node_crypto_1.createHash)('sha256').update(canonico(v), 'utf8').digest('hex');
@@ -508,7 +560,14 @@ function linhaDoByte(quebras, o) {
  * parser interpretou a relacao certo; essa prova vem da auditoria de arestas do benchmark.
  */
 function conferirFontes(entrada, fontes) {
-    const g = validarGrafo(entrada);
+    return conferirFontesDoGrafoValidado(validarGrafo(entrada), fontes);
+}
+/**
+ * RM-031 KG4 (D6): a conferencia de `conferirFontes` sobre o grafo que `validarGrafo` acabou de
+ * devolver, sem validar de novo. So para o produtor que tem esse retorno em maos (a construcao do
+ * indice, logo depois da extracao); qualquer outra entrada passa por `conferirFontes`.
+ */
+function conferirFontesDoGrafoValidado(g, fontes) {
     const manifesto = new Map(g.snapshot.source_manifest.map((m) => [m.path, m]));
     for (const [p, f] of fontes) {
         if (!manifesto.has(p))

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

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TETO_DE_LINHAS_DE_TABELA = exports.TOKENS_SEM_MENCAO = exports.CHAVES_DO_FRONTMATTER = exports.PADRAO_DE_ID = void 0;
 exports.slugDeTexto = slugDeTexto;
+exports.estruturarMarkdown = estruturarMarkdown;
 exports.extrairMarkdown = extrairMarkdown;
+exports.ligarMarkdown = ligarMarkdown;
 const yaml_1 = require("./yaml");
 /** D6: ID de artefato governado (`RM-031`, `FEAT-018`). */
 exports.PADRAO_DE_ID = /^[A-Z][A-Z0-9]*-[0-9]+$/;
@@ -329,7 +331,25 @@ const decodificar = (t) => {
         return null;
     }
 };
+function estruturarMarkdown(fonte, e) {
+    const s = estruturar(fonte, e.aceitaFragmento, e.analisar, e.referencia);
+    const mencoes = [];
+    for (const l of s.textoDeMencao)
+        for (const m of l.texto.matchAll(MENCAO))
+            mencoes.push({ inicio: l.inicio + m.index, id: m[0] });
+    const d = s.frontmatter?.dados;
+    return {
+        path: fonte.path, secoes: s.secoes, links: s.links, mencoes,
+        frontmatter: s.frontmatter && d
+            ? { id: typeof d.id === 'string' ? d.id : null, tipo: typeof d.tipo === 'string' && d.tipo !== '', valores: s.frontmatter.valores }
+            : null,
+        frontmatterInvalido: s.frontmatterInvalido, tabelaGrande: s.tabelaGrande,
+    };
+}
 function extrairMarkdown(e) {
+    return ligarMarkdown({ ...e, estruturas: e.fontes.map((f) => estruturarMarkdown(f, e)) });
+}
+function ligarMarkdown(e) {
     const saida = { nos: [], arestas: [], diagnosticos: [], lacunas: [] };
     const arquivos = new Set(e.arquivos), diretorios = new Set();
     for (const p of e.arquivos) {
@@ -337,8 +357,8 @@ function extrairMarkdown(e) {
         for (let i = 1; i < partes.length; i++)
             diretorios.add(partes.slice(0, i).join('/'));
     }
-    const estruturas = e.fontes.map((f) => estruturar(f, e.aceitaFragmento, e.analisar, e.referencia));
-    const slugs = new Map(estruturas.map((s) => [s.fonte.path, new Set(s.secoes.map((x) => x.slug).filter((x) => x !== null))]));
+    const estruturas = e.estruturas;
+    const slugs = new Map(estruturas.map((s) => [s.path, new Set(s.secoes.map((x) => x.slug).filter((x) => x !== null))]));
     const aresta = (kind, from, to, extrator, metodo, t) => {
         saida.arestas.push({ kind, from, to, extrator, metodo, trecho: t });
     };
@@ -349,17 +369,17 @@ function extrairMarkdown(e) {
     const donos = new Map();
     for (const s of estruturas) {
         if (s.frontmatterInvalido)
-            lacuna('frontmatter-invalido', s.fonte.path, 0, null);
+            lacuna('frontmatter-invalido', s.path, 0, null);
         if (s.tabelaGrande)
-            lacuna('markdown-tabela-grande', s.fonte.path, null, null);
-        const nome = s.fonte.path.slice(s.fonte.path.lastIndexOf('/') + 1), d = s.frontmatter?.dados;
-        if (!d || nome.startsWith('_') || typeof d.id !== 'string' || !exports.PADRAO_DE_ID.test(d.id) || typeof d.tipo !== 'string' || !d.tipo)
+            lacuna('markdown-tabela-grande', s.path, null, null);
+        const nome = s.path.slice(s.path.lastIndexOf('/') + 1), d = s.frontmatter;
+        if (!d || nome.startsWith('_') || d.id === null || !exports.PADRAO_DE_ID.test(d.id) || !d.tipo)
             continue;
         if (!e.aceitaFragmento(d.id)) {
-            lacuna('artefato-recusado', s.fonte.path, 0, null);
+            lacuna('artefato-recusado', s.path, 0, null);
             continue;
         }
-        donos.set(d.id, [...(donos.get(d.id) ?? []), s.fonte.path]);
+        donos.set(d.id, [...(donos.get(d.id) ?? []), s.path]);
     }
     const artefatos = new Map();
     for (const [id, caminhos] of donos) {
@@ -385,20 +405,15 @@ function extrairMarkdown(e) {
         const atual = baixo > 0 ? s.secoes[baixo - 1] : null;
         return atual && atual.slug !== null ? { kind: 'section', path: arquivo.path, fragment: atual.slug } : arquivo;
     };
-    const mencoes = (fonte, linhas, origem) => {
-        for (const l of linhas) {
-            for (const m of l.texto.matchAll(MENCAO)) {
-                const alvo = artefatos.get(m[0]), inicio = l.inicio + m.index;
-                if (!alvo) {
-                    lacuna('id-sem-artefato', fonte.path, inicio, m[0]);
-                    continue;
-                }
-                aresta('references', origem(inicio), alvo, e.extratorId, 'text-location', { path: fonte.path, inicio, fim: inicio + m[0].length });
-            }
-        }
+    const mencao = (path, inicio, id, origem) => {
+        const alvo = artefatos.get(id);
+        if (!alvo)
+            lacuna('id-sem-artefato', path, inicio, id);
+        else
+            aresta('references', origem(inicio), alvo, e.extratorId, 'text-location', { path, inicio, fim: inicio + id.length });
     };
     for (const s of estruturas) {
-        const path = s.fonte.path, arquivo = { kind: 'file', path, fragment: null };
+        const path = s.path, arquivo = { kind: 'file', path, fragment: null };
         for (const x of s.secoes) {
             if (x.slug === null) {
                 lacuna('secao-recusada', path, x.inicio, null);
@@ -444,7 +459,7 @@ function extrairMarkdown(e) {
                 continue;
             aresta('references', origem, { kind: 'file', path: alvo, fragment: null }, e.extratorMd, 'explicit-link', t);
         }
-        const artefato = s.frontmatter && typeof s.frontmatter.dados.id === 'string' ? artefatos.get(s.frontmatter.dados.id) : undefined;
+        const artefato = s.frontmatter && s.frontmatter.id !== null ? artefatos.get(s.frontmatter.id) : undefined;
         if (artefato && artefato.path === path && s.frontmatter) {
             for (const v of s.frontmatter.valores) {
                 const [kind, destino] = exports.CHAVES_DO_FRONTMATTER[v.chave].split(':');
@@ -459,11 +474,14 @@ function extrairMarkdown(e) {
                     lacuna('frontmatter-sem-alvo', path, v.inicio, `${v.chave}: ${v.valor}`);
             }
         }
-        mencoes(s.fonte, s.textoDeMencao, (o) => secaoEm(s, arquivo, o));
+        for (const m of s.mencoes)
+            mencao(path, m.inicio, m.id, (o) => secaoEm(s, arquivo, o));
     }
     for (const f of e.codigo) {
         const arquivo = { kind: 'file', path: f.path, fragment: null };
-        mencoes(f, linhasDe(f.texto), () => arquivo);
+        for (const l of linhasDe(f.texto))
+            for (const m of l.texto.matchAll(MENCAO))
+                mencao(f.path, l.inicio + m.index, m[0], () => arquivo);
     }
     return saida;
 }

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;
 }