@samchon/graph 0.1.0

package/lib/mcp/createServer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createServer.js","sourceRoot":"","sources":["../../src/mcp/createServer.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,oCAA6C;AAE7C,kDAA0B;AAE1B,gDAGwB;AAGxB,sBACE,KAA8B,EAC9B,OAAe;IAEf,MAAM,UAAU,GAA6C;QAC3D,QAAQ,EAAE,OAAO;QACjB,IAAI,EAAE,eAAe;QACrB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAAmD;QAC9D,OAAO,EAAE,IAAI,qCAAuB,CAAC,KAAK,CAAC;KAC5C,CAAC;IACF,OAAO,IAAA,qBAAe,EAAC,UAAU,EAAE,OAAO,CAAC,CAAC;AAC9C,CAAC"}

package/lib/mcp/startServer.d.ts

@@ -0,0 +1,5 @@
+import { IBuildGraphOptions } from "../indexer/IBuildGraphOptions";
+export declare function startServer(options: IBuildGraphOptions & {
+    version: string;
+    graphFile?: string;
+}): Promise<void>;

package/lib/mcp/startServer.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServer = startServer;
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const node_fs_1 = __importDefault(require("node:fs"));
+const buildGraph_1 = require("../indexer/buildGraph");
+const GraphMemory_1 = require("../model/GraphMemory");
+const createServer_1 = require("./createServer");
+async function startServer(options) {
+    // A pre-built dump (`--graph-file`) serves immediately — the expensive index
+    // was paid once, outside this process, the same way comparator tools pay
+    // their `init`. Without it the resident graph builds lazily on first use.
+    const source = options.graphFile !== undefined
+        ? () => GraphMemory_1.GraphMemory.from(JSON.parse(node_fs_1.default.readFileSync(options.graphFile, "utf8")))
+        : () => (0, buildGraph_1.buildGraph)(options);
+    const server = (0, createServer_1.createServer)(source, options.version);
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+}
+//# sourceMappingURL=startServer.js.map

package/lib/mcp/startServer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"startServer.js","sourceRoot":"","sources":["../../src/mcp/startServer.ts"],"names":[],"mappings":";;;;;;AAAA,wEAAiF;AACjF,sDAAyB;AAEzB,sDAAmD;AAEnD,sDAAmD;AAEnD,iDAA8C;AAEvC,KAAK,sBACV,OAAqE;IAErE,6EAA6E;IAC7E,yEAAyE;IACzE,0EAA0E;IAC1E,MAAM,MAAM,GACV,OAAO,CAAC,SAAS,KAAK,SAAS;QAC7B,CAAC,CAAC,GAAG,EAAE,CAAC,yBAAW,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,iBAAE,CAAC,YAAY,CAAC,OAAO,CAAC,SAAU,EAAE,MAAM,CAAC,CAAe,CAAC;QAC/F,CAAC,CAAC,GAAG,EAAE,CAAC,IAAA,uBAAU,EAAC,OAAO,CAAC,CAAC;IAChC,MAAM,MAAM,GAAG,IAAA,2BAAY,EAAC,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IACrD,MAAM,SAAS,GAAG,IAAI,+BAAoB,EAAE,CAAC;IAC7C,MAAM,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;AAClC,CAAC"}

package/lib/model/GraphMemory.d.ts

@@ -0,0 +1,25 @@
+import { IGraphDiagnostic, IGraphDump, IGraphEdge, IGraphNode } from "../structures";
+export declare class GraphMemory {
+    private readonly byId;
+    private readonly outEdges;
+    private readonly inEdges;
+    private readonly byNameIndex;
+    private readonly bySymbolIndex;
+    private readonly diagnosticsByFile;
+    readonly project: string;
+    readonly languages: readonly string[];
+    readonly indexer: IGraphDump["indexer"];
+    readonly nodes: readonly IGraphNode[];
+    readonly edges: readonly IGraphEdge[];
+    readonly diagnostics: readonly IGraphDiagnostic[];
+    readonly warnings: readonly string[];
+    private constructor();
+    static from(dump: IGraphDump): GraphMemory;
+    node(id: string): IGraphNode | undefined;
+    outgoing(id: string): readonly IGraphEdge[];
+    incoming(id: string): readonly IGraphEdge[];
+    named(name: string): readonly IGraphNode[];
+    symbols(handle: string): readonly IGraphNode[];
+    exported(): IGraphNode[];
+    diagnosticsFor(file: string): readonly IGraphDiagnostic[];
+}

package/lib/model/GraphMemory.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphMemory = void 0;
+const path_1 = require("../utils/path");
+class GraphMemory {
+    byId;
+    outEdges;
+    inEdges;
+    byNameIndex;
+    bySymbolIndex;
+    diagnosticsByFile;
+    project;
+    languages;
+    indexer;
+    nodes;
+    edges;
+    diagnostics;
+    warnings;
+    constructor(dump, nodes, edges) {
+        this.project = dump.project;
+        this.languages = dump.languages;
+        this.indexer = dump.indexer;
+        this.nodes = nodes;
+        this.edges = edges;
+        this.diagnostics = dump.diagnostics ?? [];
+        this.warnings = dump.warnings ?? [];
+        this.byId = new Map(nodes.map((node) => [node.id, node]));
+        this.outEdges = new Map();
+        this.inEdges = new Map();
+        this.byNameIndex = new Map();
+        this.bySymbolIndex = new Map();
+        this.diagnosticsByFile = new Map();
+        for (const node of nodes) {
+            push(this.byNameIndex, node.name, node);
+            if (node.kind !== "file") {
+                push(this.bySymbolIndex, node.name, node);
+                if (node.qualifiedName !== undefined) {
+                    push(this.bySymbolIndex, node.qualifiedName, node);
+                }
+            }
+        }
+        for (const edge of edges) {
+            push(this.outEdges, edge.from, edge);
+            push(this.inEdges, edge.to, edge);
+        }
+        for (const diagnostic of this.diagnostics) {
+            push(this.diagnosticsByFile, diagnostic.file, diagnostic);
+        }
+    }
+    static from(dump) {
+        const { nodes, edges } = synthesize(dump.nodes, dump.edges);
+        return new GraphMemory(dump, nodes, edges);
+    }
+    node(id) {
+        return this.byId.get(id);
+    }
+    outgoing(id) {
+        return this.outEdges.get(id) ?? [];
+    }
+    incoming(id) {
+        return this.inEdges.get(id) ?? [];
+    }
+    named(name) {
+        return this.byNameIndex.get(name) ?? [];
+    }
+    symbols(handle) {
+        return this.bySymbolIndex.get(handle) ?? [];
+    }
+    exported() {
+        return this.nodes.filter((node) => node.exported && !node.external);
+    }
+    diagnosticsFor(file) {
+        return this.diagnosticsByFile.get(file) ?? [];
+    }
+}
+exports.GraphMemory = GraphMemory;
+function push(map, key, value) {
+    const bucket = map.get(key);
+    if (bucket === undefined)
+        map.set(key, [value]);
+    else
+        bucket.push(value);
+}
+function keyOf(node) {
+    return node.qualifiedName ?? node.name;
+}
+function ownerKey(key) {
+    const dot = key.lastIndexOf(".");
+    return dot >= 0 ? key.slice(0, dot) : "";
+}
+function synthesize(rawNodes, rawEdges) {
+    const nodes = rawNodes.map((node) => ({ ...node }));
+    const edges = rawEdges.map((edge) => ({ ...edge }));
+    const byFileKey = new Map();
+    const files = new Map();
+    for (const node of nodes) {
+        if (!node.external)
+            byFileKey.set(`${node.file}\0${keyOf(node)}`, node);
+        if (!node.external && node.file !== "" && !files.has(node.file)) {
+            files.set(node.file, {
+                id: node.file,
+                kind: "file",
+                language: node.language,
+                name: (0, path_1.basename)(node.file),
+                file: node.file,
+                external: false,
+            });
+        }
+    }
+    const edgeKeys = new Set(edges.map((edge) => `${edge.kind}\0${edge.from}\0${edge.to}`));
+    const addEdge = (edge) => {
+        const key = `${edge.kind}\0${edge.from}\0${edge.to}`;
+        if (edgeKeys.has(key))
+            return;
+        edgeKeys.add(key);
+        edges.push(edge);
+    };
+    for (const node of nodes) {
+        if (node.external || node.file === "")
+            continue;
+        const parentKey = ownerKey(keyOf(node));
+        const parent = parentKey === "" ? undefined : byFileKey.get(`${node.file}\0${parentKey}`);
+        addEdge({
+            from: parent?.id ?? node.file,
+            to: node.id,
+            kind: "contains",
+        });
+        if (node.exported) {
+            addEdge({
+                from: node.file,
+                to: node.id,
+                kind: "exports",
+            });
+        }
+    }
+    return {
+        nodes: [...nodes, ...files.values()],
+        edges,
+    };
+}
+//# sourceMappingURL=GraphMemory.js.map

package/lib/model/GraphMemory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphMemory.js","sourceRoot":"","sources":["../../src/model/GraphMemory.ts"],"names":[],"mappings":"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"}

package/lib/operations/bound.d.ts

@@ -0,0 +1 @@
+export declare function bound(value: number | undefined, fallback: number, min: number, max: number): number;

package/lib/operations/bound.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bound = bound;
+function bound(value, fallback, min, max) {
+    const n = value === undefined || !Number.isFinite(value) ? fallback : value;
+    return Math.max(min, Math.min(max, Math.floor(n)));
+}
+//# sourceMappingURL=bound.js.map

package/lib/operations/bound.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bound.js","sourceRoot":"","sources":["../../src/operations/bound.ts"],"names":[],"mappings":";;;AAAA,eACE,KAAyB,EACzB,QAAgB,EAChB,GAAW,EACX,GAAW;IAEX,MAAM,CAAC,GAAG,KAAK,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC;IAC5E,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACrD,CAAC"}

package/lib/operations/common.d.ts

@@ -0,0 +1,15 @@
+export * from "./bound";
+export * from "./compareEdges";
+export * from "./edgeRank";
+export * from "./isExecution";
+export * from "./isStructural";
+export * from "./isTestPath";
+export * from "./isTypeEdge";
+export * from "./publicEvidence";
+export * from "./referencesFromEdges";
+export * from "./resolveHandle";
+export * from "./resultGuide";
+export * from "./resultNext";
+export * from "./signatureOf";
+export * from "./subwords";
+export * from "./summaryOf";

package/lib/operations/common.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bound"), exports);
+__exportStar(require("./compareEdges"), exports);
+__exportStar(require("./edgeRank"), exports);
+__exportStar(require("./isExecution"), exports);
+__exportStar(require("./isStructural"), exports);
+__exportStar(require("./isTestPath"), exports);
+__exportStar(require("./isTypeEdge"), exports);
+__exportStar(require("./publicEvidence"), exports);
+__exportStar(require("./referencesFromEdges"), exports);
+__exportStar(require("./resolveHandle"), exports);
+__exportStar(require("./resultGuide"), exports);
+__exportStar(require("./resultNext"), exports);
+__exportStar(require("./signatureOf"), exports);
+__exportStar(require("./subwords"), exports);
+__exportStar(require("./summaryOf"), exports);
+//# sourceMappingURL=common.js.map

package/lib/operations/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../src/operations/common.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAwB;AACxB,iDAA+B;AAC/B,6CAA2B;AAC3B,gDAA8B;AAC9B,iDAA+B;AAC/B,+CAA6B;AAC7B,+CAA6B;AAC7B,mDAAiC;AACjC,wDAAsC;AACtC,kDAAgC;AAChC,gDAA8B;AAC9B,+CAA6B;AAC7B,gDAA8B;AAC9B,6CAA2B;AAC3B,8CAA4B"}

package/lib/operations/compareEdges.d.ts

@@ -0,0 +1,2 @@
+import { IGraphEdge } from "../structures";
+export declare function compareEdges(a: IGraphEdge, b: IGraphEdge): number;

package/lib/operations/compareEdges.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareEdges = compareEdges;
+const edgeRank_1 = require("./edgeRank");
+function compareEdges(a, b) {
+    return ((0, edgeRank_1.edgeRank)(a.kind) - (0, edgeRank_1.edgeRank)(b.kind) ||
+        (a.evidence?.startLine ?? 999999) - (b.evidence?.startLine ?? 999999) ||
+        (a.evidence?.startCol ?? 999) - (b.evidence?.startCol ?? 999));
+}
+//# sourceMappingURL=compareEdges.js.map

package/lib/operations/compareEdges.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareEdges.js","sourceRoot":"","sources":["../../src/operations/compareEdges.ts"],"names":[],"mappings":";;;AACA,yCAAsC;AAEtC,sBAA6B,CAAa,EAAE,CAAa;IACvD,OAAO,CACL,IAAA,mBAAQ,EAAC,CAAC,CAAC,IAAI,CAAC,GAAG,IAAA,mBAAQ,EAAC,CAAC,CAAC,IAAI,CAAC;QACnC,CAAC,CAAC,CAAC,QAAQ,EAAE,SAAS,IAAI,MAAO,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,SAAS,IAAI,MAAO,CAAC;QACvE,CAAC,CAAC,CAAC,QAAQ,EAAE,QAAQ,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,QAAQ,IAAI,GAAG,CAAC,CAC9D,CAAC;AACJ,CAAC"}

package/lib/operations/edgeRank.d.ts

@@ -0,0 +1 @@
+export declare function edgeRank(kind: string): number;

package/lib/operations/edgeRank.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.edgeRank = edgeRank;
+function edgeRank(kind) {
+    switch (kind) {
+        case "calls":
+            return 0;
+        case "instantiates":
+            return 1;
+        case "references":
+        case "accesses":
+            return 2;
+        case "type_ref":
+            return 3;
+        case "extends":
+        case "implements":
+        case "overrides":
+            return 4;
+        case "tests":
+            return 5;
+        default:
+            return 10;
+    }
+}
+//# sourceMappingURL=edgeRank.js.map

package/lib/operations/edgeRank.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"edgeRank.js","sourceRoot":"","sources":["../../src/operations/edgeRank.ts"],"names":[],"mappings":";;;AAEA,kBAAyB,IAAY;IACnC,QAAQ,IAA+C,EAAE,CAAC;QACxD,KAAK,OAAO;YACV,OAAO,CAAC,CAAC;QACX,KAAK,cAAc;YACjB,OAAO,CAAC,CAAC;QACX,KAAK,YAAY,CAAC;QAClB,KAAK,UAAU;YACb,OAAO,CAAC,CAAC;QACX,KAAK,UAAU;YACb,OAAO,CAAC,CAAC;QACX,KAAK,SAAS,CAAC;QACf,KAAK,YAAY,CAAC;QAClB,KAAK,WAAW;YACd,OAAO,CAAC,CAAC;QACX,KAAK,OAAO;YACV,OAAO,CAAC,CAAC;QACX;YACE,OAAO,EAAE,CAAC;IACd,CAAC;AACH,CAAC"}

package/lib/operations/isExecution.d.ts

@@ -0,0 +1 @@
+export declare function isExecution(kind: string): boolean;

package/lib/operations/isExecution.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExecution = isExecution;
+function isExecution(kind) {
+    return (kind === "calls" ||
+        kind === "instantiates" ||
+        kind === "accesses" ||
+        kind === "renders" ||
+        kind === "references");
+}
+//# sourceMappingURL=isExecution.js.map

package/lib/operations/isExecution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isExecution.js","sourceRoot":"","sources":["../../src/operations/isExecution.ts"],"names":[],"mappings":";;;AAAA,qBAA4B,IAAY;IACtC,OAAO,CACL,IAAI,KAAK,OAAO;QAChB,IAAI,KAAK,cAAc;QACvB,IAAI,KAAK,UAAU;QACnB,IAAI,KAAK,SAAS;QAClB,IAAI,KAAK,YAAY,CACtB,CAAC;AACJ,CAAC"}

package/lib/operations/isPublicApiNoisePath.d.ts

@@ -0,0 +1,2 @@
+/** True when exported symbols are unlikely to be authored public API. */
+export declare function isPublicApiNoisePath(file: string): boolean;

package/lib/operations/isPublicApiNoisePath.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPublicApiNoisePath = isPublicApiNoisePath;
+const isSupportPath_1 = require("./isSupportPath");
+/** True when exported symbols are unlikely to be authored public API. */
+function isPublicApiNoisePath(file) {
+    return ((0, isSupportPath_1.isSupportPath)(file) ||
+        /(^|\/|\.)typings\.[cm]?ts$/.test(file) ||
+        /(^|\/)internal\//.test(file));
+}
+//# sourceMappingURL=isPublicApiNoisePath.js.map

package/lib/operations/isPublicApiNoisePath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPublicApiNoisePath.js","sourceRoot":"","sources":["../../src/operations/isPublicApiNoisePath.ts"],"names":[],"mappings":";;;AAAA,mDAAgD;AAEhD,yEAAyE;AACzE,8BAAqC,IAAY;IAC/C,OAAO,CACL,IAAA,6BAAa,EAAC,IAAI,CAAC;QACnB,4BAA4B,CAAC,IAAI,CAAC,IAAI,CAAC;QACvC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,CAC9B,CAAC;AACJ,CAAC"}

package/lib/operations/isStructural.d.ts

@@ -0,0 +1 @@
+export declare function isStructural(kind: string): boolean;

package/lib/operations/isStructural.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStructural = isStructural;
+function isStructural(kind) {
+    return kind === "contains" || kind === "exports" || kind === "imports";
+}
+//# sourceMappingURL=isStructural.js.map

package/lib/operations/isStructural.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isStructural.js","sourceRoot":"","sources":["../../src/operations/isStructural.ts"],"names":[],"mappings":";;;AAAA,sBAA6B,IAAY;IACvC,OAAO,IAAI,KAAK,UAAU,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,SAAS,CAAC;AACzE,CAAC"}

package/lib/operations/isSupportPath.d.ts

@@ -0,0 +1,2 @@
+/** True for tests, examples, fixtures, generated output, and build artifacts. */
+export declare function isSupportPath(file: string): boolean;

package/lib/operations/isSupportPath.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSupportPath = isSupportPath;
+/** True for tests, examples, fixtures, generated output, and build artifacts. */
+function isSupportPath(file) {
+    return (file === "" ||
+        file.startsWith("bundled://") ||
+        /(^|\/)(node_modules|vendor|site-packages)\//.test(file) ||
+        /(^|\/)(test|tests|__tests__|spec|specs|sample|samples|fixture|fixtures|__fixtures__|example|examples)\//.test(file) ||
+        /\.(test|spec)\.[^/]+$/.test(file) ||
+        /_test\.[^/]+$/.test(file) ||
+        /(^|\/)typings\.[cm]?ts$/.test(file) ||
+        /\.d\.[cm]?ts$/.test(file) ||
+        /(^|\/)(dist|build|coverage|generated|__generated__|gen)\//.test(file));
+}
+//# sourceMappingURL=isSupportPath.js.map

package/lib/operations/isSupportPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSupportPath.js","sourceRoot":"","sources":["../../src/operations/isSupportPath.ts"],"names":[],"mappings":";;;AAAA,iFAAiF;AACjF,uBAA8B,IAAY;IACxC,OAAO,CACL,IAAI,KAAK,EAAE;QACX,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC;QAC7B,6CAA6C,CAAC,IAAI,CAAC,IAAI,CAAC;QACxD,yGAAyG,CAAC,IAAI,CAC5G,IAAI,CACL;QACD,uBAAuB,CAAC,IAAI,CAAC,IAAI,CAAC;QAClC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC;QAC1B,yBAAyB,CAAC,IAAI,CAAC,IAAI,CAAC;QACpC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC;QAC1B,2DAA2D,CAAC,IAAI,CAAC,IAAI,CAAC,CACvE,CAAC;AACJ,CAAC"}

package/lib/operations/isTestPath.d.ts

@@ -0,0 +1 @@
+export declare function isTestPath(file: string): boolean;

package/lib/operations/isTestPath.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTestPath = isTestPath;
+function isTestPath(file) {
+    return (/(^|\/)(test|tests|__tests__|spec)\//.test(file) ||
+        /\.(test|spec)\./.test(file) ||
+        /_test\./.test(file));
+}
+//# sourceMappingURL=isTestPath.js.map

package/lib/operations/isTestPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isTestPath.js","sourceRoot":"","sources":["../../src/operations/isTestPath.ts"],"names":[],"mappings":";;;AAAA,oBAA2B,IAAY;IACrC,OAAO,CACL,qCAAqC,CAAC,IAAI,CAAC,IAAI,CAAC;QAChD,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC;QAC5B,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CACrB,CAAC;AACJ,CAAC"}

package/lib/operations/isTypeEdge.d.ts

@@ -0,0 +1 @@
+export declare function isTypeEdge(kind: string): boolean;

package/lib/operations/isTypeEdge.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTypeEdge = isTypeEdge;
+function isTypeEdge(kind) {
+    return (kind === "type_ref" ||
+        kind === "extends" ||
+        kind === "implements" ||
+        kind === "overrides" ||
+        kind === "decorates");
+}
+//# sourceMappingURL=isTypeEdge.js.map

package/lib/operations/isTypeEdge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isTypeEdge.js","sourceRoot":"","sources":["../../src/operations/isTypeEdge.ts"],"names":[],"mappings":";;;AAAA,oBAA2B,IAAY;IACrC,OAAO,CACL,IAAI,KAAK,UAAU;QACnB,IAAI,KAAK,SAAS;QAClB,IAAI,KAAK,YAAY;QACrB,IAAI,KAAK,WAAW;QACpB,IAAI,KAAK,WAAW,CACrB,CAAC;AACJ,CAAC"}

package/lib/operations/publicEvidence.d.ts

@@ -0,0 +1,2 @@
+import { IGraphEvidence } from "../structures";
+export declare function publicEvidence(evidence: IGraphEvidence): IGraphEvidence;

package/lib/operations/publicEvidence.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publicEvidence = publicEvidence;
+function publicEvidence(evidence) {
+    return {
+        file: evidence.file,
+        startLine: evidence.startLine,
+        ...(evidence.startCol !== undefined ? { startCol: evidence.startCol } : {}),
+        ...(evidence.endLine !== undefined ? { endLine: evidence.endLine } : {}),
+        ...(evidence.endCol !== undefined ? { endCol: evidence.endCol } : {}),
+    };
+}
+//# sourceMappingURL=publicEvidence.js.map

package/lib/operations/publicEvidence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publicEvidence.js","sourceRoot":"","sources":["../../src/operations/publicEvidence.ts"],"names":[],"mappings":";;;AAEA,wBAA+B,QAAwB;IACrD,OAAO;QACL,IAAI,EAAE,QAAQ,CAAC,IAAI;QACnB,SAAS,EAAE,QAAQ,CAAC,SAAS;QAC7B,GAAG,CAAC,QAAQ,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3E,GAAG,CAAC,QAAQ,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACxE,GAAG,CAAC,QAAQ,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACtE,CAAC;AACJ,CAAC"}

package/lib/operations/referencesFromEdges.d.ts

@@ -0,0 +1,3 @@
+import { GraphMemory } from "../model/GraphMemory";
+import { IGraphDetails, IGraphEdge } from "../structures";
+export declare function referencesFromEdges(graph: GraphMemory, edges: readonly IGraphEdge[], end: "from" | "to", limit: number, includeExternal: boolean, kinds?: ReadonlySet<string>): IGraphDetails.IReference[];

package/lib/operations/referencesFromEdges.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.referencesFromEdges = referencesFromEdges;
+const compareEdges_1 = require("./compareEdges");
+const isStructural_1 = require("./isStructural");
+const publicEvidence_1 = require("./publicEvidence");
+const summaryOf_1 = require("./summaryOf");
+function referencesFromEdges(graph, edges, end, limit, includeExternal, kinds) {
+    const out = [];
+    const seen = new Set();
+    for (const edge of [...edges].sort(compareEdges_1.compareEdges)) {
+        if (kinds !== undefined && !kinds.has(edge.kind))
+            continue;
+        if ((0, isStructural_1.isStructural)(edge.kind))
+            continue;
+        const node = graph.node(end === "from" ? edge.from : edge.to);
+        if (node === undefined)
+            continue;
+        if (!includeExternal && node.external)
+            continue;
+        // One entry per node; edges are pre-sorted by compareEdges, so the first
+        // (highest-ranked) relation to a node wins.
+        if (seen.has(node.id))
+            continue;
+        seen.add(node.id);
+        const ref = {
+            ...(0, summaryOf_1.summaryOf)(node),
+            relation: edge.kind,
+        };
+        if (edge.evidence !== undefined)
+            ref.evidence = (0, publicEvidence_1.publicEvidence)(edge.evidence);
+        out.push(ref);
+        if (out.length >= limit)
+            break;
+    }
+    return out;
+}
+//# sourceMappingURL=referencesFromEdges.js.map

package/lib/operations/referencesFromEdges.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"referencesFromEdges.js","sourceRoot":"","sources":["../../src/operations/referencesFromEdges.ts"],"names":[],"mappings":";;;AAEA,iDAA8C;AAC9C,iDAA8C;AAC9C,qDAAkD;AAClD,2CAAwC;AAExC,6BACE,KAAkB,EAClB,KAA4B,EAC5B,GAAkB,EAClB,KAAa,EACb,eAAwB,EACxB,KAA2B;IAE3B,MAAM,GAAG,GAA+B,EAAE,CAAC;IAC3C,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,KAAK,MAAM,IAAI,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC,IAAI,CAAC,2BAAY,CAAC,EAAE,CAAC;QACjD,IAAI,KAAK,KAAK,SAAS,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC;YAAE,SAAS;QAC3D,IAAI,IAAA,2BAAY,EAAC,IAAI,CAAC,IAAI,CAAC;YAAE,SAAS;QACtC,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC9D,IAAI,IAAI,KAAK,SAAS;YAAE,SAAS;QACjC,IAAI,CAAC,eAAe,IAAI,IAAI,CAAC,QAAQ;YAAE,SAAS;QAChD,yEAAyE;QACzE,4CAA4C;QAC5C,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YAAE,SAAS;QAChC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAClB,MAAM,GAAG,GAA6B;YACpC,GAAG,IAAA,qBAAS,EAAC,IAAI,CAAC;YAClB,QAAQ,EAAE,IAAI,CAAC,IAAI;SACpB,CAAC;QACF,IAAI,IAAI,CAAC,QAAQ,KAAK,SAAS;YAAE,GAAG,CAAC,QAAQ,GAAG,IAAA,+BAAc,EAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9E,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACd,IAAI,GAAG,CAAC,MAAM,IAAI,KAAK;YAAE,MAAM;IACjC,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/lib/operations/resolveHandle.d.ts

@@ -0,0 +1,6 @@
+import { GraphMemory } from "../model/GraphMemory";
+import { IGraphNode } from "../structures";
+export declare function resolveHandle(graph: GraphMemory, handle: string): {
+    node?: IGraphNode;
+    candidates?: IGraphNode[];
+};

package/lib/operations/resolveHandle.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveHandle = resolveHandle;
+function resolveHandle(graph, handle) {
+    const trimmed = handle.trim();
+    if (trimmed === "")
+        return {};
+    const exact = graph.node(trimmed);
+    if (exact !== undefined)
+        return { node: exact };
+    const symbolMatches = graph.symbols(trimmed);
+    if (symbolMatches.length === 1)
+        return { node: symbolMatches[0] };
+    if (symbolMatches.length > 1)
+        return { candidates: symbolMatches.slice(0, 8) };
+    const lowered = trimmed.toLowerCase();
+    const fuzzy = graph.nodes
+        .filter((node) => node.kind !== "file" &&
+        ((node.qualifiedName ?? node.name).toLowerCase().endsWith(lowered) ||
+            node.file.toLowerCase().endsWith(lowered)))
+        .slice(0, 8);
+    if (fuzzy.length === 1)
+        return { node: fuzzy[0] };
+    if (fuzzy.length > 1)
+        return { candidates: fuzzy };
+    return {};
+}
+//# sourceMappingURL=resolveHandle.js.map

package/lib/operations/resolveHandle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveHandle.js","sourceRoot":"","sources":["../../src/operations/resolveHandle.ts"],"names":[],"mappings":";;;AAGA,uBACE,KAAkB,EAClB,MAAc;IAEd,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC;IAC9B,IAAI,OAAO,KAAK,EAAE;QAAE,OAAO,EAAE,CAAC;IAC9B,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAClC,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;IAChD,MAAM,aAAa,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7C,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC;IAClE,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,EAAE,UAAU,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;IAC/E,MAAM,OAAO,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IACtC,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK;SACtB,MAAM,CACL,CAAC,IAAI,EAAE,EAAE,CACP,IAAI,CAAC,IAAI,KAAK,MAAM;QACpB,CAAC,CAAC,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC;YAChE,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAC/C;SACA,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACf,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;IAClD,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC;IACnD,OAAO,EAAE,CAAC;AACZ,CAAC"}

package/lib/operations/resultGuide.d.ts

@@ -0,0 +1 @@
+export declare function resultGuide(message: string): string;

package/lib/operations/resultGuide.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resultGuide = resultGuide;
+function resultGuide(message) {
+    return `${message} Use graph spans as citation anchors; do not treat them as a command to read source bodies.`;
+}
+//# sourceMappingURL=resultGuide.js.map

package/lib/operations/resultGuide.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resultGuide.js","sourceRoot":"","sources":["../../src/operations/resultGuide.ts"],"names":[],"mappings":";;;AAAA,qBAA4B,OAAe;IACzC,OAAO,GAAG,OAAO,6FAA6F,CAAC;AACjH,CAAC"}

package/lib/operations/resultNext.d.ts

@@ -0,0 +1,2 @@
+import { IGraphNext } from "../structures";
+export declare function resultNext(action: IGraphNext["action"], reason: string, request?: IGraphNext["request"]): IGraphNext;

package/lib/operations/resultNext.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resultNext = resultNext;
+function resultNext(action, reason, request) {
+    return request === undefined ? { action, reason } : { action, request, reason };
+}
+//# sourceMappingURL=resultNext.js.map

package/lib/operations/resultNext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resultNext.js","sourceRoot":"","sources":["../../src/operations/resultNext.ts"],"names":[],"mappings":";;;AAEA,oBACE,MAA4B,EAC5B,MAAc,EACd,OAA+B;IAE/B,OAAO,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;AAClF,CAAC"}

package/lib/operations/runDetails.d.ts

@@ -0,0 +1,8 @@
+import { GraphMemory } from "../model/GraphMemory";
+import { IGraphDetails } from "../structures";
+/**
+ * Resolve each handle to its declared shape: sourceSpan anchors, signature,
+ * direct dependencies, and for containers, member outlines. It answers from the
+ * graph's resolved structure instead of inlining implementation bodies.
+ */
+export declare function runDetails(graph: GraphMemory, props: IGraphDetails.IRequest): IGraphDetails;