ast-mcp-server 0.5.1 → 0.7.0

package/dist/services/relationships.js

@@ -0,0 +1,1198 @@
+import path from "node:path";
+import { Node, SyntaxKind, } from "ts-morph";
+import { createSourceLocation, isFreshnessCause, isSnapshotState, } from "./read-contracts.js";
+import { collectSymbols, containingSymbol, findLocatedSymbol, forEachLocatedSymbol, } from "./symbols.js";
+import { NO_REQUEST_CONTEXT } from "./request-context.js";
+export const RELATIONSHIP_EDGE_KINDS = Object.freeze([
+    "reference",
+    "import",
+    "export",
+    "extends",
+    "implements",
+    "call",
+    "contains",
+]);
+export const RELATIONSHIP_PROVENANCES = Object.freeze(["compiler", "syntax", "heuristic"]);
+export const RELATIONSHIP_CONFIDENCES = Object.freeze(["exact", "high", "medium", "low"]);
+export const RELATIONSHIP_RESOLUTIONS = Object.freeze([
+    "resolved",
+    "unresolved",
+    "ambiguous",
+]);
+function assertNonEmptyString(value, name) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`Relationship ${name} must be a non-empty string.`);
+    }
+    return value.trim();
+}
+function assertEnum(value, values, name) {
+    if (!values.includes(value)) {
+        throw new Error(`Relationship ${name} is invalid.`);
+    }
+    return value;
+}
+function normalizeFreshness(input) {
+    if (typeof input !== "object" ||
+        input === null ||
+        !isSnapshotState(input.state) ||
+        !Array.isArray(input.causes) ||
+        (input.checked_at !== null && typeof input.checked_at !== "string")) {
+        throw new Error("Relationship freshness metadata is invalid.");
+    }
+    const causes = [...new Set(input.causes)];
+    if (!causes.every((cause) => isFreshnessCause(cause))) {
+        throw new Error("Relationship freshness contains an invalid cause.");
+    }
+    if (input.state === "fresh" && causes.length > 0) {
+        throw new Error("Fresh relationship evidence cannot carry freshness causes.");
+    }
+    return Object.freeze({
+        state: input.state,
+        causes: Object.freeze(causes.sort()),
+        checked_at: input.checked_at,
+    });
+}
+function normalizeEndpoint(input) {
+    if (typeof input !== "object" || input === null) {
+        throw new Error("Relationship endpoint is invalid.");
+    }
+    const location = createSourceLocation(input.file, input.range ?? { start_line: 1 });
+    const symbolPath = assertNonEmptyString(input.symbol_path, "endpoint symbol_path");
+    const selector = assertNonEmptyString(input.selector, "endpoint selector");
+    const { file, ...range } = location;
+    return Object.freeze({
+        file,
+        symbol_path: symbolPath,
+        selector,
+        ...(input.range === undefined ? {} : { range }),
+    });
+}
+function endpointIdentity(endpoint) {
+    return [endpoint.file, endpoint.symbol_path, endpoint.selector];
+}
+export function createRelationshipEdge(input) {
+    if (typeof input !== "object" || input === null) {
+        throw new Error("Relationship edge input is invalid.");
+    }
+    const source = normalizeEndpoint(input.source);
+    const target = normalizeEndpoint(input.target);
+    const kind = assertEnum(input.kind, RELATIONSHIP_EDGE_KINDS, "edge kind");
+    const provenance = assertEnum(input.provenance, RELATIONSHIP_PROVENANCES, "provenance");
+    const confidence = assertEnum(input.confidence, RELATIONSHIP_CONFIDENCES, "confidence");
+    const resolution = assertEnum(input.resolution, RELATIONSHIP_RESOLUTIONS, "resolution");
+    const freshness = normalizeFreshness(input.freshness);
+    const compilerAuthoritative = provenance === "compiler" &&
+        confidence === "exact" &&
+        resolution === "resolved" &&
+        freshness.state === "fresh";
+    return Object.freeze({
+        relationship_id: `${kind}:${JSON.stringify(endpointIdentity(source))}->${JSON.stringify(endpointIdentity(target))}`,
+        source,
+        target,
+        kind,
+        provenance,
+        confidence,
+        resolution,
+        freshness,
+        compiler_authoritative: compilerAuthoritative,
+    });
+}
+function sourceFileKey(filePath) {
+    return path.normalize(filePath);
+}
+function isProjectScopedFile(projectRoot, filePath) {
+    const relative = path.relative(projectRoot, filePath);
+    const insideProject = relative === "" ||
+        (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative));
+    return insideProject && !relative.split(path.sep).includes("node_modules");
+}
+function projectRelativeFile(projectRoot, filePath) {
+    return path.relative(projectRoot, filePath).split(path.sep).join("/");
+}
+function nodeRange(node) {
+    const sourceFile = node.getSourceFile();
+    const start = sourceFile.getLineAndColumnAtPos(node.getStart());
+    const end = sourceFile.getLineAndColumnAtPos(Math.max(node.getStart(), node.getEnd() - 1));
+    return {
+        start_line: start.line,
+        start_column: start.column,
+        end_line: end.line,
+        end_column: end.column,
+    };
+}
+function symbolEndpoint(symbol, projectRoot) {
+    return {
+        file: projectRelativeFile(projectRoot, symbol.node.getSourceFile().getFilePath()),
+        symbol_path: symbol.symbolPath,
+        selector: `${symbol.symbolPath}@${symbol.line}`,
+        range: nodeRange(symbol.node),
+    };
+}
+function moduleEndpoint(sourceFile, projectRoot, anchor) {
+    return {
+        file: projectRelativeFile(projectRoot, sourceFile.getFilePath()),
+        symbol_path: "<module>",
+        selector: "<module>@1",
+        ...(anchor ? { range: nodeRange(anchor) } : {}),
+    };
+}
+function declarationsForSymbol(symbol) {
+    if (!symbol)
+        return [];
+    const resolved = symbol.getAliasedSymbol() ?? symbol;
+    return resolved.getDeclarations();
+}
+function declarationsForType(type) {
+    return declarationsForSymbol(type.getSymbol()).concat(declarationsForSymbol(type.getAliasSymbol()));
+}
+function symbolFromNameNode(node) {
+    if (!Node.isIdentifier(node) && !Node.isStringLiteral(node))
+        return undefined;
+    return node.getSymbol();
+}
+function addEdge(state, source, target, kind) {
+    const edge = createRelationshipEdge({
+        source,
+        target,
+        kind,
+        provenance: "compiler",
+        confidence: "exact",
+        resolution: "resolved",
+        freshness: state.freshness,
+    });
+    state.edges.set(edge.relationship_id, edge);
+}
+function projectLocatedDeclarations(state, declarations, requestContext) {
+    const unique = new Set();
+    for (const declaration of declarations) {
+        requestContext.checkpoint();
+        const sourceFile = declaration.getSourceFile();
+        if (!state.sourceFiles.has(sourceFileKey(sourceFile.getFilePath())))
+            continue;
+        const located = state.locatedSymbols.get(declaration);
+        if (located)
+            unique.add(located);
+    }
+    return [...unique];
+}
+function addReferenceEdges(state, requestContext) {
+    for (const target of new Set(state.locatedSymbols.values())) {
+        requestContext.checkpoint();
+        if (!Node.isReferenceFindable(target.node))
+            continue;
+        for (const reference of target.node.findReferencesAsNodes()) {
+            requestContext.checkpoint();
+            const sourceFile = reference.getSourceFile();
+            if (!state.sourceFiles.has(sourceFileKey(sourceFile.getFilePath())))
+                continue;
+            const source = containingSymbol(sourceFile, reference);
+            if (!source || source.node === target.node)
+                continue;
+            addEdge(state, symbolEndpoint(source, state.projectRoot), symbolEndpoint(target, state.projectRoot), "reference");
+        }
+    }
+}
+function addHeritageEdges(state, requestContext) {
+    for (const source of new Set(state.locatedSymbols.values())) {
+        requestContext.checkpoint();
+        if (Node.isClassDeclaration(source.node)) {
+            const base = source.node.getExtends();
+            if (base) {
+                for (const target of projectLocatedDeclarations(state, declarationsForType(base.getType()), requestContext)) {
+                    addEdge(state, symbolEndpoint(source, state.projectRoot), symbolEndpoint(target, state.projectRoot), "extends");
+                }
+            }
+            for (const implemented of source.node.getImplements()) {
+                requestContext.checkpoint();
+                for (const target of projectLocatedDeclarations(state, declarationsForType(implemented.getType()), requestContext)) {
+                    addEdge(state, symbolEndpoint(source, state.projectRoot), symbolEndpoint(target, state.projectRoot), "implements");
+                }
+            }
+        }
+        if (Node.isInterfaceDeclaration(source.node)) {
+            for (const base of source.node.getBaseTypes()) {
+                requestContext.checkpoint();
+                for (const target of projectLocatedDeclarations(state, declarationsForType(base), requestContext)) {
+                    addEdge(state, symbolEndpoint(source, state.projectRoot), symbolEndpoint(target, state.projectRoot), "extends");
+                }
+            }
+        }
+    }
+}
+function addModuleEdges(state, requestContext) {
+    for (const sourceFile of state.sourceFiles.values()) {
+        requestContext.checkpoint();
+        for (const declaration of sourceFile.getImportDeclarations()) {
+            requestContext.checkpoint();
+            const targetFile = declaration.getModuleSpecifierSourceFile();
+            if (!targetFile || !state.sourceFiles.has(sourceFileKey(targetFile.getFilePath())))
+                continue;
+            const source = moduleEndpoint(sourceFile, state.projectRoot, declaration);
+            let emitted = false;
+            for (const specifier of declaration.getNamedImports()) {
+                const targets = projectLocatedDeclarations(state, declarationsForSymbol(symbolFromNameNode(specifier.getNameNode())), requestContext);
+                for (const target of targets) {
+                    addEdge(state, source, symbolEndpoint(target, state.projectRoot), "import");
+                    emitted = true;
+                }
+            }
+            for (const identifier of [declaration.getDefaultImport(), declaration.getNamespaceImport()]) {
+                if (!identifier)
+                    continue;
+                for (const target of projectLocatedDeclarations(state, declarationsForSymbol(identifier.getSymbol()), requestContext)) {
+                    addEdge(state, source, symbolEndpoint(target, state.projectRoot), "import");
+                    emitted = true;
+                }
+            }
+            if (!emitted)
+                addEdge(state, source, moduleEndpoint(targetFile, state.projectRoot), "import");
+        }
+        for (const declaration of sourceFile.getExportDeclarations()) {
+            requestContext.checkpoint();
+            const targetFile = declaration.getModuleSpecifierSourceFile();
+            const source = moduleEndpoint(sourceFile, state.projectRoot, declaration);
+            let emitted = false;
+            for (const specifier of declaration.getNamedExports()) {
+                const declarations = [...specifier.getLocalTargetDeclarations()];
+                if (targetFile) {
+                    declarations.push(...(targetFile.getExportedDeclarations().get(specifier.getName()) ?? []));
+                }
+                for (const target of projectLocatedDeclarations(state, declarations, requestContext)) {
+                    addEdge(state, source, symbolEndpoint(target, state.projectRoot), "export");
+                    emitted = true;
+                }
+            }
+            if (!emitted && declaration.getNamedExports().length === 0 && targetFile) {
+                addEdge(state, source, moduleEndpoint(targetFile, state.projectRoot), "export");
+            }
+        }
+    }
+}
+const DEFAULT_COMPILER_RELATIONSHIP_WORK_ITEMS = 100_000;
+class ScopedRelationshipLimitReached extends Error {
+    constructor() {
+        super("Scoped compiler relationship discovery reached its edge limit.");
+        this.name = "ScopedRelationshipLimitReached";
+    }
+}
+class ScopedRelationshipWorkLimitReached extends Error {
+    constructor() {
+        super("Scoped compiler relationship discovery reached its work limit.");
+        this.name = "ScopedRelationshipWorkLimitReached";
+    }
+}
+function consumeRelationshipWork(state, budget) {
+    state.requestContext.checkpoint();
+    if (budget.remaining <= 0) {
+        budget.limitReached = true;
+        throw new ScopedRelationshipWorkLimitReached();
+    }
+    budget.remaining -= 1;
+    budget.consumed += 1;
+}
+function consumeScopedWork(state, collector) {
+    consumeRelationshipWork(state, collector.workBudget);
+}
+function reserveScopedWork(state, collector, count) {
+    state.requestContext.checkpoint();
+    const budget = collector.workBudget;
+    if (count > budget.remaining) {
+        budget.consumed += budget.remaining;
+        budget.remaining = 0;
+        budget.limitReached = true;
+        throw new ScopedRelationshipWorkLimitReached();
+    }
+    budget.remaining -= count;
+    budget.consumed += count;
+}
+function scopedDeclarationsForSymbol(state, collector, symbol) {
+    if (!symbol)
+        return [];
+    consumeScopedWork(state, collector);
+    const resolved = symbol.getAliasedSymbol() ?? symbol;
+    const declarationCount = resolved.compilerSymbol.declarations?.length ?? 0;
+    reserveScopedWork(state, collector, declarationCount);
+    const declarations = resolved.getDeclarations();
+    if (declarations.length !== declarationCount) {
+        throw new Error("Compiler symbol declarations changed during scoped relationship discovery.");
+    }
+    return declarations;
+}
+function scopedDeclarationsForType(state, collector, type) {
+    consumeScopedWork(state, collector);
+    const declarations = new Map();
+    for (const symbol of [type.getSymbol(), type.getAliasSymbol()]) {
+        for (const declaration of scopedDeclarationsForSymbol(state, collector, symbol)) {
+            declarations.set(declaration, declaration);
+        }
+    }
+    return [...declarations.values()];
+}
+function forEachScopedBaseType(state, collector, node, visit) {
+    if (!Node.isClassDeclaration(node) && !Node.isInterfaceDeclaration(node))
+        return;
+    consumeScopedWork(state, collector);
+    const baseTypeCount = node.getType().compilerType.getBaseTypes()?.length ?? 0;
+    reserveScopedWork(state, collector, baseTypeCount);
+    const baseTypes = node.getBaseTypes();
+    if (baseTypes.length !== baseTypeCount) {
+        throw new Error("Compiler base types changed during scoped relationship discovery.");
+    }
+    for (const baseType of baseTypes)
+        visit(baseType);
+}
+function forEachScopedImplementedType(state, collector, node, visit) {
+    if (!Node.isClassDeclaration(node))
+        return;
+    consumeScopedWork(state, collector);
+    const implementationCount = node.compilerNode.heritageClauses?.find((clause) => clause.token === SyntaxKind.ImplementsKeyword)?.types.length ?? 0;
+    reserveScopedWork(state, collector, implementationCount);
+    const implementations = node.getImplements();
+    if (implementations.length !== implementationCount) {
+        throw new Error("Compiler implementations changed during scoped relationship discovery.");
+    }
+    for (const implementation of implementations) {
+        consumeScopedWork(state, collector);
+        visit(implementation.getType());
+    }
+}
+function scopedSourceFiles(state, collector) {
+    const sourceFiles = [];
+    if (collector.allowedNeighborFilePaths) {
+        for (const filePath of collector.allowedNeighborFilePaths) {
+            consumeScopedWork(state, collector);
+            const sourceFile = state.project.getSourceFile(filePath);
+            if (sourceFile)
+                sourceFiles.push(sourceFile);
+        }
+        return sourceFiles;
+    }
+    const program = state.project.getProgram().compilerObject;
+    const filePaths = [];
+    for (const compilerSourceFile of program.getSourceFiles()) {
+        consumeScopedWork(state, collector);
+        const filePath = compilerSourceFile.fileName;
+        if (!isProjectScopedFile(state.projectRoot, filePath))
+            continue;
+        filePaths.push(filePath);
+    }
+    filePaths.sort((left, right) => left.localeCompare(right));
+    for (const filePath of filePaths) {
+        const sourceFile = state.project.getSourceFile(filePath);
+        if (sourceFile)
+            sourceFiles.push(sourceFile);
+    }
+    return sourceFiles;
+}
+function forEachScopedSymbol(state, collector, sourceFile, visit) {
+    forEachLocatedSymbol(sourceFile, (candidate) => {
+        consumeScopedWork(state, collector);
+        visit(candidate);
+    });
+}
+function scopedContainingSymbol(state, collector, sourceFile, node) {
+    let selected;
+    const nodeStart = node.getStart();
+    const nodeEnd = node.getEnd();
+    forEachLocatedSymbol(sourceFile, (symbol) => {
+        consumeScopedWork(state, collector);
+        if (symbol.node.getStart() > nodeStart)
+            return false;
+        if (symbol.node.getEnd() < nodeEnd)
+            return;
+        if (!selected) {
+            selected = symbol;
+            return;
+        }
+        const order = (() => {
+            const left = symbol;
+            const right = selected;
+            const leftSize = left.node.getEnd() - left.node.getStart();
+            const rightSize = right.node.getEnd() - right.node.getStart();
+            return (leftSize - rightSize ||
+                left.line - right.line ||
+                left.symbolPath.localeCompare(right.symbolPath));
+        })();
+        if (order < 0)
+            selected = symbol;
+    });
+    return selected;
+}
+function scopedLocatedDeclarations(state, collector, declarations) {
+    const unique = new Map();
+    for (const declaration of declarations) {
+        state.requestContext.checkpoint();
+        consumeScopedWork(state, collector);
+        const sourceFile = declaration.getSourceFile();
+        if (!isProjectScopedFile(state.projectRoot, sourceFile.getFilePath()))
+            continue;
+        if (state.project.getSourceFile(sourceFile.getFilePath()) !== sourceFile)
+            continue;
+        forEachLocatedSymbol(sourceFile, (candidate) => {
+            consumeScopedWork(state, collector);
+            if (candidate.node !== declaration)
+                return;
+            unique.set(declaration, candidate);
+            return false;
+        });
+    }
+    return [...unique.values()];
+}
+function addScopedEdge(state, collector, source, target, kind) {
+    addScopedResolvedEdge(collector, createRelationshipEdge({
+        source,
+        target,
+        kind,
+        provenance: "compiler",
+        confidence: "exact",
+        resolution: "resolved",
+        freshness: state.freshness,
+    }));
+}
+function createScopedEdge(state, source, target, kind) {
+    return createRelationshipEdge({
+        source,
+        target,
+        kind,
+        provenance: "compiler",
+        confidence: "exact",
+        resolution: "resolved",
+        freshness: state.freshness,
+    });
+}
+function scopedIncidentNeighborKey(collector, edge) {
+    const sourceKey = endpointKey(edge.source);
+    const targetKey = endpointKey(edge.target);
+    if (collector.direction !== "incoming" && sourceKey === collector.endpointKey)
+        return targetKey;
+    if (collector.direction !== "outgoing" && targetKey === collector.endpointKey)
+        return sourceKey;
+    return undefined;
+}
+function addScopedResolvedEdge(collector, edge) {
+    if (!collector.relationshipKinds.has(edge.kind))
+        return;
+    if (collector.excludedRelationshipIds.has(edge.relationship_id))
+        return;
+    const neighborKey = scopedIncidentNeighborKey(collector, edge);
+    if (!neighborKey || collector.edges.has(edge.relationship_id))
+        return;
+    if (collector.allowedNeighborKeys && !collector.allowedNeighborKeys.has(neighborKey)) {
+        collector.excludedNeighbors = true;
+        return;
+    }
+    if (collector.edges.size >= collector.maxEdges)
+        throw new ScopedRelationshipLimitReached();
+    collector.edges.set(edge.relationship_id, edge);
+    if (collector.stopAfterFirst)
+        throw new ScopedRelationshipLimitReached();
+}
+function scopedEdgeOrder(left, right) {
+    return (left.kind.localeCompare(right.kind) ||
+        left.source.file.localeCompare(right.source.file) ||
+        left.source.selector.localeCompare(right.source.selector) ||
+        left.target.file.localeCompare(right.target.file) ||
+        left.target.selector.localeCompare(right.target.selector) ||
+        left.relationship_id.localeCompare(right.relationship_id));
+}
+function scopedNeighborOrder(rootKey, left, right) {
+    const leftEndpoint = endpointKey(left.source) === rootKey ? left.target : left.source;
+    const rightEndpoint = endpointKey(right.source) === rootKey ? right.target : right.source;
+    return (leftEndpoint.file.localeCompare(rightEndpoint.file) ||
+        leftEndpoint.selector.localeCompare(rightEndpoint.selector) ||
+        leftEndpoint.symbol_path.localeCompare(rightEndpoint.symbol_path) ||
+        scopedEdgeOrder(left, right));
+}
+function createScopedCandidateSet(collector) {
+    const candidates = {
+        collector,
+        indexes: new Map(),
+        values: [],
+        capacity: collector.stopAfterFirst ? 1 : collector.maxEdges + 1,
+        push(candidate) {
+            retainScopedCandidate(candidates, candidate);
+        },
+    };
+    return candidates;
+}
+function swapScopedCandidates(candidates, left, right) {
+    [candidates.values[left], candidates.values[right]] = [
+        candidates.values[right],
+        candidates.values[left],
+    ];
+    candidates.indexes.set(candidates.values[left].relationship_id, left);
+    candidates.indexes.set(candidates.values[right].relationship_id, right);
+}
+function retainScopedCandidate(candidates, candidate) {
+    if (!candidates.collector.relationshipKinds.has(candidate.kind))
+        return;
+    if (candidates.collector.excludedRelationshipIds.has(candidate.relationship_id))
+        return;
+    const neighborKey = scopedIncidentNeighborKey(candidates.collector, candidate);
+    if (!neighborKey)
+        return;
+    if (candidates.collector.allowedNeighborKeys &&
+        !candidates.collector.allowedNeighborKeys.has(neighborKey)) {
+        candidates.collector.excludedNeighbors = true;
+        return;
+    }
+    if (candidates.indexes.has(candidate.relationship_id))
+        return;
+    const order = (left, right) => scopedNeighborOrder(candidates.collector.endpointKey, left, right);
+    if (candidates.values.length < candidates.capacity) {
+        candidates.values.push(candidate);
+        let index = candidates.values.length - 1;
+        candidates.indexes.set(candidate.relationship_id, index);
+        while (index > 0) {
+            const parent = Math.floor((index - 1) / 2);
+            if (order(candidates.values[parent], candidates.values[index]) >= 0)
+                break;
+            swapScopedCandidates(candidates, parent, index);
+            index = parent;
+        }
+        return;
+    }
+    if (order(candidate, candidates.values[0]) >= 0)
+        return;
+    candidates.indexes.delete(candidates.values[0].relationship_id);
+    candidates.values[0] = candidate;
+    candidates.indexes.set(candidate.relationship_id, 0);
+    let index = 0;
+    while (true) {
+        const left = index * 2 + 1;
+        const right = left + 1;
+        if (left >= candidates.values.length)
+            return;
+        let worst = left;
+        if (right < candidates.values.length &&
+            order(candidates.values[right], candidates.values[left]) > 0) {
+            worst = right;
+        }
+        if (order(candidates.values[index], candidates.values[worst]) >= 0)
+            return;
+        swapScopedCandidates(candidates, index, worst);
+        index = worst;
+    }
+}
+function flushScopedCandidates(candidates) {
+    candidates.values.sort((left, right) => scopedNeighborOrder(candidates.collector.endpointKey, left, right));
+    for (const candidate of candidates.values) {
+        addScopedResolvedEdge(candidates.collector, candidate);
+    }
+}
+function addScopedCandidates(collector, candidates) {
+    if (candidates.collector !== collector) {
+        throw new Error("Scoped relationship candidates belong to a different collector.");
+    }
+    flushScopedCandidates(candidates);
+}
+function collectScopedHeritageEdges(state, edges, source, candidates) {
+    consumeScopedWork(state, edges);
+    const sourceEndpoint = symbolEndpoint(source, state.projectRoot);
+    if (Node.isClassDeclaration(source.node)) {
+        const base = source.node.getExtends();
+        if (base && edges.relationshipKinds.has("extends")) {
+            for (const target of scopedLocatedDeclarations(state, edges, scopedDeclarationsForType(state, edges, base.getType()))) {
+                candidates.push(createScopedEdge(state, sourceEndpoint, symbolEndpoint(target, state.projectRoot), "extends"));
+            }
+        }
+        if (edges.relationshipKinds.has("implements")) {
+            forEachScopedImplementedType(state, edges, source.node, (implementedType) => {
+                for (const target of scopedLocatedDeclarations(state, edges, scopedDeclarationsForType(state, edges, implementedType))) {
+                    candidates.push(createScopedEdge(state, sourceEndpoint, symbolEndpoint(target, state.projectRoot), "implements"));
+                }
+            });
+        }
+    }
+    if (Node.isInterfaceDeclaration(source.node) && edges.relationshipKinds.has("extends")) {
+        forEachScopedBaseType(state, edges, source.node, (base) => {
+            for (const target of scopedLocatedDeclarations(state, edges, scopedDeclarationsForType(state, edges, base))) {
+                candidates.push(createScopedEdge(state, sourceEndpoint, symbolEndpoint(target, state.projectRoot), "extends"));
+            }
+        });
+    }
+}
+function addScopedHeritageEdges(state, edges, source) {
+    const candidates = createScopedCandidateSet(edges);
+    collectScopedHeritageEdges(state, edges, source, candidates);
+    addScopedCandidates(edges, candidates);
+}
+function forEachNamedImportSpecifier(declaration, visit) {
+    const namedBindings = declaration.getImportClause()?.getNamedBindings();
+    if (!Node.isNamedImports(namedBindings))
+        return;
+    namedBindings.forEachChild((specifier) => {
+        if (Node.isImportSpecifier(specifier))
+            visit(specifier);
+    });
+}
+function forEachNamedExportSpecifier(declaration, visit) {
+    declaration.forEachChild((namedExports) => {
+        if (!Node.isNamedExports(namedExports))
+            return;
+        namedExports.forEachChild((specifier) => {
+            if (Node.isExportSpecifier(specifier))
+                visit(specifier);
+        });
+    });
+}
+function addScopedModuleEdges(state, edges, sourceFile) {
+    const candidates = createScopedCandidateSet(edges);
+    sourceFile.forEachChild((declaration) => {
+        consumeScopedWork(state, edges);
+        if (Node.isImportDeclaration(declaration) && edges.relationshipKinds.has("import")) {
+            const targetFile = declaration.getModuleSpecifierSourceFile();
+            if (!targetFile ||
+                !isProjectScopedFile(state.projectRoot, targetFile.getFilePath()) ||
+                state.project.getSourceFile(targetFile.getFilePath()) !== targetFile)
+                return;
+            const source = moduleEndpoint(sourceFile, state.projectRoot, declaration);
+            let emitted = false;
+            forEachNamedImportSpecifier(declaration, (specifier) => {
+                consumeScopedWork(state, edges);
+                for (const target of scopedLocatedDeclarations(state, edges, scopedDeclarationsForSymbol(state, edges, symbolFromNameNode(specifier.getNameNode())))) {
+                    candidates.push(createScopedEdge(state, source, symbolEndpoint(target, state.projectRoot), "import"));
+                    emitted = true;
+                }
+            });
+            for (const identifier of [declaration.getDefaultImport(), declaration.getNamespaceImport()]) {
+                if (!identifier)
+                    continue;
+                consumeScopedWork(state, edges);
+                for (const target of scopedLocatedDeclarations(state, edges, scopedDeclarationsForSymbol(state, edges, identifier.getSymbol()))) {
+                    candidates.push(createScopedEdge(state, source, symbolEndpoint(target, state.projectRoot), "import"));
+                    emitted = true;
+                }
+            }
+            if (!emitted) {
+                candidates.push(createScopedEdge(state, source, moduleEndpoint(targetFile, state.projectRoot), "import"));
+            }
+            return;
+        }
+        if (Node.isExportDeclaration(declaration) && edges.relationshipKinds.has("export")) {
+            const targetFile = declaration.getModuleSpecifierSourceFile();
+            if (targetFile && !isProjectScopedFile(state.projectRoot, targetFile.getFilePath()))
+                return;
+            const source = moduleEndpoint(sourceFile, state.projectRoot, declaration);
+            let emitted = false;
+            let hasNamedExports = false;
+            forEachNamedExportSpecifier(declaration, (specifier) => {
+                hasNamedExports = true;
+                consumeScopedWork(state, edges);
+                for (const target of scopedLocatedDeclarations(state, edges, scopedDeclarationsForSymbol(state, edges, specifier.getLocalTargetSymbol()))) {
+                    candidates.push(createScopedEdge(state, source, symbolEndpoint(target, state.projectRoot), "export"));
+                    emitted = true;
+                }
+            });
+            if (!emitted && !hasNamedExports && targetFile) {
+                candidates.push(createScopedEdge(state, source, moduleEndpoint(targetFile, state.projectRoot), "export"));
+            }
+        }
+    });
+    addScopedCandidates(edges, candidates);
+}
+function addScopedOutgoingReferences(state, edges, source) {
+    const candidates = createScopedCandidateSet(edges);
+    const sourceFile = source.node.getSourceFile();
+    source.node.forEachDescendant((reference) => {
+        consumeScopedWork(state, edges);
+        if (!isCompilerReferenceNode(reference))
+            return;
+        if (scopedContainingSymbol(state, edges, sourceFile, reference)?.node !== source.node)
+            return;
+        const declarations = scopedDeclarationsForSymbol(state, edges, compilerReferenceSymbol(reference));
+        const declarationOwner = referenceDeclarationNameOwner(reference);
+        const referencedDeclarations = declarationOwner
+            ? compilerDeclarationNameTargets(declarationOwner, declarations)
+            : declarations;
+        for (const target of scopedLocatedDeclarations(state, edges, referencedDeclarations)) {
+            if (target.node === source.node)
+                continue;
+            candidates.push(createScopedEdge(state, symbolEndpoint(source, state.projectRoot), symbolEndpoint(target, state.projectRoot), "reference"));
+        }
+    });
+    addScopedCandidates(edges, candidates);
+}
+function isCompilerReferenceNode(node) {
+    return (Node.isReferenceFindable(node) ||
+        Node.isStringLiteral(node) ||
+        (Node.isThisExpression(node) && isStaticThisReference(node)));
+}
+function isStaticThisReference(node) {
+    for (let current = node.getParent(); current; current = current.getParent()) {
+        if (Node.isArrowFunction(current) ||
+            Node.isFunctionExpression(current) ||
+            Node.isFunctionDeclaration(current)) {
+            return false;
+        }
+        if (current.getKind() === SyntaxKind.ClassStaticBlockDeclaration)
+            return true;
+        if (Node.isMethodDeclaration(current) ||
+            Node.isGetAccessorDeclaration(current) ||
+            Node.isSetAccessorDeclaration(current)) {
+            const modifiers = current.compilerNode
+                .modifiers;
+            return modifiers?.some((modifier) => modifier.kind === SyntaxKind.StaticKeyword) ?? false;
+        }
+        if (Node.isPropertyDeclaration(current))
+            return false;
+        if (Node.isClassDeclaration(current) || Node.isClassExpression(current))
+            return false;
+    }
+    return false;
+}
+function compilerReferenceSymbol(node) {
+    if (Node.isShorthandPropertyAssignment(node))
+        return node.getValueSymbol();
+    const parent = node.getParent();
+    if (parent && Node.isShorthandPropertyAssignment(parent))
+        return parent.getValueSymbol();
+    return node.getSymbol();
+}
+function isReferenceDeclaration(node) {
+    return (Node.isFunctionDeclaration(node) ||
+        Node.isMethodDeclaration(node) ||
+        Node.isMethodSignature(node) ||
+        Node.isPropertyDeclaration(node) ||
+        Node.isPropertySignature(node) ||
+        Node.isGetAccessorDeclaration(node) ||
+        Node.isSetAccessorDeclaration(node));
+}
+function referenceDeclarationNameOwner(reference) {
+    if (isReferenceDeclaration(reference))
+        return reference;
+    const parent = reference.getParent();
+    if (!parent || !isReferenceDeclaration(parent))
+        return undefined;
+    const nameNode = parent.compilerNode
+        .name;
+    const referenceNode = reference.compilerNode;
+    return nameNode &&
+        nameNode.kind === referenceNode.kind &&
+        nameNode.pos === referenceNode.pos &&
+        nameNode.end === referenceNode.end
+        ? parent
+        : undefined;
+}
+function sameCompilerNode(left, right) {
+    return (left.getSourceFile().getFilePath() === right.getSourceFile().getFilePath() &&
+        left.getKind() === right.getKind() &&
+        left.getStart() === right.getStart() &&
+        left.getEnd() === right.getEnd());
+}
+function compilerDeclarationNameTargets(source, declarations) {
+    const sourceIndex = declarations.findIndex((declaration) => sameCompilerNode(declaration, source));
+    if (sourceIndex <= 0)
+        return [];
+    return declarations.filter((declaration) => !sameCompilerNode(declaration, source));
+}
+function scopedMemberName(node) {
+    if (Node.isMethodDeclaration(node) ||
+        Node.isMethodSignature(node) ||
+        Node.isPropertyDeclaration(node) ||
+        Node.isPropertySignature(node) ||
+        Node.isGetAccessorDeclaration(node) ||
+        Node.isSetAccessorDeclaration(node)) {
+        const nameNode = node.getNameNode();
+        if (nameNode.getKind() === SyntaxKind.ComputedPropertyName ||
+            nameNode.getKind() === SyntaxKind.PrivateIdentifier ||
+            (Node.isModifierable(node) && node.hasModifier(SyntaxKind.PrivateKeyword)) ||
+            (Node.isStaticable(node) && node.isStatic())) {
+            return undefined;
+        }
+        return node.getName();
+    }
+    return undefined;
+}
+function scopedMemberContainer(node) {
+    return node.getFirstAncestor((ancestor) => Node.isClassDeclaration(ancestor) || Node.isInterfaceDeclaration(ancestor));
+}
+function scopedBaseContainers(state, collector, container) {
+    const discovered = new Set();
+    const pending = [container];
+    while (pending.length > 0) {
+        consumeScopedWork(state, collector);
+        const current = pending.pop();
+        const discoverType = (type) => {
+            for (const declaration of scopedDeclarationsForType(state, collector, type)) {
+                if ((Node.isClassDeclaration(declaration) || Node.isInterfaceDeclaration(declaration)) &&
+                    !discovered.has(declaration)) {
+                    discovered.add(declaration);
+                    pending.push(declaration);
+                }
+            }
+        };
+        if (Node.isClassDeclaration(current) || Node.isInterfaceDeclaration(current)) {
+            forEachScopedBaseType(state, collector, current, discoverType);
+            forEachScopedImplementedType(state, collector, current, discoverType);
+        }
+    }
+    return discovered;
+}
+function addScopedMemberRelationships(state, edges, target) {
+    const targetName = scopedMemberName(target.node);
+    const targetContainer = scopedMemberContainer(target.node);
+    if (!targetName || !targetContainer)
+        return;
+    const targetBases = scopedBaseContainers(state, edges, targetContainer);
+    const candidates = createScopedCandidateSet(edges);
+    for (const sourceFile of scopedSourceFiles(state, edges)) {
+        consumeScopedWork(state, edges);
+        forEachScopedSymbol(state, edges, sourceFile, (candidate) => {
+            if (candidate.node === target.node || scopedMemberName(candidate.node) !== targetName) {
+                return;
+            }
+            const candidateContainer = scopedMemberContainer(candidate.node);
+            if (!candidateContainer)
+                return;
+            const related = targetBases.has(candidateContainer) ||
+                scopedBaseContainers(state, edges, candidateContainer).has(targetContainer);
+            if (!related)
+                return;
+            const candidateEndpoint = symbolEndpoint(candidate, state.projectRoot);
+            const targetEndpoint = symbolEndpoint(target, state.projectRoot);
+            const pairs = [
+                [candidateEndpoint, targetEndpoint],
+                [targetEndpoint, candidateEndpoint],
+            ];
+            pairs.sort((left, right) => [left[0].file, left[0].selector, left[1].file, left[1].selector]
+                .join("\u0000")
+                .localeCompare([right[0].file, right[0].selector, right[1].file, right[1].selector].join("\u0000")));
+            for (const [sourceEndpoint, targetEndpoint] of pairs) {
+                candidates.push(createScopedEdge(state, sourceEndpoint, targetEndpoint, "reference"));
+            }
+        });
+    }
+    addScopedCandidates(edges, candidates);
+}
+function addScopedIncomingHeritageRelationships(state, edges) {
+    const candidates = createScopedCandidateSet(edges);
+    for (const sourceFile of scopedSourceFiles(state, edges)) {
+        consumeScopedWork(state, edges);
+        forEachScopedSymbol(state, edges, sourceFile, (candidate) => {
+            collectScopedHeritageEdges(state, edges, candidate, candidates);
+        });
+    }
+    addScopedCandidates(edges, candidates);
+}
+function addScopedIncomingReferences(state, edges, target) {
+    for (const sourceFile of scopedSourceFiles(state, edges)) {
+        consumeScopedWork(state, edges);
+        const candidates = createScopedCandidateSet(edges);
+        sourceFile.forEachDescendant((reference) => {
+            consumeScopedWork(state, edges);
+            if (!isCompilerReferenceNode(reference))
+                return;
+            const declarations = scopedDeclarationsForSymbol(state, edges, compilerReferenceSymbol(reference));
+            const declarationOwner = referenceDeclarationNameOwner(reference);
+            if (declarationOwner &&
+                !compilerDeclarationNameTargets(declarationOwner, declarations).some((declaration) => sameCompilerNode(declaration, target.node))) {
+                return;
+            }
+            if (!declarationOwner &&
+                !declarations.some((declaration) => sameCompilerNode(declaration, target.node))) {
+                return;
+            }
+            const source = scopedContainingSymbol(state, edges, sourceFile, reference);
+            if (source && source.node !== target.node) {
+                candidates.push(createScopedEdge(state, symbolEndpoint(source, state.projectRoot), symbolEndpoint(target, state.projectRoot), "reference"));
+            }
+        });
+        addScopedCandidates(edges, candidates);
+    }
+}
+function addScopedIncomingImports(state, edges, target) {
+    const targetEndpoint = symbolEndpoint(target, state.projectRoot);
+    for (const sourceFile of scopedSourceFiles(state, edges)) {
+        consumeScopedWork(state, edges);
+        sourceFile.forEachChild((declaration) => {
+            consumeScopedWork(state, edges);
+            if (!Node.isImportDeclaration(declaration))
+                return;
+            let resolvesTarget = false;
+            forEachNamedImportSpecifier(declaration, (specifier) => {
+                consumeScopedWork(state, edges);
+                resolvesTarget ||= scopedDeclarationsForSymbol(state, edges, specifier.getNameNode().getSymbol()).some((candidate) => candidate === target.node);
+            });
+            for (const identifier of [declaration.getDefaultImport(), declaration.getNamespaceImport()]) {
+                if (!identifier)
+                    continue;
+                consumeScopedWork(state, edges);
+                resolvesTarget ||= scopedDeclarationsForSymbol(state, edges, identifier.getSymbol()).some((candidate) => candidate === target.node);
+            }
+            if (resolvesTarget) {
+                addScopedEdge(state, edges, moduleEndpoint(sourceFile, state.projectRoot, declaration), targetEndpoint, "import");
+            }
+        });
+    }
+}
+function addScopedIncomingExports(state, edges, target) {
+    const targetEndpoint = symbolEndpoint(target, state.projectRoot);
+    for (const sourceFile of scopedSourceFiles(state, edges)) {
+        consumeScopedWork(state, edges);
+        sourceFile.forEachChild((declaration) => {
+            consumeScopedWork(state, edges);
+            if (!Node.isExportDeclaration(declaration))
+                return;
+            let resolvesTarget = false;
+            forEachNamedExportSpecifier(declaration, (specifier) => {
+                consumeScopedWork(state, edges);
+                resolvesTarget ||= scopedDeclarationsForSymbol(state, edges, specifier.getLocalTargetSymbol()).some((candidate) => candidate === target.node);
+            });
+            if (resolvesTarget) {
+                addScopedEdge(state, edges, moduleEndpoint(sourceFile, state.projectRoot, declaration), targetEndpoint, "export");
+            }
+        });
+    }
+}
+function endpointKey(endpoint) {
+    return `${endpoint.file}\u0000${endpoint.symbol_path}\u0000${endpoint.selector}`;
+}
+function scopedLocatedEndpoint(state, collector, endpoint) {
+    consumeScopedWork(state, collector);
+    const sourceFile = state.project.getSourceFile(path.resolve(state.projectRoot, endpoint.file));
+    if (!sourceFile)
+        throw new Error("Impact relationship endpoint is outside the compiler project.");
+    if (endpoint.symbol_path === "<module>")
+        return { sourceFile };
+    const symbol = findLocatedSymbol(sourceFile, endpoint.selector, () => consumeScopedWork(state, collector));
+    if (!symbol || endpointKey(symbolEndpoint(symbol, state.projectRoot)) !== endpointKey(endpoint)) {
+        throw new Error("Impact relationship endpoint no longer resolves to the same declaration.");
+    }
+    return { sourceFile, symbol };
+}
+function addScopedIncomingModuleEdges(state, edges) {
+    for (const sourceFile of scopedSourceFiles(state, edges)) {
+        addScopedModuleEdges(state, edges, sourceFile);
+    }
+}
+export function createCompilerRelationshipResolver(project, projectRoot, freshness, requestContext = NO_REQUEST_CONTEXT) {
+    requestContext.checkpoint();
+    const state = {
+        project,
+        projectRoot,
+        freshness: normalizeFreshness(freshness),
+        requestContext,
+    };
+    return {
+        edgesFor(endpoint, query) {
+            requestContext.checkpoint();
+            const key = endpointKey(endpoint);
+            if (!Number.isSafeInteger(query.max_edges) || query.max_edges < 1) {
+                throw new Error("Compiler relationship max_edges must be a positive safe integer.");
+            }
+            const maxWorkItems = query.max_work_items ?? DEFAULT_COMPILER_RELATIONSHIP_WORK_ITEMS;
+            if (!Number.isSafeInteger(maxWorkItems) || maxWorkItems < 1) {
+                throw new Error("Compiler relationship max_work_items must be a positive safe integer.");
+            }
+            const direction = assertEnum(query.direction, ["incoming", "outgoing", "both"], "direction");
+            const relationshipKinds = new Set(query.relationship_kinds.map((kind) => assertEnum(kind, RELATIONSHIP_EDGE_KINDS, "edge kind")));
+            const workBudget = {
+                remaining: maxWorkItems,
+                consumed: 0,
+                limitReached: false,
+            };
+            const allowedNeighborKeys = query.allowed_neighbor_keys
+                ? new Set(query.allowed_neighbor_keys)
+                : undefined;
+            const allowedNeighborFilePaths = allowedNeighborKeys ? new Set() : undefined;
+            try {
+                for (const neighborKey of query.allowed_neighbor_keys ?? []) {
+                    consumeRelationshipWork(state, workBudget);
+                    allowedNeighborFilePaths.add(path.resolve(projectRoot, neighborKey.split("\u0000", 1)[0]));
+                }
+            }
+            catch (error) {
+                if (!(error instanceof ScopedRelationshipWorkLimitReached))
+                    throw error;
+                return {
+                    edges: [],
+                    incomplete: true,
+                    work_items: workBudget.consumed,
+                    work_limit_reached: true,
+                    excluded_neighbors: false,
+                };
+            }
+            const excludedRelationshipIds = new Set(query.excluded_relationship_ids ?? []);
+            const endpointCollector = {
+                edges: new Map(),
+                endpointKey: key,
+                direction,
+                relationshipKinds,
+                maxEdges: query.max_edges,
+                stopAfterFirst: query.stop_after_first === true,
+                allowedNeighborKeys,
+                allowedNeighborFilePaths: allowedNeighborFilePaths
+                    ? [...allowedNeighborFilePaths].sort((left, right) => left.localeCompare(right))
+                    : undefined,
+                excludedRelationshipIds,
+                workBudget,
+                excludedNeighbors: false,
+            };
+            let located;
+            try {
+                located = scopedLocatedEndpoint(state, endpointCollector, endpoint);
+            }
+            catch (error) {
+                if (!(error instanceof ScopedRelationshipWorkLimitReached))
+                    throw error;
+                return {
+                    edges: [],
+                    incomplete: true,
+                    work_items: workBudget.consumed,
+                    work_limit_reached: true,
+                    excluded_neighbors: false,
+                };
+            }
+            const outgoing = direction === "outgoing" || direction === "both";
+            const incoming = direction === "incoming" || direction === "both";
+            const producers = [];
+            if (located.symbol) {
+                if (outgoing && (relationshipKinds.has("extends") || relationshipKinds.has("implements"))) {
+                    producers.push({
+                        kinds: ["extends", "implements"],
+                        collect: (collector) => addScopedHeritageEdges(state, collector, located.symbol),
+                    });
+                }
+                if (incoming &&
+                    (Node.isClassDeclaration(located.symbol.node) ||
+                        Node.isInterfaceDeclaration(located.symbol.node)) &&
+                    (relationshipKinds.has("extends") || relationshipKinds.has("implements"))) {
+                    producers.push({
+                        kinds: ["extends", "implements"],
+                        collect: (collector) => addScopedIncomingHeritageRelationships(state, collector),
+                    });
+                }
+                if (relationshipKinds.has("reference")) {
+                    producers.push({
+                        kinds: ["reference"],
+                        collect: (collector) => addScopedMemberRelationships(state, collector, located.symbol),
+                    });
+                }
+                if (outgoing && relationshipKinds.has("reference")) {
+                    producers.push({
+                        kinds: ["reference"],
+                        collect: (collector) => addScopedOutgoingReferences(state, collector, located.symbol),
+                    });
+                }
+                if (incoming && relationshipKinds.has("reference")) {
+                    producers.push({
+                        kinds: ["reference"],
+                        collect: (collector) => addScopedIncomingReferences(state, collector, located.symbol),
+                    });
+                }
+                if (incoming && relationshipKinds.has("import")) {
+                    producers.push({
+                        kinds: ["import"],
+                        collect: (collector) => addScopedIncomingImports(state, collector, located.symbol),
+                    });
+                }
+                if (incoming && relationshipKinds.has("export")) {
+                    producers.push({
+                        kinds: ["export"],
+                        collect: (collector) => addScopedIncomingExports(state, collector, located.symbol),
+                    });
+                }
+            }
+            else {
+                for (const kind of ["import", "export"]) {
+                    if (!relationshipKinds.has(kind))
+                        continue;
+                    if (outgoing) {
+                        producers.push({
+                            kinds: [kind],
+                            collect: (collector) => addScopedModuleEdges(state, collector, located.sourceFile),
+                        });
+                    }
+                    if (incoming) {
+                        producers.push({
+                            kinds: [kind],
+                            collect: (collector) => addScopedIncomingModuleEdges(state, collector),
+                        });
+                    }
+                }
+            }
+            const merged = new Map();
+            let incomplete = false;
+            let excludedNeighbors = false;
+            for (const producer of producers) {
+                const collector = {
+                    edges: new Map(),
+                    endpointKey: key,
+                    direction,
+                    relationshipKinds: new Set(producer.kinds.filter((kind) => relationshipKinds.has(kind))),
+                    maxEdges: query.max_edges,
+                    stopAfterFirst: query.stop_after_first === true,
+                    allowedNeighborKeys,
+                    allowedNeighborFilePaths: endpointCollector.allowedNeighborFilePaths,
+                    excludedRelationshipIds,
+                    workBudget,
+                    excludedNeighbors: false,
+                };
+                try {
+                    producer.collect(collector);
+                }
+                catch (error) {
+                    if (!(error instanceof ScopedRelationshipLimitReached) &&
+                        !(error instanceof ScopedRelationshipWorkLimitReached)) {
+                        throw error;
+                    }
+                    incomplete = true;
+                }
+                for (const edge of collector.edges.values())
+                    merged.set(edge.relationship_id, edge);
+                excludedNeighbors ||= collector.excludedNeighbors;
+                if (workBudget.limitReached)
+                    break;
+            }
+            const ordered = [...merged.values()].sort((left, right) => scopedNeighborOrder(key, left, right));
+            if (ordered.length > query.max_edges)
+                incomplete = true;
+            const selected = ordered.slice(0, query.max_edges);
+            return {
+                edges: selected.sort((left, right) => left.relationship_id.localeCompare(right.relationship_id)),
+                incomplete,
+                work_items: workBudget.consumed,
+                work_limit_reached: workBudget.limitReached,
+                excluded_neighbors: excludedNeighbors,
+            };
+        },
+    };
+}
+export function collectCompilerRelationships(project, projectRoot, freshness, requestContext = NO_REQUEST_CONTEXT) {
+    requestContext.checkpoint();
+    const sourceFiles = project
+        .getSourceFiles()
+        .sort((left, right) => left.getFilePath().localeCompare(right.getFilePath()));
+    const locatedSymbols = new Map();
+    for (const sourceFile of sourceFiles) {
+        requestContext.checkpoint();
+        for (const symbol of collectSymbols(sourceFile)) {
+            requestContext.checkpoint();
+            locatedSymbols.set(symbol.node, symbol);
+        }
+    }
+    const state = {
+        projectRoot,
+        sourceFiles: new Map(sourceFiles.map((sourceFile) => [sourceFileKey(sourceFile.getFilePath()), sourceFile])),
+        locatedSymbols,
+        freshness: normalizeFreshness(freshness),
+        edges: new Map(),
+    };
+    requestContext.checkpoint();
+    addReferenceEdges(state, requestContext);
+    requestContext.checkpoint();
+    addModuleEdges(state, requestContext);
+    requestContext.checkpoint();
+    addHeritageEdges(state, requestContext);
+    requestContext.checkpoint();
+    return [...state.edges.values()].sort((left, right) => [left.kind, left.source.file, left.source.selector, left.target.file, left.target.selector]
+        .join("\u0000")
+        .localeCompare([
+        right.kind,
+        right.source.file,
+        right.source.selector,
+        right.target.file,
+        right.target.selector,
+    ].join("\u0000")));
+}