sneakoscope 7.3.0 → 7.6.0

package/dist/core/triwiki/code-pack.js

@@ -1,9 +1,11 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { ensureDir, exists, nowIso, readJson, sha256, writeJsonAtomic } from '../fsx.js';
-export const CODE_PACK_SCHEMA = 'sks.code-pack.v1';
-export const DEFAULT_CODE_PACK_TOKEN_BUDGET = 8000;
+import { ensureDir, exists, readJson, writeJsonAtomic } from '../fsx.js';
+import { buildCodePackFromGraph } from './context-graph/projections/code-pack.js';
+import { CODE_PACK_SCHEMA } from './context-graph/projections/pack-contract.js';
+export { CODE_PACK_SCHEMA, DEFAULT_CODE_PACK_TOKEN_BUDGET } from './context-graph/projections/pack-contract.js';
+export { buildCodePackFromGraph, computeCodePackIndexDigest, isCodePackProjectionBoundToSnapshot, projectCodePackFromGraph } from './context-graph/projections/code-pack.js';
+export { buildWorkspaceCodePack } from './context-graph/projections/code-pack-workspace.js';
 export function codePackDir(root) {
     return path.join(root, '.sneakoscope', 'wiki');
 }
@@ -13,126 +15,16 @@ export function codePackPath(root) {
 export function codePackPrevPath(root) {
     return path.join(codePackDir(root), 'code-pack.prev.json');
 }
-export function buildCodePack(root, index, tokenBudget = DEFAULT_CODE_PACK_TOKEN_BUDGET) {
-    const normalizedBudget = Number.isFinite(tokenBudget) && tokenBudget >= 0
-        ? Math.floor(tokenBudget)
-        : DEFAULT_CODE_PACK_TOKEN_BUDGET;
-    const entries = [];
-    let totalTokenCost = 0;
-    for (const card of index.modules) {
-        const entry = buildEntryForModule(card);
-        if (!entry)
-            continue;
-        if (totalTokenCost + entry.token_cost > normalizedBudget)
-            continue;
-        entries.push(entry);
-        totalTokenCost += entry.token_cost;
-    }
-    return {
-        schema: CODE_PACK_SCHEMA,
-        generated_at: nowIso(),
-        git_head_sha: readGitHeadSha(root),
-        source_file_count: index.scanned_file_count,
-        index_digest: computeIndexDigest(index),
-        entries,
-        token_budget: normalizedBudget,
-        total_token_cost: totalTokenCost
-    };
-}
-function buildEntryForModule(card) {
-    const citations = collectCitations(card);
-    if (!citations.length)
-        return null;
-    const text = summarizeModule(card);
-    return {
-        id: `code:${card.module_id}`,
-        text,
-        citations,
-        trust_score: computeTrustScore(card),
-        freshness: 'unknown',
-        token_cost: Math.ceil(text.length / 4)
-    };
-}
-function collectCitations(card) {
-    const paths = [...card.paths, ...card.entry_points].filter(Boolean);
-    const seen = new Set();
-    const citations = [];
-    for (const p of paths) {
-        if (seen.has(p))
-            continue;
-        seen.add(p);
-        citations.push({ path: p });
-    }
-    return citations;
-}
-function summarizeModule(card) {
-    const role = inferRole(card);
-    const primaryPath = card.paths[0] || card.module_id;
-    const exportsPart = summarizeExports(card.exports_summary);
-    const depsPart = summarizeDependencies(card.dependency_edges);
-    const sizePart = `${card.file_count} file${card.file_count === 1 ? '' : 's'}, ${card.loc} loc, ${card.risk} risk`;
-    return `${card.module_id} is ${role} at ${primaryPath} (${sizePart}). ${exportsPart} ${depsPart}`.trim().replace(/\s+/g, ' ');
-}
-function inferRole(card) {
-    const idLower = card.module_id.toLowerCase();
-    const pathLower = card.paths.join(' ').toLowerCase();
-    if (idLower.includes('test') || pathLower.includes('__tests__'))
-        return 'a test module';
-    if (idLower.includes('cli') || pathLower.includes('cli'))
-        return 'a CLI module';
-    if (idLower.includes('command'))
-        return 'a command module';
-    if (idLower.includes('core'))
-        return 'a core module';
-    return 'a module';
-}
-function summarizeExports(exportsSummary) {
-    if (!exportsSummary.length)
-        return 'It has no detected top-level exports.';
-    const preview = exportsSummary.slice(0, 5).map((line) => line.replace(/^export\s+/, '').replace(/\s*\{\s*$/, '').trim());
-    const suffix = exportsSummary.length > preview.length ? `, and ${exportsSummary.length - preview.length} more` : '';
-    return `Key exports: ${preview.join('; ')}${suffix}.`;
-}
-function summarizeDependencies(dependencyEdges) {
-    if (!dependencyEdges.length)
-        return 'It has no detected cross-module dependencies.';
-    const preview = dependencyEdges.slice(0, 5);
-    const suffix = dependencyEdges.length > preview.length ? `, and ${dependencyEdges.length - preview.length} more` : '';
-    return `Depends on: ${preview.join(', ')}${suffix}.`;
-}
-function computeTrustScore(card) {
-    let score = 0.5;
-    if (card.entry_points.length > 0)
-        score += 0.2;
-    if (card.exports_summary.length > 0)
-        score += 0.2;
-    if (card.risk === 'high')
-        score -= 0.15;
-    else if (card.risk === 'low')
-        score += 0.1;
-    return Math.max(0, Math.min(1, Number(score.toFixed(2))));
-}
-function readGitHeadSha(root) {
-    try {
-        const result = spawnSync('git', ['rev-parse', 'HEAD'], { cwd: root, encoding: 'utf8' });
-        if (result.status !== 0 || result.error)
-            return null;
-        const sha = String(result.stdout || '').trim();
-        return sha || null;
-    }
-    catch {
-        return null;
-    }
-}
-function computeIndexDigest(index) {
-    const stable = index.modules
-        .map((card) => ({ module_id: card.module_id, paths: [...card.paths].sort() }))
-        .sort((a, b) => a.module_id.localeCompare(b.module_id));
-    return sha256(JSON.stringify(stable));
+export function buildCodePack(root, source, options = {}) {
+    return buildCodePackFromGraph(root, source, options);
 }
 export async function validateCodePack(pack, root) {
     const issues = [];
     const seenIds = new Set();
+    if (pack.schema !== CODE_PACK_SCHEMA)
+        issues.push(`unexpected pack schema: ${String(pack.schema)}`);
+    if (!pack.index_digest)
+        issues.push('pack has no index_digest');
     for (const entry of pack.entries) {
         if (seenIds.has(entry.id)) {
             issues.push(`duplicate entry id: ${entry.id}`);

package/dist/core/triwiki/context-graph/compiler/cache-key.js

@@ -0,0 +1,277 @@
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { runProcess, sha256 } from '../../../fsx.js';
+import { CONTEXT_GRAPH_SCHEMA_REVISION } from '../contracts.js';
+import { shortDigest } from '../ids.js';
+import { isWorkspaceRelativePosixPath } from '../paths.js';
+const GIT_TIMEOUT_MS = 10_000;
+const MAX_FINGERPRINT_FILES = 2000;
+const MAX_FINGERPRINT_FILE_BYTES = 8 * 1024 * 1024;
+const MAX_DIR_FINGERPRINT_ENTRIES = 4000;
+const TSCONFIG_INPUTS = ['tsconfig.json', 'tsconfig.build.json'];
+const COMMAND_MANIFEST_INPUTS = [
+    'src/cli/command-registry.ts',
+    'src/cli/command-manifest-lite.ts',
+    'runtime-required-scripts.json'
+];
+const GATE_MANIFEST_INPUTS = [
+    'release-gates.v2.json',
+    'infra-harness-gates.json',
+    'config/architecture-budgets.v1.json'
+];
+const PROOF_INDEX_DIR = '.sneakoscope/triwiki/proof-bank';
+const WIKI_CONTEXT_DIR = '.sneakoscope/wiki';
+const WIKI_CONTEXT_EXCLUDED = new Set([
+    'context-graph.json',
+    'context-graph.meta.json',
+    'context-graph.prev.json',
+    'context-graph-events.jsonl',
+    'context-pack.json',
+    'code-pack.json',
+    'code-pack.prev.json'
+]);
+const WIKI_CONTEXT_GIT_EXCLUDED = new Set([...WIKI_CONTEXT_EXCLUDED].map((name) => `${WIKI_CONTEXT_DIR}/${name}`));
+const RELEVANT_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.mjs',
+    '.cjs',
+    '.json',
+    '.jsonc',
+    '.md',
+    '.toml',
+    '.yml',
+    '.yaml',
+    '.swift',
+    '.rs',
+    '.py'
+]);
+function toPosix(value) {
+    return value.replace(/\\/g, '/');
+}
+async function hashFile(root, relative) {
+    if (!isWorkspaceRelativePosixPath(relative))
+        return null;
+    const absolute = path.resolve(root, relative);
+    let stat;
+    try {
+        stat = await fsp.lstat(absolute);
+    }
+    catch {
+        return null;
+    }
+    if (stat.isSymbolicLink())
+        return `symlink:${shortDigest(relative)}`;
+    if (!stat.isFile())
+        return null;
+    if (stat.size > MAX_FINGERPRINT_FILE_BYTES)
+        return `oversize:${stat.size}`;
+    try {
+        return sha256(await fsp.readFile(absolute));
+    }
+    catch {
+        return null;
+    }
+}
+async function fingerprintFiles(root, relatives) {
+    const rows = [];
+    const ordered = [...new Set(relatives)].sort();
+    let count = 0;
+    for (const relative of ordered) {
+        if (count >= MAX_FINGERPRINT_FILES) {
+            rows.push(`truncated:${ordered.length}`);
+            break;
+        }
+        count += 1;
+        const hash = await hashFile(root, relative);
+        rows.push(`${relative}:${hash ?? 'missing'}`);
+    }
+    return sha256(rows.join('\n'));
+}
+async function listDirectoryFiles(root, relativeDir) {
+    const absolute = path.resolve(root, relativeDir);
+    const out = [];
+    const stack = [absolute];
+    while (stack.length) {
+        const dir = stack.pop();
+        if (dir === undefined)
+            break;
+        let entries;
+        try {
+            entries = await fsp.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (out.length >= MAX_DIR_FINGERPRINT_ENTRIES)
+                return out.sort();
+            const child = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(child);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            const relative = toPosix(path.relative(root, child));
+            if (!isWorkspaceRelativePosixPath(relative))
+                continue;
+            out.push(relative);
+        }
+    }
+    return out.sort();
+}
+async function fingerprintDirectory(root, relativeDir, exclude = new Set()) {
+    const files = (await listDirectoryFiles(root, relativeDir)).filter((relative) => !exclude.has(path.posix.basename(relative)));
+    return fingerprintFiles(root, files);
+}
+function parsePorcelain(stdout) {
+    const tracked = [];
+    const untracked = [];
+    for (const record of stdout.split('\0')) {
+        if (record.length < 4)
+            continue;
+        const status = record.slice(0, 2);
+        const file = record.slice(3);
+        if (!file)
+            continue;
+        if (status === '??')
+            untracked.push(toPosix(file));
+        else
+            tracked.push(toPosix(file));
+    }
+    return { tracked: tracked.sort(), untracked: untracked.sort() };
+}
+function isRelevant(relative) {
+    if (relative.startsWith('.sneakoscope/'))
+        return false;
+    if (relative.startsWith('node_modules/') || relative.includes('/node_modules/'))
+        return false;
+    if (relative.startsWith('dist/'))
+        return false;
+    return RELEVANT_EXTENSIONS.has(path.posix.extname(relative));
+}
+export async function readContextGraphGitState(root) {
+    const unknown = {
+        state: 'unknown',
+        head: null,
+        trackedDirtyFingerprint: 'unknown',
+        untrackedFingerprint: 'unknown',
+        dirtyPaths: []
+    };
+    const head = await runProcess('git', ['rev-parse', '--verify', 'HEAD'], {
+        cwd: root,
+        timeoutMs: GIT_TIMEOUT_MS
+    }).catch(() => null);
+    if (!head || head.code !== 0 || head.timedOut)
+        return unknown;
+    const headSha = head.stdout.trim();
+    if (!/^[0-9a-f]{7,64}$/.test(headSha))
+        return unknown;
+    const status = await runProcess('git', ['status', '--porcelain=v1', '-z', '--untracked-files=all', '--no-renames'], { cwd: root, timeoutMs: GIT_TIMEOUT_MS }).catch(() => null);
+    if (!status || status.code !== 0 || status.timedOut || status.truncated)
+        return unknown;
+    const { tracked, untracked } = parsePorcelain(status.stdout);
+    const relevantTracked = tracked.filter((relative) => !WIKI_CONTEXT_GIT_EXCLUDED.has(relative));
+    const relevantUntracked = untracked.filter(isRelevant);
+    return {
+        state: relevantTracked.length === 0 && relevantUntracked.length === 0 ? 'clean' : 'dirty',
+        head: headSha,
+        trackedDirtyFingerprint: await fingerprintFiles(root, relevantTracked),
+        untrackedFingerprint: await fingerprintFiles(root, relevantUntracked),
+        dirtyPaths: [...new Set([...relevantTracked, ...relevantUntracked])].sort()
+    };
+}
+async function workspaceIdentity(root) {
+    let name = '';
+    try {
+        const parsed = JSON.parse(await fsp.readFile(path.join(root, 'package.json'), 'utf8'));
+        if (parsed && typeof parsed === 'object' && typeof parsed.name === 'string') {
+            name = parsed.name;
+        }
+    }
+    catch {
+        name = '';
+    }
+    return sha256(JSON.stringify({ name, dir: path.basename(path.resolve(root)) }));
+}
+function extractorSchemaRevision(extractors) {
+    const rows = [...extractors]
+        .map((extractor) => `${extractor.id}@${extractor.revision}`)
+        .sort();
+    return `${CONTEXT_GRAPH_SCHEMA_REVISION}+${shortDigest(rows.join('\n'))}`;
+}
+export function contextGraphCacheKey(parts) {
+    return sha256(JSON.stringify([
+        parts.workspaceIdentity,
+        parts.head ?? 'no-head',
+        parts.gitState,
+        parts.trackedDirtyFingerprint,
+        parts.untrackedFingerprint,
+        parts.schemaRevision,
+        parts.tsconfigHash,
+        parts.commandManifestHash,
+        parts.gateManifestHash,
+        parts.proofIndexHash,
+        parts.wikiContextHash
+    ]));
+}
+export async function computeContextGraphCacheKey(input) {
+    const root = path.resolve(input.root);
+    const git = await readContextGraphGitState(root);
+    const [tsconfigHash, commandManifestHash, gateManifestHash, proofIndexHash, wikiContextHash, identity] = await Promise.all([
+        fingerprintFiles(root, TSCONFIG_INPUTS),
+        fingerprintFiles(root, COMMAND_MANIFEST_INPUTS),
+        fingerprintFiles(root, GATE_MANIFEST_INPUTS),
+        fingerprintDirectory(root, PROOF_INDEX_DIR),
+        fingerprintDirectory(root, WIKI_CONTEXT_DIR, WIKI_CONTEXT_EXCLUDED),
+        workspaceIdentity(root)
+    ]);
+    const parts = {
+        workspaceIdentity: identity,
+        head: git.head,
+        gitState: git.state,
+        trackedDirtyFingerprint: git.trackedDirtyFingerprint,
+        untrackedFingerprint: git.untrackedFingerprint,
+        schemaRevision: extractorSchemaRevision(input.extractors),
+        tsconfigHash,
+        commandManifestHash,
+        gateManifestHash,
+        proofIndexHash,
+        wikiContextHash
+    };
+    const reusable = git.state !== 'unknown';
+    return {
+        key: contextGraphCacheKey(parts),
+        parts,
+        reusable,
+        reasons: reusable ? [] : ['git_state_unknown'],
+        dirtyPaths: git.dirtyPaths
+    };
+}
+const PART_REASONS = [
+    ['head', 'head_changed'],
+    ['trackedDirtyFingerprint', 'dirty_fingerprint_changed'],
+    ['untrackedFingerprint', 'dirty_fingerprint_changed'],
+    ['schemaRevision', 'schema_revision_changed'],
+    ['tsconfigHash', 'tsconfig_changed'],
+    ['commandManifestHash', 'command_manifest_changed'],
+    ['gateManifestHash', 'gate_manifest_changed'],
+    ['proofIndexHash', 'proof_index_changed'],
+    ['wikiContextHash', 'wiki_context_changed'],
+    ['workspaceIdentity', 'cache_key_changed']
+];
+export function compareCacheKeyParts(previous, current) {
+    const reasons = [];
+    if (!previous)
+        return ['cache_key_changed'];
+    if (current.gitState === 'unknown' || previous.gitState === 'unknown')
+        reasons.push('git_state_unknown');
+    for (const [field, reason] of PART_REASONS) {
+        if (previous[field] !== current[field] && !reasons.includes(reason))
+            reasons.push(reason);
+    }
+    return reasons;
+}

package/dist/core/triwiki/context-graph/compiler/extract.js

@@ -0,0 +1,104 @@
+import { CONTEXT_GRAPH_FRAGMENT_SCHEMA, lintWarning } from '../contracts.js';
+import { fragmentCacheKey, pruneFragmentCache, readCachedFragment, writeCachedFragment } from '../store/fragment-cache.js';
+export const DEFAULT_CONTEXT_GRAPH_LIMITS = {
+    maxFiles: 5000,
+    maxFileBytes: 512 * 1024,
+    maxNodes: 50_000,
+    maxEdges: 200_000,
+    timeoutMs: 60_000
+};
+async function settle(promise) {
+    try {
+        return { ok: true, value: await promise };
+    }
+    catch (error) {
+        return { ok: false, error };
+    }
+}
+async function withTimeout(promise, timeoutMs) {
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve('timeout'), Math.max(1, timeoutMs));
+        if (typeof timer.unref === 'function')
+            timer.unref();
+    });
+    try {
+        return await Promise.race([settle(promise), timeout]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+function isFragment(value, extractorId) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const fragment = value;
+    return (fragment.schema === CONTEXT_GRAPH_FRAGMENT_SCHEMA
+        && fragment.extractor === extractorId
+        && Array.isArray(fragment.nodes)
+        && Array.isArray(fragment.edges));
+}
+function sortExtractors(extractors) {
+    return [...extractors].sort((left, right) => (left.id < right.id ? -1 : left.id > right.id ? 1 : 0));
+}
+export async function runContextGraphExtractors(input) {
+    const fragments = [];
+    const issues = [];
+    const cacheHits = [];
+    const blockers = [];
+    const seen = new Set();
+    for (const extractor of sortExtractors(input.extractors)) {
+        if (seen.has(extractor.id)) {
+            blockers.push(`extractor_duplicate_id:${extractor.id}`);
+            continue;
+        }
+        seen.add(extractor.id);
+        const key = fragmentCacheKey({
+            extractorId: extractor.id,
+            extractorRevision: extractor.revision,
+            cacheKey: input.cacheKey,
+            changedPaths: input.changedPaths
+        });
+        if (input.useFragmentCache) {
+            const cached = await readCachedFragment(input.root, key, extractor.id);
+            if (cached) {
+                fragments.push(cached);
+                cacheHits.push(extractor.id);
+                continue;
+            }
+        }
+        const outcome = await withTimeout(extractor.extract({
+            root: input.root,
+            changedPaths: input.changedPaths,
+            limits: input.limits,
+            observedAt: input.observedAt
+        }), input.limits.timeoutMs);
+        if (outcome === 'timeout') {
+            blockers.push(`extractor_timeout:${extractor.id}`);
+            continue;
+        }
+        if (!outcome.ok) {
+            blockers.push(`extractor_failed:${extractor.id}`);
+            continue;
+        }
+        if (!isFragment(outcome.value, extractor.id)) {
+            blockers.push(`extractor_invalid_fragment:${extractor.id}`);
+            continue;
+        }
+        fragments.push(outcome.value);
+        if (outcome.value.skipped.length > 0) {
+            issues.push(lintWarning('extractor_skipped_input', `${extractor.id} skipped ${outcome.value.skipped.length} input(s)`, { extractor: extractor.id }));
+        }
+        if (input.useFragmentCache) {
+            try {
+                await writeCachedFragment(input.root, key, outcome.value);
+            }
+            catch {
+            }
+        }
+    }
+    if (input.useFragmentCache)
+        await pruneFragmentCache(input.root);
+    return { fragments, issues, cacheHits, blockers };
+}

package/dist/core/triwiki/context-graph/compiler/freshness.js

@@ -0,0 +1,108 @@
+import fsp from 'node:fs/promises';
+import { sha256 } from '../../../fsx.js';
+import { resolveInsideWorkspace } from '../paths.js';
+import { compareContextGraphIds } from '../ids.js';
+export const CONTEXT_GRAPH_MISSING_SOURCE_HASH = 'missing';
+const DERIVATION_EDGE_TYPES = new Set([
+    'cites',
+    'derived_from',
+    'supports',
+    'verified_by'
+]);
+const DERIVED_KINDS = new Set([
+    'wiki_claim',
+    'proof',
+    'source',
+    'risk_domain'
+]);
+export async function readSourceHashes(root, paths) {
+    const out = {};
+    for (const relative of [...new Set(paths)].sort()) {
+        let absolute = null;
+        try {
+            absolute = resolveInsideWorkspace(root, relative);
+        }
+        catch {
+            out[relative] = CONTEXT_GRAPH_MISSING_SOURCE_HASH;
+            continue;
+        }
+        if (!absolute) {
+            out[relative] = CONTEXT_GRAPH_MISSING_SOURCE_HASH;
+            continue;
+        }
+        try {
+            out[relative] = sha256(await fsp.readFile(absolute));
+        }
+        catch {
+            out[relative] = CONTEXT_GRAPH_MISSING_SOURCE_HASH;
+        }
+    }
+    return out;
+}
+function withFreshness(node, freshness) {
+    return node.freshness === freshness ? node : { ...node, freshness };
+}
+export async function applyContextGraphFreshness(input) {
+    const wanted = [];
+    for (const node of input.nodes) {
+        if (node.path !== undefined && node.path !== '')
+            wanted.push(node.path);
+    }
+    const provided = input.sourceHashes ?? {};
+    const missingFromCache = wanted.filter((relative) => provided[relative] === undefined);
+    const sourceHashes = {
+        ...provided,
+        ...(await readSourceHashes(input.root, missingFromCache))
+    };
+    const byId = new Map();
+    const stale = new Set();
+    const missingPaths = new Set();
+    for (const node of input.nodes) {
+        let resolved = node;
+        if (node.path !== undefined && node.path !== '') {
+            const current = sourceHashes[node.path];
+            if (current === undefined || current === CONTEXT_GRAPH_MISSING_SOURCE_HASH) {
+                missingPaths.add(node.path);
+                resolved = withFreshness(node, 'stale');
+            }
+            else if (node.contentHash !== undefined && node.contentHash !== '') {
+                resolved = withFreshness(node, current === node.contentHash ? 'fresh' : 'stale');
+            }
+        }
+        if (resolved.freshness === 'stale')
+            stale.add(resolved.id);
+        byId.set(resolved.id, resolved);
+    }
+    const incoming = new Map();
+    for (const edge of input.edges) {
+        if (!DERIVATION_EDGE_TYPES.has(edge.type))
+            continue;
+        const bucket = incoming.get(edge.to);
+        if (bucket)
+            bucket.push(edge);
+        else
+            incoming.set(edge.to, [edge]);
+    }
+    const queue = [...stale];
+    while (queue.length) {
+        const current = queue.pop();
+        if (current === undefined)
+            break;
+        for (const edge of incoming.get(current) ?? []) {
+            if (stale.has(edge.from))
+                continue;
+            const source = byId.get(edge.from);
+            if (!source || !DERIVED_KINDS.has(source.kind))
+                continue;
+            stale.add(edge.from);
+            byId.set(edge.from, withFreshness(source, 'stale'));
+            queue.push(edge.from);
+        }
+    }
+    return {
+        nodes: [...byId.values()],
+        sourceHashes,
+        staleNodeIds: [...stale].sort(compareContextGraphIds),
+        missingPaths: [...missingPaths].sort()
+    };
+}