@ttsc/graph 0.18.3 → 0.19.0

package/lib/model/TtscGraphSession.js

@@ -0,0 +1,457 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TtscGraphSession = void 0;
+const _assertGuard_1 = __importStar(require("typia/lib/internal/_assertGuard"));
+const node_child_process_1 = require("node:child_process");
+const node_readline_1 = __importDefault(require("node:readline"));
+const typia_1 = __importDefault(require("typia"));
+const nativeExecutable_1 = require("../nativeExecutable");
+const resolveGraphBinary_1 = require("../resolveGraphBinary");
+const TtscGraphMemory_1 = require("./TtscGraphMemory");
+/**
+ * Resident bridge to `ttscgraph serve`.
+ *
+ * Every graph request first asks the native session for the current disk
+ * snapshot. Unchanged requests reuse the existing {@link TtscGraphMemory}; an
+ * edited source reuses tsgo's resident Program through `driver.Session`, while
+ * config and root-file-set changes force a safe full reload.
+ */
+class TtscGraphSession {
+    cwd;
+    tsconfig;
+    binary;
+    child;
+    stderr = "";
+    nextId = 0;
+    pending = new Map();
+    queue = Promise.resolve();
+    current;
+    closed = false;
+    constructor(options) {
+        // Resolve the platform binary from the project this session serves, so the
+        // MCP server started from an unrelated directory still finds the target's
+        // installed `ttsc`.
+        const binary = options.binary ?? (0, resolveGraphBinary_1.resolveGraphBinary)(process.env, options.cwd);
+        if (binary === null) {
+            throw new Error("@ttsc/graph: could not resolve the ttscgraph binary. " +
+                "Install `ttsc` so its platform package is present, " +
+                "or set TTSC_GRAPH_BINARY to an absolute path.");
+        }
+        (0, nativeExecutable_1.ensureExecutable)(binary);
+        this.cwd = options.cwd;
+        this.tsconfig = options.tsconfig;
+        this.binary = binary;
+    }
+    /** Return a graph for the current disk snapshot, serialized per tool call. */
+    graph() {
+        let resolve;
+        let reject;
+        const result = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        this.queue = this.queue
+            .catch(() => undefined)
+            .then(async () => {
+            try {
+                resolve(await this.refresh());
+            }
+            catch (error) {
+                reject(asError(error));
+            }
+        });
+        return result;
+    }
+    /** Close the native session. Safe to call more than once. */
+    close() {
+        this.closed = true;
+        const child = this.child;
+        this.child = undefined;
+        if (child !== undefined && !child.killed)
+            child.stdin.end();
+        this.failPending(new Error("@ttsc/graph: native session closed"));
+    }
+    async refresh() {
+        const response = await this.request();
+        if (response.error !== undefined) {
+            throw new Error(`@ttsc/graph: ${response.error}`);
+        }
+        if (response.changed) {
+            if (response.dump === undefined) {
+                throw new Error(`@ttsc/graph: native ${response.mode ?? "changed"} response omitted its dump`);
+            }
+            const dump = (() => {
+                const _iv0 = new Set(["class", "enum", "external_symbol", "file", "function", "interface", "method", "module", "namespace", "package", "parameter", "property", "type", "variable"]);
+                const _ip0 = input => "string" === typeof input["name"];
+                const _iv1 = new Set(["abstract", "async", "const", "declare", "default", "export", "optional", "private", "protected", "public", "readonly", "static"]);
+                const _ip1 = input => undefined === input["evidence"] || "object" === typeof input["evidence"] && null !== input["evidence"] && _io4(input["evidence"]);
+                const _iv2 = new Set(["accesses", "calls", "contains", "decorates", "dispatches", "exports", "extends", "implements", "imports", "instantiates", "overrides", "renders", "tests", "type_ref"]);
+                const _av0 = new Set(["class", "enum", "external_symbol", "file", "function", "interface", "method", "module", "namespace", "package", "parameter", "property", "type", "variable"]);
+                const _ae0 = "(\"class\" | \"enum\" | \"external_symbol\" | \"file\" | \"function\" | \"interface\" | \"method\" | \"module\" | \"namespace\" | \"package\" | \"parameter\" | \"property\" | \"type\" | \"variable\")";
+                const _ap0 = (input, _path, _exceptionable = true) => "string" === typeof input["name"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".name",
+                    expected: "string",
+                    value: input["name"]
+                }, _errorFactory);
+                const _av1 = new Set(["abstract", "async", "const", "declare", "default", "export", "optional", "private", "protected", "public", "readonly", "static"]);
+                const _ae1 = "(\"abstract\" | \"async\" | \"const\" | \"declare\" | \"default\" | \"export\" | \"optional\" | \"private\" | \"protected\" | \"public\" | \"readonly\" | \"static\")";
+                const _ap1 = (input, _path, _exceptionable = true) => undefined === input["evidence"] || ("object" === typeof input["evidence"] && null !== input["evidence"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".evidence",
+                    expected: "(ITtscGraphSpan | undefined)",
+                    value: input["evidence"]
+                }, _errorFactory)) && _ao4(input["evidence"], _path + ".evidence", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".evidence",
+                    expected: "(ITtscGraphSpan | undefined)",
+                    value: input["evidence"]
+                }, _errorFactory);
+                const _av2 = new Set(["accesses", "calls", "contains", "decorates", "dispatches", "exports", "extends", "implements", "imports", "instantiates", "overrides", "renders", "tests", "type_ref"]);
+                const _ae2 = "(\"accesses\" | \"calls\" | \"contains\" | \"decorates\" | \"dispatches\" | \"exports\" | \"extends\" | \"implements\" | \"imports\" | \"instantiates\" | \"overrides\" | \"renders\" | \"tests\" | \"type_ref\")";
+                const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.project || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".project",
+                    expected: "string",
+                    value: input.project
+                }, _errorFactory)) && ("string" === typeof input.tsconfig || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".tsconfig",
+                    expected: "string",
+                    value: input.tsconfig
+                }, _errorFactory)) && ((Array.isArray(input.nodes) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".nodes",
+                    expected: "Array<ITtscGraphDump.INode>",
+                    value: input.nodes
+                }, _errorFactory)) && input.nodes.every((elem, _index6) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".nodes[" + _index6 + "]",
+                    expected: "ITtscGraphDump.INode",
+                    value: elem
+                }, _errorFactory)) && _ao1(elem, _path + ".nodes[" + _index6 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".nodes[" + _index6 + "]",
+                    expected: "ITtscGraphDump.INode",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".nodes",
+                    expected: "Array<ITtscGraphDump.INode>",
+                    value: input.nodes
+                }, _errorFactory)) && ((Array.isArray(input.edges) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".edges",
+                    expected: "Array<ITtscGraphDump.IEdge>",
+                    value: input.edges
+                }, _errorFactory)) && input.edges.every((elem, _index7) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".edges[" + _index7 + "]",
+                    expected: "ITtscGraphDump.IEdge",
+                    value: elem
+                }, _errorFactory)) && _ao5(elem, _path + ".edges[" + _index7 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".edges[" + _index7 + "]",
+                    expected: "ITtscGraphDump.IEdge",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".edges",
+                    expected: "Array<ITtscGraphDump.IEdge>",
+                    value: input.edges
+                }, _errorFactory));
+                const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".id",
+                    expected: "string",
+                    value: input.id
+                }, _errorFactory)) && (true === _av0.has(input.kind) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".kind",
+                    expected: _ae0,
+                    value: input.kind
+                }, _errorFactory)) && _ap0(input, _path, true && _exceptionable) && (undefined === input.qualifiedName || "string" === typeof input.qualifiedName || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".qualifiedName",
+                    expected: "(string | undefined)",
+                    value: input.qualifiedName
+                }, _errorFactory)) && ("string" === typeof input.file || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".file",
+                    expected: "string",
+                    value: input.file
+                }, _errorFactory)) && ("boolean" === typeof input.external || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".external",
+                    expected: "boolean",
+                    value: input.external
+                }, _errorFactory)) && (undefined === input.ignored || "boolean" === typeof input.ignored || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".ignored",
+                    expected: "(boolean | undefined)",
+                    value: input.ignored
+                }, _errorFactory)) && (undefined === input.exported || "boolean" === typeof input.exported || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".exported",
+                    expected: "(boolean | undefined)",
+                    value: input.exported
+                }, _errorFactory)) && (undefined === input.closure || "boolean" === typeof input.closure || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".closure",
+                    expected: "(boolean | undefined)",
+                    value: input.closure
+                }, _errorFactory)) && (undefined === input.modifiers || (Array.isArray(input.modifiers) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".modifiers",
+                    expected: "(Array<TtscGraphNodeModifier> | undefined)",
+                    value: input.modifiers
+                }, _errorFactory)) && input.modifiers.every((elem, _index8) => true === _av1.has(elem) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".modifiers[" + _index8 + "]",
+                    expected: _ae1,
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".modifiers",
+                    expected: "(Array<TtscGraphNodeModifier> | undefined)",
+                    value: input.modifiers
+                }, _errorFactory)) && (undefined === input.decorators || (Array.isArray(input.decorators) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".decorators",
+                    expected: "(Array<ITtscGraphDecorator> | undefined)",
+                    value: input.decorators
+                }, _errorFactory)) && input.decorators.every((elem, _index9) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".decorators[" + _index9 + "]",
+                    expected: "ITtscGraphDecorator",
+                    value: elem
+                }, _errorFactory)) && _ao2(elem, _path + ".decorators[" + _index9 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".decorators[" + _index9 + "]",
+                    expected: "ITtscGraphDecorator",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".decorators",
+                    expected: "(Array<ITtscGraphDecorator> | undefined)",
+                    value: input.decorators
+                }, _errorFactory)) && _ap1(input, _path, true && _exceptionable) && (undefined === input.implementation || ("object" === typeof input.implementation && null !== input.implementation || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".implementation",
+                    expected: "(ITtscGraphSpan | undefined)",
+                    value: input.implementation
+                }, _errorFactory)) && _ao4(input.implementation, _path + ".implementation", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".implementation",
+                    expected: "(ITtscGraphSpan | undefined)",
+                    value: input.implementation
+                }, _errorFactory));
+                const _ao2 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && ((Array.isArray(input.arguments) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".arguments",
+                    expected: "Array<ITtscGraphDecorator.IArgument>",
+                    value: input.arguments
+                }, _errorFactory)) && input.arguments.every((elem, _index10) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".arguments[" + _index10 + "]",
+                    expected: "ITtscGraphDecorator.IArgument",
+                    value: elem
+                }, _errorFactory)) && _ao3(elem, _path + ".arguments[" + _index10 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".arguments[" + _index10 + "]",
+                    expected: "ITtscGraphDecorator.IArgument",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".arguments",
+                    expected: "Array<ITtscGraphDecorator.IArgument>",
+                    value: input.arguments
+                }, _errorFactory));
+                const _ao3 = (input, _path, _exceptionable = true) => undefined === input.literal || "string" === typeof input.literal || "number" === typeof input.literal || "boolean" === typeof input.literal || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".literal",
+                    expected: "(boolean | number | string | undefined)",
+                    value: input.literal
+                }, _errorFactory);
+                const _ao4 = (input, _path, _exceptionable = true) => (undefined === input.file || "string" === typeof input.file || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".file",
+                    expected: "(string | undefined)",
+                    value: input.file
+                }, _errorFactory)) && ("number" === typeof input.startLine || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".startLine",
+                    expected: "number",
+                    value: input.startLine
+                }, _errorFactory)) && (undefined === input.startCol || "number" === typeof input.startCol || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".startCol",
+                    expected: "(number | undefined)",
+                    value: input.startCol
+                }, _errorFactory)) && (undefined === input.endLine || "number" === typeof input.endLine || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".endLine",
+                    expected: "(number | undefined)",
+                    value: input.endLine
+                }, _errorFactory)) && (undefined === input.endCol || "number" === typeof input.endCol || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".endCol",
+                    expected: "(number | undefined)",
+                    value: input.endCol
+                }, _errorFactory));
+                const _ao5 = (input, _path, _exceptionable = true) => ("string" === typeof input.from || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".from",
+                    expected: "string",
+                    value: input.from
+                }, _errorFactory)) && ("string" === typeof input.to || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".to",
+                    expected: "string",
+                    value: input.to
+                }, _errorFactory)) && (true === _av2.has(input.kind) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".kind",
+                    expected: _ae2,
+                    value: input.kind
+                }, _errorFactory)) && _ap1(input, _path, true && _exceptionable);
+                const _io0 = input => "string" === typeof input.project && "string" === typeof input.tsconfig && (Array.isArray(input.nodes) && input.nodes.every(elem => "object" === typeof elem && null !== elem && _io1(elem))) && (Array.isArray(input.edges) && input.edges.every(elem => "object" === typeof elem && null !== elem && _io5(elem)));
+                const _io1 = input => "string" === typeof input.id && true === _iv0.has(input.kind) && _ip0(input) && (undefined === input.qualifiedName || "string" === typeof input.qualifiedName) && "string" === typeof input.file && "boolean" === typeof input.external && (undefined === input.ignored || "boolean" === typeof input.ignored) && (undefined === input.exported || "boolean" === typeof input.exported) && (undefined === input.closure || "boolean" === typeof input.closure) && (undefined === input.modifiers || Array.isArray(input.modifiers) && input.modifiers.every(elem => true === _iv1.has(elem))) && (undefined === input.decorators || Array.isArray(input.decorators) && input.decorators.every(elem => "object" === typeof elem && null !== elem && _io2(elem))) && _ip1(input) && (undefined === input.implementation || "object" === typeof input.implementation && null !== input.implementation && _io4(input.implementation));
+                const _io2 = input => _ip0(input) && (Array.isArray(input.arguments) && input.arguments.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _io3(elem)));
+                const _io3 = input => undefined === input.literal || "string" === typeof input.literal || "number" === typeof input.literal || "boolean" === typeof input.literal;
+                const _io4 = input => (undefined === input.file || "string" === typeof input.file) && "number" === typeof input.startLine && (undefined === input.startCol || "number" === typeof input.startCol) && (undefined === input.endLine || "number" === typeof input.endLine) && (undefined === input.endCol || "number" === typeof input.endCol);
+                const _io5 = input => "string" === typeof input.from && "string" === typeof input.to && true === _iv2.has(input.kind) && _ip1(input);
+                const __is = input => "object" === typeof input && null !== input && _io0(input);
+                let _errorFactory;
+                return (input, errorFactory) => {
+                    if (false === __is(input)) {
+                        _errorFactory = errorFactory;
+                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _assertGuard_1._assertGuard(true, {
+                            method: "typia.assert",
+                            path: _path + "",
+                            expected: "ITtscGraphDump",
+                            value: input
+                        }, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard_1._assertGuard(true, {
+                            method: "typia.assert",
+                            path: _path + "",
+                            expected: "ITtscGraphDump",
+                            value: input
+                        }, _errorFactory))(input, "$input", true);
+                    }
+                    return input;
+                };
+            })()(response.dump);
+            this.current = TtscGraphMemory_1.TtscGraphMemory.from(dump);
+        }
+        if (this.current === undefined) {
+            throw new Error("@ttsc/graph: native session returned no initial graph snapshot");
+        }
+        return this.current;
+    }
+    request() {
+        const child = this.ensureChild();
+        const id = ++this.nextId;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            child.stdin.write(`${JSON.stringify({ id })}\n`, (error) => {
+                if (error === null || error === undefined)
+                    return;
+                this.pending.delete(id);
+                reject(new Error(`@ttsc/graph: could not request native snapshot: ${error.message}`));
+            });
+        });
+    }
+    ensureChild() {
+        if (this.closed) {
+            // A request queued behind the close must not respawn the native
+            // process; an orphaned resident compiler would outlive the MCP server.
+            throw new Error("@ttsc/graph: native session is closed");
+        }
+        if (this.child !== undefined && this.child.exitCode === null) {
+            return this.child;
+        }
+        this.stderr = "";
+        const child = (0, node_child_process_1.spawn)(this.binary, ["serve", "--cwd", this.cwd, "--tsconfig", this.tsconfig], { stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
+        this.child = child;
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => {
+            this.stderr = (this.stderr + chunk).slice(-64 * 1024);
+        });
+        const lines = node_readline_1.default.createInterface({ input: child.stdout });
+        lines.on("line", (line) => this.onLine(line));
+        child.on("error", (error) => this.failChild(child, error));
+        child.on("exit", (code, signal) => {
+            if (this.child !== child)
+                return;
+            this.child = undefined;
+            this.failPending(new Error(`@ttsc/graph: native session exited (code=${String(code)}, signal=${String(signal)})${this.stderr.trim() === "" ? "" : `: ${this.stderr.trim()}`}`));
+        });
+        return child;
+    }
+    onLine(line) {
+        let response;
+        try {
+            response = JSON.parse(line);
+        }
+        catch (error) {
+            this.failPending(new Error(`@ttsc/graph: native session returned invalid JSON: ${asError(error).message}`));
+            return;
+        }
+        const pending = this.pending.get(response.id);
+        if (pending === undefined)
+            return;
+        this.pending.delete(response.id);
+        pending.resolve(response);
+    }
+    failChild(child, error) {
+        if (this.child === child)
+            this.child = undefined;
+        this.failPending(new Error(`@ttsc/graph: native session failed: ${error.message}`));
+    }
+    failPending(error) {
+        for (const pending of this.pending.values())
+            pending.reject(error);
+        this.pending.clear();
+    }
+}
+exports.TtscGraphSession = TtscGraphSession;
+function asError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+//# sourceMappingURL=TtscGraphSession.js.map

package/lib/model/TtscGraphSession.js.map

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

package/lib/model/loadGraph.d.ts

@@ -1,9 +1,9 @@
 import { TtscGraphMemory } from "./TtscGraphMemory";
 /**
  * Build the resident {@link TtscGraphMemory} for a project by running `ttscgraph
- * dump` once and loading its JSON. This is the cold path behind the MCP tool
- * calls: one type-check in Go produces the checker-resolved fact graph, then
- * every later tool call is answered from the in-memory model.
+ * dump` once and loading its JSON. This is the one-shot path for direct callers
+ * and the viewer. The MCP server uses `TtscGraphSession` instead so source
+ * edits refresh a resident compiler session.
  *
  * Throws when the binary cannot be resolved, the dump command fails, or its
  * output is not a readable graph — the server surfaces the failure rather than