hoi4-agent-tools 3.0.9 → 3.2.0

package/dist/hoi4_agent_tools/core/engine.js

@@ -1,10 +1,14 @@
 import { compareCodeUnits, hashCanonical } from './canonical.js';
 import { SymbolIndex } from './index.js';
+import { IndexSegmentCache } from './index-segments.js';
+import { PersistentAnalysisCache, } from './persistent-analysis-cache.js';
+import { sourceDocuments } from './source/cache.js';
 import { WorkspaceScanner } from './scanner.js';
 import { ArtifactStore } from './artifacts.js';
-import { TransactionManager } from './transactions.js';
+import { TransactionManager, transactionRootFingerprint } from './transactions.js';
 import { RequestScheduler } from './request-scheduler.js';
 import { SharedRequestCapacity } from './shared-request-capacity.js';
+import { JobStore } from './job-store.js';
 const RECOVERY_TTL_SECONDS = 3_600;
 const RECOVERY_MAX_BYTES = 536_870_912;
 const RECOVERY_MAX_RECORDS = 128;
@@ -81,6 +85,8 @@ export class CoreEngine {
     scanner;
     artifacts;
     transactions;
+    indexSegments;
+    persistentAnalysisCache;
     #scanCache = new Map();
     #scanFlights = new Map();
     #scanGenerations = new Map();
@@ -88,14 +94,30 @@ export class CoreEngine {
     #activeScanAdmissions = new Set();
     constructor(resolver, services = {}) {
         this.resolver = resolver;
+        this.indexSegments = services.indexSegments ?? new IndexSegmentCache();
+        const state = resolver.serverState();
+        this.persistentAnalysisCache =
+            services.persistentAnalysisCache === null || state === undefined
+                ? undefined
+                : Promise.resolve(services.persistentAnalysisCache ?? PersistentAnalysisCache.create(state));
         this.requests = new RequestScheduler(resolver.config().maxConcurrentTools);
         this.sharedRequests = new SharedRequestCapacity(resolver.serverState()?.root, resolver.config().maxSharedTools);
         this.scanner =
             services.scanner ??
                 new WorkspaceScanner(resolver.config().scanMaxFiles, resolver.config().scanMaxBytes, resolver.config().scanMaxFileBytes);
+        let retentionJobs;
         this.artifacts =
             services.artifacts ??
-                new ArtifactStore(resolver.config().artifactMaxBytes, resolver.config().artifactMaxEntries, resolver.config().artifactMaxSingleBytes);
+                new ArtifactStore(resolver.config().artifactMaxBytes, resolver.config().artifactMaxEntries, resolver.config().artifactMaxSingleBytes, state === undefined
+                    ? undefined
+                    : async (workspace, signal) => {
+                        retentionJobs ??= JobStore.create(state);
+                        return (await retentionJobs).checkpointResources({
+                            workspaceId: workspace.id,
+                            workspaceIdentity: workspace.workspaceIdentity,
+                            rootFingerprint: transactionRootFingerprint(workspace),
+                        }, signal);
+                    });
         this.transactions =
             services.transactions ??
                 new TransactionManager(resolver, this.artifacts, RECOVERY_TTL_SECONDS, RECOVERY_MAX_BYTES, RECOVERY_MAX_RECORDS, resolver.serverState());
@@ -160,12 +182,28 @@ export class CoreEngine {
                         signal: controller.signal,
                     });
                     controller.signal.throwIfAborted();
-                    const revision = hashCanonical(files.map(({ displayPath, loadOrder, sha256 }) => ({ displayPath, loadOrder, sha256 })));
+                    const persistentAnalysisCache = await this.persistentAnalysisCache;
+                    const analysisScope = {
+                        workspaceIdentity: workspace.workspaceIdentity,
+                        rootFingerprint: transactionRootFingerprint(workspace),
+                        principal: principal ?? null,
+                    };
+                    await persistentAnalysisCache?.hydrate(analysisScope, files, sourceDocuments, this.indexSegments, controller.signal);
+                    const revision = hashCanonical(files.map(({ absolutePath, displayPath, relativePath, rootKind, loadOrder, shadowedBy, sha256, }) => ({
+                        absolutePath,
+                        displayPath,
+                        relativePath,
+                        rootKind,
+                        loadOrder,
+                        shadowedBy: shadowedBy ?? null,
+                        sha256,
+                    })));
                     const cacheKey = `${requestKey}:${revision}`;
                     const cached = this.#scanCache.get(cacheKey);
                     if (cached !== undefined)
                         return cached;
-                    const index = await SymbolIndex.buildAsync(files, controller.signal);
+                    const index = await SymbolIndex.buildAsync(files, controller.signal, this.indexSegments);
+                    await persistentAnalysisCache?.persist(analysisScope, files, sourceDocuments, this.indexSegments, controller.signal);
                     const snapshot = {
                         workspaceId,
                         revision,
@@ -219,12 +257,17 @@ export class CoreEngine {
     /** Drop completed scan buffers without invalidating revisions or interrupting active scans. */
     releaseScanCaches() {
         this.#scanCache.clear();
+        this.indexSegments.clear();
+        sourceDocuments.clear();
         this.scanner.clearCaches();
     }
     /** Monotonic cache generation used by domain services to invalidate derived snapshots. */
     generation(workspaceId) {
         return this.#scanGenerations.get(workspaceId) ?? 0;
     }
+    async persistentAnalysisCacheStatistics() {
+        return (await this.persistentAnalysisCache)?.statistics();
+    }
     awaitScanFlight(requestKey, flight, signal) {
         signal?.throwIfAborted();
         flight.waiters += 1;
@@ -342,6 +385,6 @@ export class CoreEngine {
         }
     }
     indexFiles(files) {
-        return SymbolIndex.build(files);
+        return SymbolIndex.build(files, this.indexSegments);
     }
 }

package/dist/hoi4_agent_tools/core/helper-expansion.js

@@ -0,0 +1,186 @@
+import { z } from 'zod/v4';
+import { PACKAGE_VERSION } from '../version.js';
+import { helperExpansionRequestSchema, } from '../schemas/helper-expansion.js';
+import { canonicalJson, compareCodeUnits, hashCanonical } from './canonical.js';
+import { boundedSourceHashEvidence } from './artifacts.js';
+import { DependencyPages, dependencyPageCursorSchema } from './dependency-pages.js';
+import { ServiceError } from './result.js';
+import { transactionRootFingerprint } from './transactions.js';
+const digest = z.string().regex(/^[a-f0-9]{64}$/u);
+const querySchema = helperExpansionRequestSchema
+    .pick({ rootIds: true })
+    .extend({ maxDepth: z.number().int().min(1).max(256) });
+const continuationSchema = z
+    .object({
+    version: z.literal(1),
+    toolVersion: z.string(),
+    domain: z.enum(['event', 'technology']),
+    scope: digest,
+    sourceRevision: digest,
+    query: querySchema,
+    cursor: dependencyPageCursorSchema,
+})
+    .strict();
+export function helperExpansionValidation(summary) {
+    return {
+        passed: summary.complete,
+        checks: [
+            {
+                id: 'helper-expansion-coverage',
+                passed: summary.complete,
+                message: `${summary.completedRoots}/${summary.totalRoots} roots finished; ${summary.depthStops} depth stops; source inventory ${summary.sourceComplete ? 'complete' : 'partial'}; static source coverage only, not runtime validity`,
+            },
+        ],
+    };
+}
+/** Read-only structural evidence, with authenticated opaque continuation resources shared by both domains. */
+export async function inspectHelperExpansion(engine, workspaceId, inventory, request = {}, principal, signal) {
+    signal?.throwIfAborted();
+    const options = helperExpansionRequestSchema.parse(request);
+    const workspace = engine.resolver.get(workspaceId, principal);
+    const scope = hashCanonical({
+        workspaceId: workspace.id,
+        workspaceIdentity: workspace.workspaceIdentity,
+        ownerIdentity: workspace.ownerIdentity,
+        roots: transactionRootFingerprint(workspace),
+        principal: principal ?? null,
+    });
+    let restored;
+    if (options.continuationUri !== undefined) {
+        const resource = await engine.artifacts.readLogical(workspace, options.continuationUri, { mimeType: 'application/json', maxBytes: 8_388_608, maxChunks: 8_192 }, signal);
+        try {
+            restored = continuationSchema.parse(JSON.parse(resource.bytes.toString('utf8')));
+        }
+        catch {
+            throw new ServiceError('HELPER_CONTINUATION_INVALID', 'Helper continuation does not contain a valid bounded traversal envelope');
+        }
+        if (restored.domain !== inventory.domain || restored.scope !== scope)
+            throw new ServiceError('HELPER_CONTINUATION_SCOPE_MISMATCH', 'Helper continuation belongs to a different domain, workspace, root topology, or principal');
+        if (restored.toolVersion !== PACKAGE_VERSION ||
+            restored.sourceRevision !== inventory.sourceRevision)
+            throw new ServiceError('HELPER_CONTINUATION_STALE', 'Helper continuation requires the same tool version and exact source revision; start a new analysis');
+    }
+    const rootIds = options.rootIds === undefined
+        ? restored?.query.rootIds
+        : [...new Set(options.rootIds)].sort(compareCodeUnits);
+    const query = querySchema.parse({
+        ...(rootIds === undefined ? {} : { rootIds }),
+        maxDepth: options.maxDepth ?? restored?.query.maxDepth ?? 64,
+    });
+    if (restored !== undefined && hashCanonical(restored.query) !== hashCanonical(query))
+        throw new ServiceError('HELPER_CONTINUATION_QUERY_MISMATCH', 'Helper continuation cannot change root selection or depth; start a new analysis');
+    const knownRoots = new Set(inventory.roots);
+    if (query.rootIds?.some((id) => !knownRoots.has(id)) === true)
+        throw new ServiceError('HELPER_ROOT_UNKNOWN', 'Every selected root must be a structural helper-call root in the current source inventory');
+    const input = {
+        domain: `${inventory.domain}-helper-expansion.v1`,
+        sourceRevision: inventory.sourceRevision,
+        edges: inventory.edges.map(({ id, from, to }) => ({ id, from, to })),
+        roots: query.rootIds ?? [...inventory.roots].sort(compareCodeUnits),
+        branches: inventory.branches,
+        maximumDepth: query.maxDepth,
+        visitPolicy: 'edge_path',
+        reverseEdges: false,
+    };
+    const pager = new DependencyPages(input, restored?.cursor);
+    const page = pager.page(options.maxRecords ?? 250, options.maxWork ?? 5_000, signal);
+    const summary = {
+        complete: inventory.sourceComplete && page.finished && page.cursor.depthStops === 0,
+        finished: page.finished,
+        sourceComplete: inventory.sourceComplete,
+        maxDepth: query.maxDepth,
+        records: page.records.length,
+        totalRecords: page.cursor.emitted,
+        work: page.work,
+        totalWork: page.cursor.steps,
+        completedRoots: page.completedRoots,
+        totalRoots: page.totalRoots,
+        cycles: page.cursor.cycles,
+        depthStops: page.cursor.depthStops,
+    };
+    const used = new Set(page.records.flatMap(({ path }) => path));
+    const records = page.records.map(({ kind, root, path }) => ({
+        id: hashCanonical({ key: pager.key, kind, root, path }),
+        kind,
+        rootId: input.roots[root],
+        path: path.map((index) => inventory.edges[index].id),
+    }));
+    const continuationName = `${inventory.domain}-helper-continuation.json`;
+    const report = {
+        schemaVersion: 'helper-expansion.v1',
+        domain: inventory.domain,
+        workspaceId: workspace.id,
+        workspaceIdentity: workspace.workspaceIdentity,
+        sourceRevision: inventory.sourceRevision,
+        sourceEvidence: boundedSourceHashEvidence(inventory.sourceHashes),
+        unresolved: {
+            count: inventory.unresolved?.length ?? 0,
+            retainedCount: Math.min(100, inventory.unresolved?.length ?? 0),
+            sample: (inventory.unresolved ?? []).slice(0, 100),
+        },
+        query,
+        coverage: summary,
+        analysisBoundary: {
+            staticAnalysis: true,
+            visitPolicy: 'edge_path',
+            cyclePolicy: 'report_and_stop',
+            conditions: 'source evidence only; not evaluated',
+            directReferences: 'helper-owned leaves only; use the ordinary inspection modes for non-helper references',
+            completeness: 'recognized static call paths under report-and-stop cycle semantics; not runtime outcomes or resolution of dynamic source findings',
+        },
+        records,
+        edges: [...used].sort((left, right) => left - right).map((index) => inventory.edges[index]),
+        ...(page.finished
+            ? {}
+            : {
+                continuation: {
+                    name: continuationName,
+                    mimeType: 'application/json',
+                    resolution: 'helperExpansion.continuationUri in the tool result; also linked as a sibling artifact',
+                },
+            }),
+    };
+    const reportJson = `${canonicalJson(report)}\n`;
+    const provenance = {
+        kind: `${inventory.domain}-helper-expansion`,
+        toolVersion: PACKAGE_VERSION,
+        schemaVersion: '1',
+        sourceHashes: {},
+        metadata: { scope, sourceRevision: inventory.sourceRevision, traversal: pager.key },
+    };
+    const writes = [
+        {
+            name: `${inventory.domain}-helper-expansion.json`,
+            mimeType: 'application/json',
+            content: reportJson,
+            provenance,
+            description: 'Bounded source-linked helper path evidence and explicit traversal coverage',
+        },
+    ];
+    if (!page.finished)
+        writes.push({
+            name: continuationName,
+            mimeType: 'application/json',
+            content: canonicalJson(continuationSchema.parse({
+                version: 1,
+                toolVersion: PACKAGE_VERSION,
+                domain: inventory.domain,
+                scope,
+                sourceRevision: inventory.sourceRevision,
+                query,
+                cursor: page.cursor,
+            })),
+            provenance,
+            description: 'Opaque revision- and principal-bound helper continuation; pass as helperExpansion.continuationUri',
+        });
+    const artifacts = await engine.artifacts.withAtomicChunkedWrites(workspace, writes, (stored) => Promise.resolve([...stored]), signal);
+    return {
+        report,
+        reportJson,
+        summary: {
+            ...summary,
+            ...(artifacts[1] === undefined ? {} : { continuationUri: artifacts[1].uri }),
+        },
+        artifacts,
+    };
+}

package/dist/hoi4_agent_tools/core/impact-comparison.js

@@ -0,0 +1,49 @@
+import { compareCodeUnits, hashCanonical } from './canonical.js';
+import { inspectImpactGraph, } from './impact-graph.js';
+function edgeIdentity(edge) {
+    const targetDefinition = edge.targetDefinition;
+    return hashCanonical({
+        source: edge.source,
+        target: edge.target,
+        targetDefinition: targetDefinition === undefined
+            ? null
+            : {
+                path: targetDefinition.path,
+                rootKind: targetDefinition.rootKind,
+                loadOrder: targetDefinition.loadOrder,
+            },
+        referenceKind: edge.referenceKind,
+        accessRole: edge.accessRole,
+    });
+}
+function consumers(result) {
+    return [...result.directConsumers, ...result.transitiveConsumers];
+}
+/** Compare typed dependency consumers under the same selection and bounds. */
+export function compareImpactGraphs(beforeSnapshot, afterSnapshot, query) {
+    if (beforeSnapshot.workspaceId !== afterSnapshot.workspaceId)
+        throw new Error('Impact comparison crosses workspace boundaries');
+    const before = inspectImpactGraph(beforeSnapshot, query);
+    const after = inspectImpactGraph(afterSnapshot, query);
+    const beforeEdges = consumers(before);
+    const afterEdges = consumers(after);
+    const beforeKeys = new Set(beforeEdges.map(edgeIdentity));
+    const afterKeys = new Set(afterEdges.map(edgeIdentity));
+    const beforeFiles = new Set(before.affectedFiles);
+    const afterFiles = new Set(after.affectedFiles);
+    return {
+        beforeRevision: before.sourceRevision,
+        afterRevision: after.sourceRevision,
+        complete: before.complete && after.complete,
+        before,
+        after,
+        addedConsumers: afterEdges.filter((edge) => !beforeKeys.has(edgeIdentity(edge))),
+        removedConsumers: beforeEdges.filter((edge) => !afterKeys.has(edgeIdentity(edge))),
+        newlyAffectedFiles: after.affectedFiles
+            .filter((file) => !beforeFiles.has(file))
+            .sort(compareCodeUnits),
+        noLongerAffectedFiles: before.affectedFiles
+            .filter((file) => !afterFiles.has(file))
+            .sort(compareCodeUnits),
+    };
+}

package/dist/hoi4_agent_tools/core/impact-graph.js

@@ -0,0 +1,301 @@
+import { compareCodeUnits } from './canonical.js';
+import { scanImpactSemanticReferences } from './impact-semantic.js';
+function symbolKey(kind, id) {
+    return `${kind}\0${id}`;
+}
+function sourceKey(path, id) {
+    return `${path}\0${id}`;
+}
+function edgeOrder(left, right) {
+    return (compareCodeUnits(left.target.kind, right.target.kind) ||
+        compareCodeUnits(left.target.id, right.target.id) ||
+        compareCodeUnits(left.source.kind, right.source.kind) ||
+        compareCodeUnits(left.source.id, right.source.id) ||
+        compareCodeUnits(left.path, right.path) ||
+        compareCodeUnits(left.referenceKind, right.referenceKind));
+}
+function bounded(value, fallback, maximum) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isSafeInteger(value) || value < 1 || value > maximum)
+        throw new RangeError(`Impact limit must be an integer between 1 and ${maximum}`);
+    return value;
+}
+/** Finds every reached edge inside a strongly connected component without recursive call stacks. */
+function reachedCycleEdges(reached, edges) {
+    const outgoing = new Map();
+    const incoming = new Map();
+    for (const edge of edges) {
+        const from = symbolKey(edge.target.kind, edge.target.id);
+        const to = symbolKey(edge.source.kind, edge.source.id);
+        if (!reached.has(from) || !reached.has(to))
+            continue;
+        const targets = outgoing.get(from) ?? [];
+        targets.push(to);
+        outgoing.set(from, targets);
+        const sources = incoming.get(to) ?? [];
+        sources.push(from);
+        incoming.set(to, sources);
+    }
+    const visited = new Set();
+    const order = [];
+    for (const root of [...reached].sort(compareCodeUnits)) {
+        if (visited.has(root))
+            continue;
+        visited.add(root);
+        const stack = [{ key: root, cursor: 0 }];
+        while (stack.length > 0) {
+            const frame = stack.at(-1);
+            const next = outgoing.get(frame.key)?.[frame.cursor];
+            if (next === undefined) {
+                order.push(frame.key);
+                stack.pop();
+                continue;
+            }
+            frame.cursor += 1;
+            if (!visited.has(next)) {
+                visited.add(next);
+                stack.push({ key: next, cursor: 0 });
+            }
+        }
+    }
+    const componentByKey = new Map();
+    const componentSizes = [];
+    for (const root of order.reverse()) {
+        if (componentByKey.has(root))
+            continue;
+        const component = componentSizes.length;
+        let size = 0;
+        const stack = [root];
+        componentByKey.set(root, component);
+        while (stack.length > 0) {
+            const key = stack.pop();
+            size += 1;
+            for (const previous of incoming.get(key) ?? []) {
+                if (componentByKey.has(previous))
+                    continue;
+                componentByKey.set(previous, component);
+                stack.push(previous);
+            }
+        }
+        componentSizes.push(size);
+    }
+    const cycles = [];
+    const recorded = new Set();
+    let omittedCycles = 0;
+    for (const edge of [...edges].sort(edgeOrder)) {
+        const from = symbolKey(edge.target.kind, edge.target.id);
+        const to = symbolKey(edge.source.kind, edge.source.id);
+        const component = componentByKey.get(from);
+        if (component === undefined ||
+            component !== componentByKey.get(to) ||
+            (componentSizes[component] === 1 && from !== to))
+            continue;
+        const identity = `${from}\0${to}\0${edge.source.path}`;
+        if (recorded.has(identity))
+            continue;
+        recorded.add(identity);
+        if (cycles.length < 1_000)
+            cycles.push({
+                from: edge.target,
+                to: { kind: edge.source.kind, id: edge.source.id },
+                path: edge.source.path,
+            });
+        else
+            omittedCycles += 1;
+    }
+    return { cycles, omittedCycles };
+}
+/** Revision-pinned reverse consumer walk over the shared typed symbol index. */
+export function inspectImpactGraph(snapshot, query) {
+    const maxNodes = bounded(query.maxNodes, 5_000, 50_000);
+    const maxEdges = bounded(query.maxEdges, 10_000, 100_000);
+    const maxDepth = bounded(query.maxDepth, 12, 64);
+    const semantic = scanImpactSemanticReferences(snapshot);
+    const activeBySource = new Map();
+    const activeByKey = new Map();
+    const activeByPath = new Map();
+    for (const symbol of snapshot.index.symbols) {
+        if (symbol.overridden)
+            continue;
+        const source = sourceKey(symbol.path, symbol.id);
+        const sourceGroup = activeBySource.get(source) ?? [];
+        sourceGroup.push(symbol);
+        activeBySource.set(source, sourceGroup);
+        activeByKey.set(symbolKey(symbol.kind, symbol.id), symbol);
+        const pathGroup = activeByPath.get(symbol.path) ?? [];
+        pathGroup.push(symbol);
+        activeByPath.set(symbol.path, pathGroup);
+    }
+    const reverse = new Map();
+    const unresolvedByTarget = new Map();
+    const assetReferences = snapshot.index.symbols.flatMap((symbol) => symbol.kind === 'sprite' && !symbol.overridden && typeof symbol.metadata.texture === 'string'
+        ? [
+            {
+                kind: 'sprite_texture',
+                from: symbol.id,
+                toKind: 'texture',
+                to: symbol.metadata.texture,
+                path: symbol.path,
+                ...(symbol.location === undefined ? {} : { location: symbol.location }),
+            },
+        ]
+        : []);
+    for (const reference of [
+        ...snapshot.index.references,
+        ...semantic.references,
+        ...assetReferences,
+    ]) {
+        const sources = activeBySource.get(sourceKey(reference.path, reference.from)) ?? [];
+        const targetKey = symbolKey(reference.toKind, reference.to);
+        if (sources.length !== 1) {
+            const list = unresolvedByTarget.get(targetKey) ?? [];
+            list.push({
+                reference,
+                reason: sources.length === 0
+                    ? 'Reference has no active enclosing symbol in the shared index'
+                    : 'Reference has more than one active enclosing symbol kind',
+            });
+            unresolvedByTarget.set(targetKey, list);
+            continue;
+        }
+        const target = activeByKey.get(symbolKey(reference.toKind, reference.to));
+        const edge = {
+            source: {
+                kind: sources[0].kind,
+                id: sources[0].id,
+                path: sources[0].path,
+                rootKind: sources[0].rootKind,
+                loadOrder: sources[0].loadOrder,
+            },
+            target: { kind: reference.toKind, id: reference.to },
+            ...(target === undefined
+                ? {}
+                : {
+                    targetDefinition: {
+                        path: target.path,
+                        rootKind: target.rootKind,
+                        loadOrder: target.loadOrder,
+                        ...(target.location === undefined ? {} : { location: target.location }),
+                    },
+                }),
+            referenceKind: reference.kind,
+            accessRole: reference.kind.endsWith('_read')
+                ? 'read'
+                : reference.kind.endsWith('_write')
+                    ? 'write'
+                    : 'reference',
+            path: reference.path,
+            ...(reference.location === undefined ? {} : { location: reference.location }),
+            targetStatus: ['variable', 'flag', 'event_target'].includes(reference.toKind)
+                ? 'state_key'
+                : target === undefined
+                    ? snapshot.index.hasSkippedSourceForKind(reference.toKind)
+                        ? 'partial'
+                        : 'missing'
+                    : 'active',
+        };
+        const list = reverse.get(targetKey) ?? [];
+        list.push(edge);
+        reverse.set(targetKey, list);
+    }
+    for (const edges of reverse.values())
+        edges.sort(edgeOrder);
+    const selectors = query.symbols ?? [];
+    const selectorKeys = new Set(selectors.map(({ kind, id }) => symbolKey(kind, id)));
+    const changedFiles = [...new Set(query.changedFiles ?? [])].sort(compareCodeUnits);
+    const seeds = new Set(selectorKeys);
+    for (const changedFile of changedFiles)
+        for (const symbol of activeByPath.get(changedFile) ?? [])
+            seeds.add(symbolKey(symbol.kind, symbol.id));
+    const definitions = snapshot.index.symbols
+        .filter((symbol) => selectorKeys.has(symbolKey(symbol.kind, symbol.id)))
+        .sort((left, right) => compareCodeUnits(left.kind, right.kind) ||
+        compareCodeUnits(left.id, right.id) ||
+        right.loadOrder - left.loadOrder ||
+        compareCodeUnits(left.path, right.path));
+    const missingSymbols = selectors.filter(({ kind, id }) => !activeByKey.has(symbolKey(kind, id)) &&
+        !(['variable', 'flag', 'event_target'].includes(kind) && reverse.has(symbolKey(kind, id))));
+    const seedKeys = [...seeds].sort(compareCodeUnits);
+    const visited = new Set(seedKeys.slice(0, maxNodes));
+    const queue = [...visited].map((key) => ({ key, depth: 0 }));
+    const directConsumers = [];
+    const transitiveConsumers = [];
+    const affectedFiles = new Set(changedFiles);
+    for (const key of seeds) {
+        const source = activeByKey.get(key);
+        if (source !== undefined)
+            affectedFiles.add(source.path);
+    }
+    const unresolved = [];
+    let reachedEdges = 0;
+    let omittedEdges = 0;
+    let omittedNodes = seedKeys.length - visited.size;
+    let stoppedAtDepth = false;
+    for (const { key, depth } of queue) {
+        unresolved.push(...(unresolvedByTarget.get(key) ?? []));
+        const consumers = reverse.get(key) ?? [];
+        if (depth >= maxDepth) {
+            if (consumers.length > 0)
+                stoppedAtDepth = true;
+            omittedEdges += consumers.length;
+            continue;
+        }
+        for (const edge of consumers) {
+            if (reachedEdges >= maxEdges) {
+                omittedEdges += 1;
+                continue;
+            }
+            reachedEdges += 1;
+            affectedFiles.add(edge.source.path);
+            if (depth === 0)
+                directConsumers.push(edge);
+            else
+                transitiveConsumers.push(edge);
+            const consumerKey = symbolKey(edge.source.kind, edge.source.id);
+            if (visited.has(consumerKey))
+                continue;
+            if (visited.size >= maxNodes) {
+                omittedNodes += 1;
+                continue;
+            }
+            visited.add(consumerKey);
+            queue.push({ key: consumerKey, depth: depth + 1 });
+        }
+    }
+    const { cycles, omittedCycles } = reachedCycleEdges(visited, [
+        ...directConsumers,
+        ...transitiveConsumers,
+    ]);
+    return {
+        sourceRevision: snapshot.revision,
+        complete: snapshot.complete &&
+            semantic.complete &&
+            omittedNodes === 0 &&
+            omittedEdges === 0 &&
+            omittedCycles === 0 &&
+            !stoppedAtDepth &&
+            unresolved.length === 0 &&
+            semantic.unresolved.length === 0,
+        definitions,
+        missingSymbols,
+        directConsumers: directConsumers.sort(edgeOrder),
+        transitiveConsumers: transitiveConsumers.sort(edgeOrder),
+        affectedFiles: [...affectedFiles].sort(compareCodeUnits),
+        unresolved,
+        dynamicReferences: semantic.unresolved,
+        cycles,
+        coverage: {
+            scannedSymbols: snapshot.index.symbols.length,
+            scannedReferences: snapshot.index.references.length + semantic.references.length + assetReferences.length,
+            reachedNodes: visited.size,
+            reachedEdges,
+            omittedNodes,
+            omittedEdges,
+            omittedCycles,
+            stoppedAtDepth,
+            sourceComplete: snapshot.complete,
+            skippedSourceCount: snapshot.skippedSourceCount,
+        },
+    };
+}