@orkastery/cli 0.4.3 → 0.5.1

package/dist/intelligence-graph-extract.js

@@ -0,0 +1,546 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+exports.decodificarUtf8 = decodificarUtf8;
+exports.extrairGrafo = extrairGrafo;
+/**
+ * RM-031 KG2 (D1, D7 a D10): extracao deterministica do grafo `ork.code-artifact-graph/v1`.
+ *
+ * Modulo puro: recebe os bytes das fontes e o compilador TypeScript por parametro (D1), sem abrir
+ * arquivo, rede ou processo. As fontes sao ordenadas antes de tudo e os IDs saem do contrato
+ * (`derivarIds`), entao a ordem de leitura nao muda o grafo nem o relatorio. O que nenhum extrator
+ * prova vira diagnostico do contrato ou lacuna do relatorio (D7), nunca aresta nem no fabricado.
+ */
+const node_crypto_1 = require("node:crypto");
+const intelligence_graph_contract_1 = require("./intelligence-graph-contract");
+const intelligence_graph_extract_md_1 = require("./intelligence-graph-extract-md");
+const intelligence_graph_extract_ts_1 = require("./intelligence-graph-extract-ts");
+exports.EXTRATOR_TS = 'ork.ts-ast';
+exports.EXTRATOR_MD = 'ork.md-structure';
+exports.EXTRATOR_ID = 'ork.id-mention';
+/** D9: declara o arquivo do manifesto que nenhum extrator leu. */
+exports.EXTRATOR_ARQUIVOS = 'ork.repo-files';
+/** Versao da regra de extracao; a do compilador entra no `extractor_version` do `ork.ts-ast`. */
+exports.VERSAO_KG2 = '1.0.0';
+exports.RELATORIO_SCHEMA = 'ork.graph-extraction-report/v0';
+exports.CONFIG_SCHEMA = 'ork.graph-extraction-config/v0';
+exports.EXTENSOES_TS = ['.cjs', '.cts', '.js', '.jsx', '.mjs', '.mts', '.ts', '.tsx'];
+exports.EXTENSOES_MD = ['.markdown', '.md'];
+/** D7: categorias de lacuna volumosas saem so na contagem; as demais saem tambem listadas. */
+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);
+}
+/**
+ * Aninhamento extremo estoura a pilha do compilador ou do analisador (o binder do TypeScript e
+ * recursivo): a extracao falha inteira com erro tipado, nunca com grafo parcial (D10).
+ */
+function semEstouro(extrator, f) {
+    try {
+        return f();
+    }
+    catch (e) {
+        if (e instanceof RangeError && /call stack/i.test(e.message))
+            falha('extracao.limite.pilha', extrator);
+        throw e;
+    }
+}
+/**
+ * Replica da regra de texto do contrato (controles, marcas invisiveis, surrogate isolado), para o
+ * produtor descartar referencia que o contrato recusaria. O corpus do KG1 e a autoridade.
+ */
+const CONTROLE = /[\u0000-\u001f\u007f-\u009f\u00ad\u061c\u180e\u200b\u200e\u200f\u2028\u2029\u202a-\u202e\u2060-\u206f\ufeff\ufff9-\ufffb]/;
+const SURROGATE_ISOLADO = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+const textoAceito = (t) => !CONTROLE.test(t) && !SURROGATE_ISOLADO.test(t);
+exports.textoAceito = textoAceito;
+/** Texto curto que cabe em `reference` ou `fragment`; fora disso, `null` (nunca truncado). */
+function textoCurto(t) {
+    const limpo = t.trim();
+    return limpo.length >= 1 && limpo.length <= intelligence_graph_contract_1.GRAFO_LIMITES.fragmento && (0, exports.textoAceito)(limpo) ? limpo : null;
+}
+/** Extensao do nome do arquivo em minusculas (`.ts`); arquivo oculto sem ponto no meio nao tem. */
+function extensaoDe(caminho) {
+    const nome = caminho.slice(caminho.lastIndexOf('/') + 1), i = nome.lastIndexOf('.');
+    return i <= 0 ? '' : nome.slice(i).toLowerCase();
+}
+/** D8: id de blob do Git, calculado dos bytes; igual ao `git hash-object --no-filters` do arquivo. */
+function idDeBlob(bytes) {
+    return (0, node_crypto_1.createHash)('sha1').update(`blob ${bytes.length}\0`).update(bytes).digest('hex');
+}
+const sha256 = (b) => (0, node_crypto_1.createHash)('sha256').update(b).digest('hex');
+/** UTF-8 estrito, com o BOM preservado para os offsets baterem com os bytes. */
+function decodificarUtf8(bytes) {
+    try {
+        return new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes);
+    }
+    catch {
+        return null;
+    }
+}
+/** Converte offset UTF-16 do texto em offset de byte UTF-8 e em linha (1-based). */
+class MapaDoTexto {
+    texto;
+    tamanho;
+    bytes = null;
+    quebras = null;
+    constructor(texto, tamanho) {
+        this.texto = texto;
+        this.tamanho = tamanho;
+    }
+    byte(i) {
+        if (this.tamanho === this.texto.length)
+            return i;
+        if (!this.bytes) {
+            const t = this.texto, acc = new Uint32Array(t.length + 1);
+            for (let j = 0; j < t.length; j++) {
+                const c = t.charCodeAt(j);
+                // Par de surrogates e um code point de 4 bytes; o texto veio de UTF-8 valido, sem surrogate isolado.
+                if (c >= 0xd800 && c <= 0xdbff && j + 1 < t.length) {
+                    acc[j + 1] = acc[j] + 4;
+                    acc[j + 2] = acc[j + 1];
+                    j++;
+                    continue;
+                }
+                acc[j + 1] = acc[j] + (c < 0x80 ? 1 : c < 0x800 ? 2 : 3);
+            }
+            this.bytes = acc;
+        }
+        return this.bytes[i];
+    }
+    linha(i) {
+        if (!this.quebras) {
+            const q = [];
+            for (let j = this.texto.indexOf('\n'); j >= 0; j = this.texto.indexOf('\n', j + 1))
+                q.push(j);
+            this.quebras = q;
+        }
+        let baixo = 0, alto = this.quebras.length;
+        while (baixo < alto) {
+            const meio = (baixo + alto) >> 1;
+            if (this.quebras[meio] < i)
+                baixo = meio + 1;
+            else
+                alto = meio;
+        }
+        return baixo + 1;
+    }
+}
+const chaveDoNo = (r) => (0, intelligence_graph_contract_1.canonico)([r.kind, r.path, r.fragment]);
+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, base = null) {
+    const { ts, unicode, markdown, javascript } = parser;
+    if (!/^[0-9]+(\.[0-9]+)*$/.test(unicode))
+        falha('extracao.entrada.unicode-invalido');
+    if (!/^[0-9A-Za-z][0-9A-Za-z.-]{0,40}$/.test(markdown.versao) || typeof markdown.analisar !== 'function'
+        || typeof markdown.referencia !== 'function')
+        falha('extracao.entrada.markdown-invalido');
+    if (!javascript || !/^node\.[0-9]+(\.[0-9]+)*$/.test(javascript.versao) || typeof javascript.sintaxe !== 'function') {
+        falha('extracao.entrada.javascript-invalido');
+    }
+    const acl = [...new Set(entrada.acl_refs)].sort(intelligence_graph_contract_1.compararUtf8);
+    const access = { tenant_id: entrada.tenant_id, acl_refs: acl };
+    const authority = `git:${entrada.repository_id}`;
+    const fontes = [...entrada.fontes].sort((a, b) => (0, intelligence_graph_contract_1.compararUtf8)(a.path, b.path));
+    for (let i = 1; i < fontes.length; i++)
+        if (fontes[i - 1].path === fontes[i].path)
+            falha('extracao.entrada.fonte-duplicada');
+    // O contrato recusa o grafo inteiro por um caminho ruim; aqui o caminho sai e fica declarado.
+    const excluidas = (entrada.excluidas ?? []).map((e) => ({ path: e.path, motivo: e.motivo }));
+    const validas = fontes.filter((f) => {
+        const ok = f.path.length <= intelligence_graph_contract_1.GRAFO_LIMITES.caminho && (0, intelligence_graph_contract_1.caminhoValido)(f.path);
+        if (!ok)
+            excluidas.push({ path: f.path, motivo: 'caminho-recusado' });
+        return ok;
+    });
+    const porNfc = new Map();
+    for (const f of validas)
+        porNfc.set(f.path.normalize('NFC'), (porNfc.get(f.path.normalize('NFC')) ?? 0) + 1);
+    const aceitas = validas.filter((f) => {
+        const ok = porNfc.get(f.path.normalize('NFC')) === 1;
+        if (!ok)
+            excluidas.push({ path: f.path, motivo: 'caminho-ambiguo' });
+        return ok;
+    });
+    if (aceitas.length === 0)
+        falha('extracao.entrada.sem-fontes');
+    if (aceitas.length > intelligence_graph_contract_1.GRAFO_LIMITES.manifesto)
+        falha('extracao.limite.manifesto');
+    const manifesto = new Map();
+    for (const f of aceitas) {
+        manifesto.set(f.path, {
+            path: f.path, authority, source_hash: sha256(f.bytes), source_version: idDeBlob(f.bytes), size_bytes: f.bytes.length, access,
+        });
+    }
+    const bytesDe = new Map(aceitas.map((f) => [f.path, f.bytes]));
+    const textos = new Map();
+    const texto = (p) => {
+        if (!textos.has(p)) {
+            const b = bytesDe.get(p);
+            textos.set(p, b ? decodificarUtf8(b) : null);
+        }
+        return textos.get(p) ?? undefined;
+    };
+    const achados = { nos: [], arestas: [], diagnosticos: [], lacunas: [] };
+    // Laco, nao `push(...lista)`: lista grande estouraria a pilha antes do teto tipado do contrato.
+    const juntar = (a) => {
+        for (const x of a.nos)
+            achados.nos.push(x);
+        for (const x of a.arestas)
+            achados.arestas.push(x);
+        for (const x of a.diagnosticos)
+            achados.diagnosticos.push(x);
+        for (const x of a.lacunas)
+            achados.lacunas.push(x);
+    };
+    const caminhos = aceitas.map((f) => f.path);
+    const fontesTs = [], fontesMd = [];
+    for (const p of caminhos) {
+        const ext = extensaoDe(p), ehTs = exports.EXTENSOES_TS.includes(ext), ehMd = exports.EXTENSOES_MD.includes(ext);
+        if (!ehTs && !ehMd) {
+            // D9: o arquivo vira no, e o diagnostico diz que o conteudo dele nao foi lido.
+            achados.diagnosticos.push({ kind: 'unsupported-language', path: p, reference: ext || null, extrator: exports.EXTRATOR_ARQUIVOS });
+            continue;
+        }
+        const t = texto(p);
+        if (t === undefined)
+            achados.lacunas.push({ categoria: 'utf8-invalido', path: p, inicio: null, detalhe: null });
+        else
+            (ehTs ? fontesTs : fontesMd).push({ path: p, texto: t });
+    }
+    const versaoTs = `${exports.VERSAO_KG2}+typescript.${ts.version}+${javascript.versao}`;
+    // 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);
+    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);
+    }
+    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 },
+        { extractor_id: exports.EXTRATOR_ID, extractor_version: exports.VERSAO_KG2 },
+        { extractor_id: exports.EXTRATOR_MD, extractor_version: `${exports.VERSAO_KG2}+${markdown.versao}+unicode.${unicode}` },
+        { extractor_id: exports.EXTRATOR_TS, extractor_version: versaoTs },
+    ];
+    const versoes = new Map(extratores.map((e) => [e.extractor_id, e.extractor_version]));
+    const versaoDe = (id) => versoes.get(id) ?? falha('extracao.interna.extrator-desconhecido');
+    // Nos: todo arquivo do manifesto e os nos que os extratores provaram.
+    const nos = new Map();
+    for (const p of caminhos)
+        nos.set(chaveDoNo({ kind: 'file', path: p, fragment: null }), { kind: 'file', path: p, fragment: null });
+    for (const r of achados.nos) {
+        if (!manifesto.has(r.path))
+            falha('extracao.interna.no-sem-fonte');
+        if (r.fragment === null || !(0, exports.textoAceito)(r.fragment) || r.fragment.length > intelligence_graph_contract_1.GRAFO_LIMITES.fragmento)
+            falha('extracao.interna.fragmento');
+        nos.set(chaveDoNo(r), r);
+    }
+    if (nos.size > intelligence_graph_contract_1.GRAFO_LIMITES.nos)
+        falha('extracao.limite.nos');
+    const mapas = new Map();
+    const mapaDe = (p) => {
+        let m = mapas.get(p);
+        if (!m) {
+            const t = texto(p);
+            if (t === undefined)
+                falha('extracao.interna.trecho-sem-texto');
+            m = new MapaDoTexto(t, bytesDe.get(p).length);
+            mapas.set(p, m);
+        }
+        return m;
+    };
+    // D10: uma aresta por (tipo, origem, destino), com as evidencias ordenadas por posicao.
+    const arestas = new Map();
+    for (const a of achados.arestas) {
+        const kf = chaveDoNo(a.from), kt = chaveDoNo(a.to);
+        if (!nos.has(kf) || !nos.has(kt))
+            falha('extracao.interna.extremidade-ausente');
+        if (a.trecho.path !== a.from.path)
+            falha('extracao.interna.evidencia-fora-da-origem');
+        if (!(a.trecho.inicio < a.trecho.fim))
+            falha('extracao.interna.trecho-vazio');
+        const m = mapaDe(a.trecho.path), fonte = manifesto.get(a.trecho.path);
+        const e = {
+            snapshot_id: `snap-${zeros}`, path: fonte.path, source_hash: fonte.source_hash, source_version: fonte.source_version, authority,
+            extractor_id: a.extrator, extractor_version: versaoDe(a.extrator), extraction_method: a.metodo, confidence_class: intelligence_graph_contract_1.CLASSE_DE_CONFIANCA,
+            span: { type: 'text', byte_start: m.byte(a.trecho.inicio), byte_end: m.byte(a.trecho.fim), line_start: m.linha(a.trecho.inicio), line_end: m.linha(a.trecho.fim - 1) },
+            access,
+        };
+        const chave = `${a.kind}\u0000${kf}\u0000${kt}`;
+        let atual = arestas.get(chave);
+        if (!atual)
+            arestas.set(chave, (atual = { kind: a.kind, from: a.from, to: a.to, evidencias: new Map() }));
+        atual.evidencias.set((0, intelligence_graph_contract_1.canonico)(e), e);
+    }
+    if (arestas.size > intelligence_graph_contract_1.GRAFO_LIMITES.arestas)
+        falha('extracao.limite.arestas');
+    const idProvisorio = (r) => `node-${(0, intelligence_graph_contract_1.sha256DoCanonico)([r.kind, r.path, r.fragment])}`;
+    let excedentes = 0;
+    const edges = [...arestas.values()].map((a) => {
+        const evidencias = [...a.evidencias.values()].sort((x, y) => (x.span.byte_start - y.span.byte_start) || (x.span.byte_end - y.span.byte_end)
+            || (0, intelligence_graph_contract_1.compararUtf8)(x.extractor_id, y.extractor_id) || (0, intelligence_graph_contract_1.compararUtf8)(x.extraction_method, y.extraction_method));
+        excedentes += Math.max(0, evidencias.length - intelligence_graph_contract_1.GRAFO_LIMITES.evidenciasPorAresta);
+        return {
+            edge_id: `edge-${zeros}`, kind: a.kind, snapshot_id: `snap-${zeros}`, from: idProvisorio(a.from), to: idProvisorio(a.to),
+            evidence: evidencias.slice(0, intelligence_graph_contract_1.GRAFO_LIMITES.evidenciasPorAresta), access,
+        };
+    });
+    const diagnosticos = new Map();
+    for (const d of achados.diagnosticos) {
+        if (!manifesto.has(d.path))
+            falha('extracao.interna.diagnostico-sem-fonte');
+        const reference = d.reference === null ? null : textoCurto(d.reference);
+        const diag = { kind: d.kind, path: d.path, reference, extractor_id: d.extrator, extractor_version: versaoDe(d.extrator), access };
+        diagnosticos.set((0, intelligence_graph_contract_1.canonico)(diag), diag);
+    }
+    if (diagnosticos.size > intelligence_graph_contract_1.GRAFO_LIMITES.diagnosticos)
+        falha('extracao.limite.diagnosticos');
+    const config = {
+        schema: exports.CONFIG_SCHEMA, authority, acl_refs: acl, evidencias_por_aresta: intelligence_graph_contract_1.GRAFO_LIMITES.evidenciasPorAresta,
+        typescript: { extensoes: exports.EXTENSOES_TS, opcoes: intelligence_graph_extract_ts_1.OPCOES_TS_DESCRITAS },
+        markdown: {
+            extensoes: exports.EXTENSOES_MD, ancora: 'github-slug', artefato: intelligence_graph_extract_md_1.PADRAO_DE_ID.source, frontmatter: intelligence_graph_extract_md_1.CHAVES_DO_FRONTMATTER, sem_mencao: intelligence_graph_extract_md_1.TOKENS_SEM_MENCAO,
+        },
+    };
+    const rascunho = {
+        schema: intelligence_graph_contract_1.GRAFO_SCHEMA, tenant_id: entrada.tenant_id, repository_id: entrada.repository_id,
+        snapshot: {
+            snapshot_id: `snap-${zeros}`, revision: entrada.revision, revision_unavailable_reason: entrada.revision_unavailable_reason,
+            source_manifest: [...manifesto.values()], config_hash: (0, intelligence_graph_contract_1.sha256DoCanonico)(config), extractors: extratores, extractors_digest: zeros,
+        },
+        nodes: [...nos.values()].map((r) => ({
+            node_id: idProvisorio(r), kind: r.kind, snapshot_id: `snap-${zeros}`, locator: { path: r.path, fragment: r.fragment },
+            source_hash: manifesto.get(r.path).source_hash, access,
+        })),
+        edges,
+        diagnostics: [...diagnosticos.values()],
+    };
+    const grafo = (0, intelligence_graph_contract_1.validarGrafo)((0, intelligence_graph_contract_1.derivarIds)(rascunho));
+    const digest = (0, intelligence_graph_contract_1.sha256DoCanonico)(grafo);
+    const contagens = {
+        fontes: grafo.snapshot.source_manifest.length, nos: contagemVazia(intelligence_graph_contract_1.TIPOS_DE_NO), arestas: contagemVazia(intelligence_graph_contract_1.TIPOS_DE_ARESTA),
+        diagnosticos: contagemVazia(intelligence_graph_contract_1.TIPOS_DE_DIAGNOSTICO), evidencias: 0,
+    };
+    for (const n of grafo.nodes)
+        contagens.nos[n.kind]++;
+    for (const a of grafo.edges) {
+        contagens.arestas[a.kind]++;
+        contagens.evidencias += a.evidence.length;
+    }
+    for (const d of grafo.diagnostics)
+        contagens.diagnosticos[d.kind]++;
+    const porCategoria = new Map(), listadas = new Map();
+    for (const l of achados.lacunas) {
+        porCategoria.set(l.categoria, (porCategoria.get(l.categoria) ?? 0) + 1);
+        if (exports.LACUNAS_SO_CONTAGEM.has(l.categoria))
+            continue;
+        const linha = l.inicio === null || texto(l.path) === undefined ? null : mapaDe(l.path).linha(l.inicio);
+        const item = { categoria: l.categoria, path: l.path, linha, detalhe: l.detalhe };
+        listadas.set((0, intelligence_graph_contract_1.canonico)(item), item);
+    }
+    const relatorio = {
+        schema: exports.RELATORIO_SCHEMA, snapshot_id: grafo.snapshot.snapshot_id, graph_digest: digest, contagens, evidencias_excedentes: excedentes,
+        excluidas: [...new Map(excluidas.map((e) => [(0, intelligence_graph_contract_1.canonico)(e), e])).entries()].sort((a, b) => (0, intelligence_graph_contract_1.compararUtf8)(a[0], b[0])).map(([, e]) => e),
+        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),
+    };
+    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 };
+}