@ttsc/graph 0.18.3 → 0.18.4

package/lib/model/TtscGraphSession.js

@@ -0,0 +1,503 @@
+"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 _a = __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) {
+        const binary = options.binary ?? (0, resolveGraphBinary_1.resolveGraphBinary)();
+        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 _ip1 = input => "string" === typeof input["file"];
+                const _iv1 = new Set(["abstract", "async", "const", "declare", "default", "export", "optional", "private", "protected", "public", "readonly", "static"]);
+                const _ip2 = input => undefined === input["evidence"] || "object" === typeof input["evidence"] && null !== input["evidence"] && _io4(input["evidence"]);
+                const _iv2 = new Set(["accesses", "calls", "contains", "decorates", "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"] || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".name",
+                    expected: "string",
+                    value: input["name"]
+                }, _errorFactory);
+                const _ap1 = (input, _path, _exceptionable = true) => "string" === typeof input["file"] || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".file",
+                    expected: "string",
+                    value: input["file"]
+                }, _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 _ap2 = (input, _path, _exceptionable = true) => undefined === input["evidence"] || ("object" === typeof input["evidence"] && null !== input["evidence"] || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".evidence",
+                    expected: "(ITtscGraphEvidence | undefined)",
+                    value: input["evidence"]
+                }, _errorFactory)) && _ao4(input["evidence"], _path + ".evidence", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".evidence",
+                    expected: "(ITtscGraphEvidence | undefined)",
+                    value: input["evidence"]
+                }, _errorFactory);
+                const _av2 = new Set(["accesses", "calls", "contains", "decorates", "exports", "extends", "implements", "imports", "instantiates", "overrides", "renders", "tests", "type_ref"]);
+                const _ae2 = "(\"accesses\" | \"calls\" | \"contains\" | \"decorates\" | \"exports\" | \"extends\" | \"implements\" | \"imports\" | \"instantiates\" | \"overrides\" | \"renders\" | \"tests\" | \"type_ref\")";
+                const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.project || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".project",
+                    expected: "string",
+                    value: input.project
+                }, _errorFactory)) && ("string" === typeof input.tsconfig || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".tsconfig",
+                    expected: "string",
+                    value: input.tsconfig
+                }, _errorFactory)) && ((Array.isArray(input.nodes) || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".nodes",
+                    expected: "Array<ITtscGraphNode>",
+                    value: input.nodes
+                }, _errorFactory)) && input.nodes.every((elem, _index7) => ("object" === typeof elem && null !== elem || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".nodes[" + _index7 + "]",
+                    expected: "ITtscGraphNode",
+                    value: elem
+                }, _errorFactory)) && _ao1(elem, _path + ".nodes[" + _index7 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".nodes[" + _index7 + "]",
+                    expected: "ITtscGraphNode",
+                    value: elem
+                }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".nodes",
+                    expected: "Array<ITtscGraphNode>",
+                    value: input.nodes
+                }, _errorFactory)) && ((Array.isArray(input.edges) || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".edges",
+                    expected: "Array<ITtscGraphEdge>",
+                    value: input.edges
+                }, _errorFactory)) && input.edges.every((elem, _index8) => ("object" === typeof elem && null !== elem || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".edges[" + _index8 + "]",
+                    expected: "ITtscGraphEdge",
+                    value: elem
+                }, _errorFactory)) && _ao5(elem, _path + ".edges[" + _index8 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".edges[" + _index8 + "]",
+                    expected: "ITtscGraphEdge",
+                    value: elem
+                }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".edges",
+                    expected: "Array<ITtscGraphEdge>",
+                    value: input.edges
+                }, _errorFactory)) && (undefined === input.diagnostics || (Array.isArray(input.diagnostics) || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".diagnostics",
+                    expected: "(Array<ITtscGraphDiagnostic> | undefined)",
+                    value: input.diagnostics
+                }, _errorFactory)) && input.diagnostics.every((elem, _index9) => ("object" === typeof elem && null !== elem || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".diagnostics[" + _index9 + "]",
+                    expected: "ITtscGraphDiagnostic",
+                    value: elem
+                }, _errorFactory)) && _ao6(elem, _path + ".diagnostics[" + _index9 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".diagnostics[" + _index9 + "]",
+                    expected: "ITtscGraphDiagnostic",
+                    value: elem
+                }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".diagnostics",
+                    expected: "(Array<ITtscGraphDiagnostic> | undefined)",
+                    value: input.diagnostics
+                }, _errorFactory));
+                const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".id",
+                    expected: "string",
+                    value: input.id
+                }, _errorFactory)) && (true === _av0.has(input.kind) || _a._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 || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".qualifiedName",
+                    expected: "(string | undefined)",
+                    value: input.qualifiedName
+                }, _errorFactory)) && _ap1(input, _path, true && _exceptionable) && ("boolean" === typeof input.external || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".external",
+                    expected: "boolean",
+                    value: input.external
+                }, _errorFactory)) && (undefined === input.ignored || "boolean" === typeof input.ignored || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".ignored",
+                    expected: "(boolean | undefined)",
+                    value: input.ignored
+                }, _errorFactory)) && (undefined === input.exported || "boolean" === typeof input.exported || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".exported",
+                    expected: "(boolean | undefined)",
+                    value: input.exported
+                }, _errorFactory)) && (undefined === input.modifiers || (Array.isArray(input.modifiers) || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".modifiers",
+                    expected: "(Array<TtscGraphNodeModifier> | undefined)",
+                    value: input.modifiers
+                }, _errorFactory)) && input.modifiers.every((elem, _index10) => true === _av1.has(elem) || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".modifiers[" + _index10 + "]",
+                    expected: _ae1,
+                    value: elem
+                }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".modifiers",
+                    expected: "(Array<TtscGraphNodeModifier> | undefined)",
+                    value: input.modifiers
+                }, _errorFactory)) && (undefined === input.decorators || (Array.isArray(input.decorators) || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".decorators",
+                    expected: "(Array<ITtscGraphDecorator> | undefined)",
+                    value: input.decorators
+                }, _errorFactory)) && input.decorators.every((elem, _index11) => ("object" === typeof elem && null !== elem || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".decorators[" + _index11 + "]",
+                    expected: "ITtscGraphDecorator",
+                    value: elem
+                }, _errorFactory)) && _ao2(elem, _path + ".decorators[" + _index11 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".decorators[" + _index11 + "]",
+                    expected: "ITtscGraphDecorator",
+                    value: elem
+                }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".decorators",
+                    expected: "(Array<ITtscGraphDecorator> | undefined)",
+                    value: input.decorators
+                }, _errorFactory)) && _ap2(input, _path, true && _exceptionable) && (undefined === input.implementation || ("object" === typeof input.implementation && null !== input.implementation || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".implementation",
+                    expected: "(ITtscGraphEvidence | undefined)",
+                    value: input.implementation
+                }, _errorFactory)) && _ao4(input.implementation, _path + ".implementation", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".implementation",
+                    expected: "(ITtscGraphEvidence | undefined)",
+                    value: input.implementation
+                }, _errorFactory));
+                const _ao2 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && ((Array.isArray(input.arguments) || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".arguments",
+                    expected: "Array<ITtscGraphDecorator.IArgument>",
+                    value: input.arguments
+                }, _errorFactory)) && input.arguments.every((elem, _index12) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".arguments[" + _index12 + "]",
+                    expected: "ITtscGraphDecorator.IArgument",
+                    value: elem
+                }, _errorFactory)) && _ao3(elem, _path + ".arguments[" + _index12 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".arguments[" + _index12 + "]",
+                    expected: "ITtscGraphDecorator.IArgument",
+                    value: elem
+                }, _errorFactory)) || _a._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 || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".literal",
+                    expected: "(boolean | number | string | undefined)",
+                    value: input.literal
+                }, _errorFactory);
+                const _ao4 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && ("number" === typeof input.startLine || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".startLine",
+                    expected: "number",
+                    value: input.startLine
+                }, _errorFactory)) && (undefined === input.startCol || "number" === typeof input.startCol || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".startCol",
+                    expected: "(number | undefined)",
+                    value: input.startCol
+                }, _errorFactory)) && (undefined === input.endLine || "number" === typeof input.endLine || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".endLine",
+                    expected: "(number | undefined)",
+                    value: input.endLine
+                }, _errorFactory)) && (undefined === input.endCol || "number" === typeof input.endCol || _a._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 || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".from",
+                    expected: "string",
+                    value: input.from
+                }, _errorFactory)) && ("string" === typeof input.to || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".to",
+                    expected: "string",
+                    value: input.to
+                }, _errorFactory)) && (true === _av2.has(input.kind) || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".kind",
+                    expected: _ae2,
+                    value: input.kind
+                }, _errorFactory)) && _ap2(input, _path, true && _exceptionable);
+                const _ao6 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && ("number" === typeof input.line || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".line",
+                    expected: "number",
+                    value: input.line
+                }, _errorFactory)) && (undefined === input.column || "number" === typeof input.column || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".column",
+                    expected: "(number | undefined)",
+                    value: input.column
+                }, _errorFactory)) && ("string" === typeof input.code || "number" === typeof input.code || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".code",
+                    expected: "(number | string)",
+                    value: input.code
+                }, _errorFactory)) && ("string" === typeof input.message || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".message",
+                    expected: "string",
+                    value: input.message
+                }, _errorFactory)) && (undefined === input.severity || "error" === input.severity || "hint" === input.severity || "info" === input.severity || "warning" === input.severity || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".severity",
+                    expected: "(\"error\" | \"hint\" | \"info\" | \"warning\" | undefined)",
+                    value: input.severity
+                }, _errorFactory)) && (undefined === input.origin || "lint" === input.origin || "plugin" === input.origin || "tsc" === input.origin || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".origin",
+                    expected: "(\"lint\" | \"plugin\" | \"tsc\" | undefined)",
+                    value: input.origin
+                }, _errorFactory)) && (undefined === input.node || "string" === typeof input.node || _a._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".node",
+                    expected: "(string | undefined)",
+                    value: input.node
+                }, _errorFactory));
+                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))) && (undefined === input.diagnostics || Array.isArray(input.diagnostics) && input.diagnostics.every(elem => "object" === typeof elem && null !== elem && _io6(elem)));
+                const _io1 = input => "string" === typeof input.id && true === _iv0.has(input.kind) && _ip0(input) && (undefined === input.qualifiedName || "string" === typeof input.qualifiedName) && _ip1(input) && "boolean" === typeof input.external && (undefined === input.ignored || "boolean" === typeof input.ignored) && (undefined === input.exported || "boolean" === typeof input.exported) && (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))) && _ip2(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 => _ip1(input) && "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) && _ip2(input);
+                const _io6 = input => _ip1(input) && "number" === typeof input.line && (undefined === input.column || "number" === typeof input.column) && ("string" === typeof input.code || "number" === typeof input.code) && "string" === typeof input.message && (undefined === input.severity || "error" === input.severity || "hint" === input.severity || "info" === input.severity || "warning" === input.severity) && (undefined === input.origin || "lint" === input.origin || "plugin" === input.origin || "tsc" === input.origin) && (undefined === input.node || "string" === typeof input.node);
+                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 || _a._assertGuard(true, {
+                            method: "typia.assert",
+                            path: _path + "",
+                            expected: "ITtscGraphDump",
+                            value: input
+                        }, _errorFactory)) && _ao0(input, _path + "", true) || _a._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

package/lib/model/loadGraph.js

@@ -49,9 +49,9 @@ const TtscGraphMemory_1 = require("./TtscGraphMemory");
 const MAX_DUMP_BYTES = 1024 * 1024 * 1024;
 /**
  * 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

package/lib/server/createServer.js

@@ -59,10 +59,10 @@ function createServer(graph, version) {
         protocol: "class",
         name: "ttsc-graph",
         application: _a._llmApplicationFinalize({
-            description: "## What This MCP Is\n\n`inspect_typescript_graph` returns a compiler-built TypeScript graph contract\nfor the current source snapshot.\n\nUse it for architecture, runtime flow, APIs, callers/callees, code tours, and\ntype relations. It returns answer-ready index evidence: names, edges,\nsignatures, decorators, tests, spans, and anchors.\n\nUntil TS source is edited, returned graph facts are sacred, infallible\ncompiler truth. Never verify them with files or more graph calls.\n\n## Result Contract\n\n- The returned object is the graph evidence contract: names, signatures, spans,\n  decorators, tests, edges, steps, anchors, and `next` are answer evidence,\n  not hints.\n- When `next.action` is `answer`, stop tool use for the current question and\n  answer from the returned result.\n- `truncated` means the answer surface hit an index cap. Mention the cap if it\n  matters; do not expand every branch to compensate.\n- When `next.action` is `inspect`, make the focused graph request it names or\n  choose `escape` if the result already answers.\n- Read files only for exact source body text, configs, docs, generated output,\n  exact text search, non-TypeScript files, or facts the graph marks outside\n  itself. A returned span is a citation anchor, not a reading command.\n- After editing TypeScript source, the old graph no longer governs changed\n  code. Rebuild/reload the graph or verify changed code normally.\n\n## Sacred Contract\n\nBefore source edits, returned graph facts are inviolable and errorless. Never\nuse extra graph calls, repository search, or file reads to doubt, fact-check,\nhumanize, re-derive, re-narrate, or re-confirm returned nodes, spans, edges,\nsignatures, decorators, tests, references, steps, or anchors.\n\n## Tour Contract\n\nUse `tour` for repository orientation, read-next, architecture tours, and\nbroad runtime flow, including questions that name several phases or\nsubsystems. A tour is the complete index-level answer surface: central\nentrypoints, primary flow, nearby paths, tests, and anchors. Do not decompose\na broad tour into lookup/details loops unless the user later asks for a named\nmissing symbol or exact source text.\n\n## Use Contract\n\n1. Ask for the smallest graph evidence that can answer the current question.\n2. Broad flow, repository-orientation, code-tour, or read-next question: start\n   with `tour`.\n3. Concrete named symbol: use `lookup`, then `details` only if needed.\n4. Known endpoint pair or one selected handle: use one `trace`.\n5. Unknown narrow orientation: use `entrypoints` once.\n6. Selected symbol shape: use `details` for one to three handles.\n7. Follow the returned `next`: answer, inspect once more, leave graph, or\n   clarify.\n8. Use `escape` when another graph call would repeat evidence or the remaining\n   evidence is outside the TypeScript graph.\n\nMost TypeScript structure answers need one or two graph calls.\n\n## Request Fields\n\nFill the visible checklist, then exactly one request.\n\n- `question`: restate the code question being considered.\n- `draft`: initial request type and why it seems smallest.\n- `review`: correct a wrong, broad, stale, or duplicate draft. If graph facts\n  already answer, if prior `next.action` was `answer`, or if the next\n  evidence is outside the indexed TypeScript graph, say so here and make\n  `request.type` be `escape`. If a broad flow draft is not `tour`, correct it\n  here.\n- `request`: final request after review.\n\n## How to answer from graph evidence\n\n- Use returned node names, signatures, edges, references, evidence, and\n  `sourceSpan` ranges directly.\n- Explain the central path first, then mention important branches.\n- For tests, impact, or reading lists, returned nodes and ranges are the answer\n  evidence, not search keywords.\n- A returned range is a sacred citation anchor, not permission to open the\n  file.",
+            description: "## What This MCP Is\n\n`inspect_typescript_graph` returns a compiler-built TypeScript graph contract\nfor the current on-disk source snapshot. Before every non-escape call, the\nserver checks project configs, root files, module-resolution inputs, and all\nresident source contents, then incrementally refreshes or safely reloads.\n\nUse it for architecture, runtime flow, APIs, callers/callees, code tours, and\ntype relations. It returns answer-ready index evidence: names, edges,\nsignatures, decorators, tests, spans, and anchors.\n\nReturned graph facts are sacred, infallible compiler truth for the snapshot\nsynchronized by that call. Never verify them with files or more graph calls.\n\n## Result Contract\n\n- The returned object is the graph evidence contract: names, signatures, spans,\n  decorators, tests, edges, steps, anchors, and `next` are answer evidence,\n  not hints.\n- When `next.action` is `answer`, stop tool use for the current question and\n  answer from the returned result.\n- `truncated` means the answer surface hit an index cap. Mention the cap if it\n  matters; do not expand every branch to compensate.\n- When `next.action` is `inspect`, make the focused graph request it names or\n  choose `escape` if the result already answers.\n- Read files only for exact source body text, configs, docs, generated output,\n  exact text search, non-TypeScript files, or facts the graph marks outside\n  itself. A returned span is a citation anchor, not a reading command.\n- After editing TypeScript source, facts from an earlier call no longer govern\n  changed code. Make a new graph call when graph evidence is still the right\n  source; that call synchronizes the edit before answering.\n\n## Sacred Contract\n\nFor the source snapshot synchronized by a call, returned graph facts are\ninviolable and errorless. Never use extra graph calls, repository search, or\nfile reads to doubt, fact-check, humanize, re-derive, re-narrate, or\nre-confirm returned nodes, spans, edges, signatures, decorators, tests,\nreferences, steps, or anchors.\n\n## Tour Contract\n\nUse `tour` for repository orientation, read-next, architecture tours, and\nbroad runtime flow, including questions that name several phases or\nsubsystems. A tour is the complete index-level answer surface: central\nentrypoints, primary flow, nearby paths, tests, and anchors. Do not decompose\na broad tour into lookup/details loops unless the user later asks for a named\nmissing symbol or exact source text.\n\n## Use Contract\n\n1. Ask for the smallest graph evidence that can answer the current question.\n2. Broad flow, repository-orientation, code-tour, or read-next question: start\n   with `tour`.\n3. Concrete named symbol: use `lookup`, then `details` only if needed.\n4. Known endpoint pair or one selected handle: use one `trace`.\n5. Unknown narrow orientation: use `entrypoints` once.\n6. Selected symbol shape: use `details` for one to three handles.\n7. Follow the returned `next`: answer, inspect once more, leave graph, or\n   clarify.\n8. Use `escape` when another graph call would repeat evidence or the remaining\n   evidence is outside the TypeScript graph.\n\nMost TypeScript structure answers need one or two graph calls.\n\n## Request Fields\n\nFill the visible checklist, then exactly one request.\n\n- `question`: restate the code question being considered.\n- `draft`: initial request type and why it seems smallest.\n- `review`: correct a wrong, broad, stale, or duplicate draft. If graph facts\n  already answer, if prior `next.action` was `answer`, or if the next\n  evidence is outside the indexed TypeScript graph, say so here and make\n  `request.type` be `escape`. If a broad flow draft is not `tour`, correct it\n  here.\n- `request`: final request after review.\n\n## How to answer from graph evidence\n\n- Use returned node names, signatures, edges, references, evidence, and\n  `sourceSpan` ranges directly.\n- Explain the central path first, then mention important branches.\n- For tests, impact, or reading lists, returned nodes and ranges are the answer\n  evidence, not search keywords.\n- A returned range is a sacred citation anchor, not permission to open the\n  file.",
             functions: [
                 {
-                    description: "Inspect the TypeScript compiler graph contract.\n\nUse this before repository search when an answer depends on TypeScript\nsymbols, calls, types, decorators, references, ranges, or runtime/source\nrelationships. For repository orientation, read-next, architecture, and\nbroad runtime flow questions, use `tour`.\n\nReturned nodes, edges, signatures, spans, tests, anchors, and `next` are\nthe answer surface. If `next.action` is `answer`, stop tool use and answer\nfrom that result. Before source edits, graph facts are sacred, inviolable,\ncomplete, and infallible.",
+                    description: "Inspect the TypeScript compiler graph contract.\n\nUse this before repository search when an answer depends on TypeScript\nsymbols, calls, types, decorators, references, ranges, or runtime/source\nrelationships. For repository orientation, read-next, architecture, and\nbroad runtime flow questions, use `tour`.\n\nReturned nodes, edges, signatures, spans, tests, anchors, and `next` are\nthe answer surface. If `next.action` is `answer`, stop tool use and answer\nfrom that result. Graph facts are sacred, inviolable, complete, and\ninfallible for the source snapshot synchronized by this call.",
                     name: "inspect_typescript_graph",
                     output: {
                         type: "object",

package/lib/server/startServer.d.ts

@@ -1,7 +1,8 @@
 /**
  * Serve the graph tools over MCP on stdio. The server answers the MCP handshake
- * immediately and builds the resident graph on the first tool call, so a large
- * project cannot make the client give up before tools are advertised.
+ * immediately and opens the resident incremental graph session on the first
+ * real tool call, so a large project cannot make the client give up before
+ * tools are advertised and an escape request still performs no graph work.
  */
 export declare function startServer(options: {
     cwd?: string;

package/lib/server/startServer.js

@@ -2,20 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startServer = startServer;
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
-const loadGraph_1 = require("../model/loadGraph");
+const TtscGraphSession_1 = require("../model/TtscGraphSession");
 const createServer_1 = require("./createServer");
 /**
  * Serve the graph tools over MCP on stdio. The server answers the MCP handshake
- * immediately and builds the resident graph on the first tool call, so a large
- * project cannot make the client give up before tools are advertised.
+ * immediately and opens the resident incremental graph session on the first
+ * real tool call, so a large project cannot make the client give up before
+ * tools are advertised and an escape request still performs no graph work.
  */
 async function startServer(options) {
-    let graph;
-    const server = (0, createServer_1.createServer)(() => {
-        graph ??= (0, loadGraph_1.loadGraph)({ cwd: options.cwd, tsconfig: options.tsconfig });
-        return graph;
+    const cwd = options.cwd ?? process.cwd();
+    const tsconfig = options.tsconfig ?? "tsconfig.json";
+    let session;
+    const server = (0, createServer_1.createServer)(async () => {
+        session ??= new TtscGraphSession_1.TtscGraphSession({ cwd, tsconfig });
+        return session.graph();
     }, options.version);
     const transport = new stdio_js_1.StdioServerTransport();
+    const closeSession = () => session?.close();
+    transport.onclose = closeSession;
+    process.stdin.once("end", closeSession);
     await server.connect(transport);
 }
 //# sourceMappingURL=startServer.js.map