hoi4-agent-tools 3.1.0 → 3.3.0

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## Unreleased
 
+## 3.3.0 - 2026-09-20
+
+- Add `hoi4.mechanic_test` with copied versioned scenario state, bounded source effects, explicit time advancement, traces, and typed gameplay assertions.
+- Add `hoi4.package_check` for declarative package definitions, calls, registrations, localisation, assets, and required suite-case references.
+- Add `hoi4.scenario_test` for named inline or workspace-owned suites through fixed read-only operations, case artifacts, and authenticated revision-bound continuation.
+- Share declared condition state across GUI and probability adapters while preserving their public inputs and specialized evaluation semantics.
+
+## 3.2.0 - 2026-09-20
+
+- Add read-only `hoi4.impact_inspect` with active and overridden definitions, direct and transitive source consumers, state-key access roles, cycle and coverage evidence, and in-memory source comparisons.
+- Connect event, focus, decision, idea, technology, scripted-helper, localisation, scripted-GUI, GUI, sprite, and texture references where typed static source evidence supports an edge; leave dynamic and unsupported references unresolved.
+- Identify affected declared scenario-suite cases from bounded workspace-owned JSON references without executing them.
+- Add read-only `hoi4.decision_inspect` for decision and mission inventory, declared actor and target gates, costs and direct payments, lifecycle paths, and scenario-by-scenario source comparisons.
+- Reuse the probability adapters for decision and mission AI scores and score comparisons, retaining linked traces and explicit proposal limits.
+- Serve both tools through ordinary and persistent native MCP tasks over legacy and modern stdio and HTTP routes, with revision-bound linked reports and source-preserving overlays.
+
 ## 3.1.0 - 2026-09-20
 
 - Reuse authenticated content-addressed parsed documents and file-local index segments across authorized local processes while revalidating current source bytes, load order, shadowing, workspace topology, and principal scope.

package/README.md

@@ -1,6 +1,6 @@
 # HOI4 Agent Tools
 
-HOI4 Agent Tools is an MCP server for coding agents to understand Hearts of Iron IV event chains, technology systems, AI weights, and MTTH timing and to inspect, create, or clean up focus trees, scripted GUIs, and maps. It produces source-linked structural and visual evidence that agents can use inside a larger modding workflow.
+HOI4 Agent Tools is an MCP server for coding agents to understand Hearts of Iron IV event chains, decisions, cross-system dependencies, technology systems, AI weights, and MTTH timing and to inspect, create, or clean up focus trees, scripted GUIs, and maps. It produces source-linked structural and visual evidence that agents can use inside a larger modding workflow.
 
 ## What it does
 
@@ -8,6 +8,7 @@ HOI4 Agent Tools is an MCP server for coding agents to understand Hearts of Iron
 - Scripted GUIs: trace GUI, GFX, scripted-GUI, and localisation links; render value-driven variants, dynamic country flags, inline text icons, states, resolutions, hierarchy, and click regions; diagnose alignment, visibility, clipping, panel containment, and button-label centering; create or repair interface source.
 - Maps: navigate the complete rendered map by ID or localised name; inspect provinces, states, regions, adjacency, supply, railways, and positions; create states and provinces; change IDs; and repair connected map data.
 - Event chains: scan definitions and call sites, trace routes and state flow, lint references, render graphs, and compare revisions without editing event source.
+- Cross-system impact and decisions: trace definitions and consumers across source systems, evaluate declared actor and target scenarios, inspect costs and mission paths, and compare in-memory proposals.
 - Technology trees: reconstruct technology and doctrine paths, folder layouts, unlocks, bonuses, grants, metadata, assets, and structural changes.
 - AI and MTTH: evaluate weighted choices and timing across explicit scenarios, bind special scope chains, enumerate dynamic target pools, sweep uncertain inputs, simulate distributions, compare patches, and analyze declared stateful pools.
 
@@ -71,6 +72,11 @@ On non-Windows systems, use `hoi4-agent-tools` as the command. Agentic HOI4 repo
 | `hoi4.event_inspect`        | Scan, trace, explain, lint, or assess event chains and their state flow.                  |
 | `hoi4.event_render`         | Render source-linked event routes, options, timing, state, scope, and unresolved edges.   |
 | `hoi4.event_compare`        | Compare event-chain topology and diagnostics between revisions.                           |
+| `hoi4.impact_inspect`       | Trace symbol and changed-file consumers across source systems and compare proposals.      |
+| `hoi4.decision_inspect`     | Inventory and evaluate decisions or missions under declared scenarios and source changes. |
+| `hoi4.mechanic_test`        | Execute bounded source effects on a copied declared scenario and check assertions.        |
+| `hoi4.package_check`        | Check declarative package definitions, calls, registrations, assets, and case links.      |
+| `hoi4.scenario_test`        | Run named source and domain cases in resumable, revision-bound batches.                   |
 | `hoi4.job_inspect`          | Inspect durable background work or retrieve its completed tool result.                    |
 | `hoi4.job_cancel`           | Durably request cancellation of authorized background work.                               |
 | `hoi4.tech_inspect`         | Scan, trace, explain, lint, and assess technology and doctrine systems.                   |
@@ -94,7 +100,7 @@ Long-running domain calls advertise optional MCP task support. A task survives c
 
 HOI4 Agent Tools provides HOI4 domain operations without replacing repository instructions such as `AGENTS.md`, skills, plans, or subagents. Its optional weighted-logic prompt helps an agent scope one probability analysis and then returns control to the normal workflow.
 
-Connecting and listing tools does not scan mod source. Compact tool schemas and linked resources keep large diagnostics, renders, and diffs out of the agent's working context until needed. Event, technology, and probability tools analyze source without editing it; only `hoi4.*_rewrite` calls edit mod source.
+Connecting and listing tools does not scan mod source. Compact tool schemas and linked resources keep large diagnostics, renders, and diffs out of the agent's working context until needed. Event, impact, decision, technology, and probability tools analyze source without editing it; only `hoi4.*_rewrite` calls edit mod source.
 
 ## Create or clean content
 
@@ -104,6 +110,8 @@ Ask your agent in normal task language. A typical workflow is inspect, render, r
 - Scripted GUIs: "Create a scripted GUI for this mechanic," or "Render every value-driven version of this window and fix hidden controls, off-center button text, background alignment, clipping, and click-region conflicts." See [Scripted GUIs](docs/gui.md).
 - Maps: "Render the whole map and find this state by name," "Create a state from these provinces," "Create a province inside this exact rectangle," or "Swap these state IDs and update connected references." See [Maps](docs/map.md).
 - Event chains: "Trace every route from this event and explain where its flags and variables change," or "Compare the workspace event graph with its previous revision and render the affected routes." See [Event chains](docs/events.md).
+- Cross-system impact and decisions: "Find every direct and transitive consumer of this idea," or "Compare who can take this decision, what they pay, and its mission end paths for these actor and target scenarios." See [Cross-system impact and decisions](docs/analysis.md).
+- Mechanics and packages: "Test this transfer's conservation and payment," or "Check every declared package link and resume its named scenario suite." See [Mechanic tests and scenario suites](docs/mechanics.md).
 - Technology trees: "Explain everything this technology requires and unlocks," or "Compare this technology patch and render every affected folder and doctrine branch." See [Technology trees](docs/technology.md).
 - AI and MTTH: "Compare these focus weights across peace, defensive-war, and low-stability scenarios," or "Show when this MTTH event becomes likely and which unknown inputs control the result." See [AI and MTTH analysis](docs/probability.md).
 

package/dist/hoi4_agent_tools/core/analysis-evidence.js

@@ -0,0 +1,9 @@
+import { boundedSourceHashEvidence } from './artifacts.js';
+/** Bind a linked analysis report to every source in both compared revisions. */
+export function analysisSourceEvidence(before, after, additionalSources = {}) {
+    return boundedSourceHashEvidence(Object.fromEntries([
+        ...before.files.map((file) => [`before:${file.displayPath}`, file.sha256]),
+        ...(after?.files.map((file) => [`after:${file.displayPath}`, file.sha256]) ?? []),
+        ...Object.entries(additionalSources),
+    ]));
+}

package/dist/hoi4_agent_tools/core/analysis-job-operations.js

@@ -0,0 +1,48 @@
+import { z } from 'zod/v4';
+import { DecisionAnalyzer } from '../decision/service.js';
+import { ImpactAnalyzer } from '../impact/service.js';
+import { MechanicAnalyzer } from '../mechanic/service.js';
+import { PackageAnalyzer } from '../package-check/service.js';
+import { ScenarioAnalyzer } from '../scenario-suite/service.js';
+import { decisionInspectRequestSchema, impactInspectRequestSchema } from '../schemas/analysis.js';
+import { mechanicTestRequestSchema, packageCheckRequestSchema, scenarioTestRequestSchema, } from '../schemas/scenarios.js';
+import { errorResult, toolResult } from './operation-result.js';
+import { ServiceError } from './result.js';
+const wireResult = z.record(z.string(), z.json());
+/** Registers read-only analysis services for durable ordinary and native tasks. */
+export function registerAnalysisJobs(operations, engine) {
+    const impact = new ImpactAnalyzer(engine);
+    const decision = new DecisionAnalyzer(engine);
+    const mechanic = new MechanicAnalyzer(engine);
+    const packages = new PackageAnalyzer(engine);
+    const scenarios = new ScenarioAnalyzer(engine);
+    const register = (name, schema, execute, progressMessage) => {
+        operations.registerRead(name, schema, async (input, context) => {
+            try {
+                if (input.workspaceId !== 'current' && input.workspaceId !== context.workspaceId)
+                    throw new ServiceError('JOB_ARGUMENT_SCOPE_MISMATCH', 'The request workspace does not match the authorized job workspace');
+                await context.progress({ completed: 0, total: 2, message: progressMessage });
+                const result = await execute({
+                    ...input,
+                    workspaceId: context.workspaceId,
+                    ...(context.principal === undefined ? {} : { principal: context.principal }),
+                    signal: context.signal,
+                });
+                await context.progress({ completed: 2, total: 2, message: 'Analysis complete' });
+                const wire = wireResult.parse(JSON.parse(JSON.stringify(toolResult(result))));
+                await context.stageResult(wire, { sourceRevision: result.data.sourceRevision });
+                return wire;
+            }
+            catch (error) {
+                if (context.signal.aborted)
+                    throw error;
+                return wireResult.parse(JSON.parse(JSON.stringify(errorResult(error, context.workspaceId))));
+            }
+        });
+    };
+    register('hoi4.impact_inspect', impactInspectRequestSchema, (input) => impact.inspect(input), 'Tracing cross-system impact');
+    register('hoi4.decision_inspect', decisionInspectRequestSchema, (input) => decision.inspect(input), 'Analyzing decisions and missions');
+    register('hoi4.mechanic_test', mechanicTestRequestSchema, (input) => mechanic.test(input), 'Testing declared mechanic steps');
+    register('hoi4.package_check', packageCheckRequestSchema, (input) => packages.check(input), 'Checking package connections');
+    register('hoi4.scenario_test', scenarioTestRequestSchema, (input) => scenarios.test(input), 'Running a bounded scenario suite');
+}

package/dist/hoi4_agent_tools/core/condition-evaluator.js

@@ -257,7 +257,11 @@ function evaluateAssignmentCore(assignment, scenario, candidate, definitions, he
         const explicit = bool(scopeStateValue(scenario, `flag.${right}`, scopeContext));
         if (explicit !== undefined)
             return { state: explicit ? 'true' : 'false', unresolved: [] };
-        const flags = scopeContext.expression === 'ROOT' ? scenario.flags : scopeContext.binding.flags;
+        const flags = key === 'has_global_flag' && scenario.globalFlags !== undefined
+            ? scenario.globalFlags
+            : scopeContext.expression === 'ROOT'
+                ? scenario.flags
+                : scopeContext.binding.flags;
         if (scenario.closedFlags === false && flags?.includes(right) !== true)
             return unresolved(assignment, candidate, `Scenario does not declare flag ${right}`);
         return { state: flags?.includes(right) === true ? 'true' : 'false', unresolved: [] };
@@ -344,6 +348,20 @@ function evaluateAssignmentCore(assignment, scenario, candidate, definitions, he
             state: compare(leftNumber, rightNumber, assignment.operator.text) ? 'true' : 'false',
             unresolved: [],
         };
+    if (/^(?:ROOT|THIS|PREV|FROM)$/iu.test(right)) {
+        const comparisonScope = resolveScopeContext(scenario, right, scopeContext);
+        if (comparisonScope === undefined ||
+            (comparisonScope.expression === 'ROOT' && scenario.actor === undefined))
+            return unresolved(assignment, candidate, `Scenario does not bind scope ${right}`);
+        if (typeof declared !== 'string')
+            return unresolved(assignment, candidate, `Trigger ${key} cannot compare its declared value with scope ${right}`);
+        return {
+            state: compare(declared, scopeIdentity(comparisonScope), assignment.operator.text)
+                ? 'true'
+                : 'false',
+            unresolved: [],
+        };
+    }
     if (typeof declared === 'string')
         return {
             state: compare(declared, right, assignment.operator.text) ? 'true' : 'false',
@@ -397,3 +415,5 @@ export function evaluateTriggerBlock(block, scenario, candidate, definitions, he
         trace: children.flatMap(({ trace }) => trace ?? []),
     };
 }
+/** Resolve a declared numeric expression with the same constants and scope rules as triggers. */
+export { numberValue as resolveConditionNumber };

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