@ttsc/graph 0.19.1 → 0.19.3

package/lib/model/TtscGraphSession.js

@@ -43,7 +43,17 @@ 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 loadGraph_1 = require("./loadGraph");
 const TtscGraphMemory_1 = require("./TtscGraphMemory");
+/**
+ * The serve protocol version this client speaks.
+ *
+ * Keep it equal to `serveProtocolVersion` in
+ * `packages/ttsc/cmd/ttscgraph/serve.go`. The two are hand-synchronized, and
+ * `serve_protocol_version_matches_the_typescript_client_test.go` reads this
+ * constant out of this file and fails if the pair drifts.
+ */
+const PROTOCOL_VERSION = 1;
 /**
  * Resident bridge to `ttscgraph serve`.
  *
@@ -108,23 +118,131 @@ class TtscGraphSession {
         this.failPending(new Error("@ttsc/graph: native session closed"));
     }
     async refresh() {
+        // The protocol version and the envelope shape were both settled in onLine,
+        // before this frame was ever routed here.
         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`);
+                throw new Error(`@ttsc/graph: native ${response.mode} response omitted its dump`);
             }
-            const dump = (() => {
+            this.current = TtscGraphMemory_1.TtscGraphMemory.from(response.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 parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch (error) {
+            this.failPending(new Error(`@ttsc/graph: native session returned invalid JSON: ${asError(error).message}`));
+            return;
+        }
+        // Read the version before the shape, because a server speaking another
+        // version is entitled to a different shape. Asserting first would report
+        // that mismatch as a field complaint — "expected string at $input.mode" —
+        // about a contract the other side never agreed to, which is the misparse
+        // this field exists to prevent. Ask what protocol it is first, then hold it
+        // to that protocol.
+        const version = (() => {
+            const _io0 = input => "number" === typeof input.protocolVersion;
+            return input => "object" === typeof input && null !== input && _io0(input);
+        })()(parsed) ? parsed.protocolVersion
+            : undefined;
+        if (version !== PROTOCOL_VERSION) {
+            // Session-wide: a version mismatch is not one bad frame, it is the wrong
+            // binary, and every request against it is equally doomed.
+            this.failPending(new Error(`@ttsc/graph: ttscgraph speaks serve protocol ${version === undefined ? "an unknown version" : `v${String(version)}`}, this client speaks v${String(PROTOCOL_VERSION)}. ` +
+                "Install a matching `ttsc` (the binary resolves from the target " +
+                "project, or from TTSC_GRAPH_BINARY)."));
+            return;
+        }
+        let response;
+        try {
+            // Validate the envelope, not just the dump it carries. The dump was
+            // typia-asserted while the envelope around it was a bare cast, so the
+            // fields the client actually branches on — the mode, and the id that
+            // routes the frame — were the unchecked ones. Anything added to the
+            // envelope belongs on this side of that line.
+            response = (() => {
+                const _ip0 = input => Array.isArray(input["capabilities"]) && input["capabilities"].every(elem => "string" === typeof elem);
+                const _ip1 = input => "string" === typeof input["file"];
                 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 _ip2 = 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 _ip3 = input => undefined === input["evidence"] || "object" === typeof input["evidence"] && null !== input["evidence"] && _io13(input["evidence"]);
                 const _iv2 = new Set(["accesses", "calls", "contains", "decorates", "dispatches", "exports", "extends", "implements", "imports", "instantiates", "overrides", "renders", "tests", "type_ref"]);
+                const _ap0 = (input, _path, _exceptionable = true) => (Array.isArray(input["capabilities"]) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".capabilities",
+                    expected: "Array<string>",
+                    value: input["capabilities"]
+                }, _errorFactory)) && input["capabilities"].every((elem, _index13) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".capabilities[" + _index13 + "]",
+                    expected: "string",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".capabilities",
+                    expected: "Array<string>",
+                    value: input["capabilities"]
+                }, _errorFactory);
+                const _ap1 = (input, _path, _exceptionable = true) => "string" === typeof input["file"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".file",
+                    expected: "string",
+                    value: input["file"]
+                }, _errorFactory);
                 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, {
+                const _ap2 = (input, _path, _exceptionable = true) => "string" === typeof input["name"] || _assertGuard_1._assertGuard(_exceptionable, {
                     method: "typia.assert",
                     path: _path + ".name",
                     expected: "string",
@@ -132,12 +250,12 @@ class TtscGraphSession {
                 }, _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, {
+                const _ap3 = (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, {
+                }, _errorFactory)) && _ao13(input["evidence"], _path + ".evidence", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
                     method: "typia.assert",
                     path: _path + ".evidence",
                     expected: "(ITtscGraphSpan | undefined)",
@@ -145,7 +263,43 @@ class TtscGraphSession {
                 }, _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, {
+                const _ao0 = (input, _path, _exceptionable = true) => ("number" === typeof input.id || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".id",
+                    expected: "number",
+                    value: input.id
+                }, _errorFactory)) && ("number" === typeof input.protocolVersion || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".protocolVersion",
+                    expected: "number",
+                    value: input.protocolVersion
+                }, _errorFactory)) && ("error" === input.mode || "incremental" === input.mode || "initial" === input.mode || "rebuild" === input.mode || "reload" === input.mode || "unchanged" === input.mode || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".mode",
+                    expected: "(\"error\" | \"incremental\" | \"initial\" | \"rebuild\" | \"reload\" | \"unchanged\")",
+                    value: input.mode
+                }, _errorFactory)) && _ap0(input, _path, true && _exceptionable) && ("boolean" === typeof input.changed || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".changed",
+                    expected: "boolean",
+                    value: input.changed
+                }, _errorFactory)) && (undefined === input.dump || ("object" === typeof input.dump && null !== input.dump || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".dump",
+                    expected: "(ITtscGraphDump | undefined)",
+                    value: input.dump
+                }, _errorFactory)) && _ao1(input.dump, _path + ".dump", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".dump",
+                    expected: "(ITtscGraphDump | undefined)",
+                    value: input.dump
+                }, _errorFactory)) && (undefined === input.error || "string" === typeof input.error || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".error",
+                    expected: "(string | undefined)",
+                    value: input.error
+                }, _errorFactory));
+                const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.project || _assertGuard_1._assertGuard(_exceptionable, {
                     method: "typia.assert",
                     path: _path + ".project",
                     expected: "string",
@@ -155,19 +309,49 @@ class TtscGraphSession {
                     path: _path + ".tsconfig",
                     expected: "string",
                     value: input.tsconfig
+                }, _errorFactory)) && (("object" === typeof input.provenance && null !== input.provenance || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".provenance",
+                    expected: "ITtscGraphDump.IProvenance",
+                    value: input.provenance
+                }, _errorFactory)) && _ao2(input.provenance, _path + ".provenance", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".provenance",
+                    expected: "ITtscGraphDump.IProvenance",
+                    value: input.provenance
+                }, _errorFactory)) && ((Array.isArray(input.diagnostics) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".diagnostics",
+                    expected: "Array<ITtscGraphDump.IDiagnostic>",
+                    value: input.diagnostics
+                }, _errorFactory)) && input.diagnostics.every((elem, _index14) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".diagnostics[" + _index14 + "]",
+                    expected: "ITtscGraphDump.IDiagnostic",
+                    value: elem
+                }, _errorFactory)) && _ao8(elem, _path + ".diagnostics[" + _index14 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".diagnostics[" + _index14 + "]",
+                    expected: "ITtscGraphDump.IDiagnostic",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".diagnostics",
+                    expected: "Array<ITtscGraphDump.IDiagnostic>",
+                    value: input.diagnostics
                 }, _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, {
+                }, _errorFactory)) && input.nodes.every((elem, _index15) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
                     method: "typia.assert",
-                    path: _path + ".nodes[" + _index6 + "]",
+                    path: _path + ".nodes[" + _index15 + "]",
                     expected: "ITtscGraphDump.INode",
                     value: elem
-                }, _errorFactory)) && _ao1(elem, _path + ".nodes[" + _index6 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                }, _errorFactory)) && _ao9(elem, _path + ".nodes[" + _index15 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
                     method: "typia.assert",
-                    path: _path + ".nodes[" + _index6 + "]",
+                    path: _path + ".nodes[" + _index15 + "]",
                     expected: "ITtscGraphDump.INode",
                     value: elem
                 }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -180,14 +364,14 @@ class TtscGraphSession {
                     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, {
+                }, _errorFactory)) && input.edges.every((elem, _index16) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
                     method: "typia.assert",
-                    path: _path + ".edges[" + _index7 + "]",
+                    path: _path + ".edges[" + _index16 + "]",
                     expected: "ITtscGraphDump.IEdge",
                     value: elem
-                }, _errorFactory)) && _ao5(elem, _path + ".edges[" + _index7 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                }, _errorFactory)) && _ao14(elem, _path + ".edges[" + _index16 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
                     method: "typia.assert",
-                    path: _path + ".edges[" + _index7 + "]",
+                    path: _path + ".edges[" + _index16 + "]",
                     expected: "ITtscGraphDump.IEdge",
                     value: elem
                 }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -196,7 +380,234 @@ class TtscGraphSession {
                     expected: "Array<ITtscGraphDump.IEdge>",
                     value: input.edges
                 }, _errorFactory));
-                const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_1._assertGuard(_exceptionable, {
+                const _ao10 = (input, _path, _exceptionable = true) => _ap2(input, _path, true && _exceptionable) && (undefined === input.value || "string" === typeof input.value || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".value",
+                    expected: "(string | undefined)",
+                    value: input.value
+                }, _errorFactory));
+                const _ao11 = (input, _path, _exceptionable = true) => _ap2(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, _index24) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".arguments[" + _index24 + "]",
+                    expected: "ITtscGraphDecorator.IArgument",
+                    value: elem
+                }, _errorFactory)) && _ao12(elem, _path + ".arguments[" + _index24 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".arguments[" + _index24 + "]",
+                    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 _ao12 = (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 _ao13 = (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 _ao14 = (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)) && _ap3(input, _path, true && _exceptionable);
+                const _ao2 = (input, _path, _exceptionable = true) => ("number" === typeof input.schemaVersion || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".schemaVersion",
+                    expected: "number",
+                    value: input.schemaVersion
+                }, _errorFactory)) && _ap0(input, _path, true && _exceptionable) && (("object" === typeof input.producer && null !== input.producer || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".producer",
+                    expected: "ITtscGraphDump.IProducer",
+                    value: input.producer
+                }, _errorFactory)) && _ao3(input.producer, _path + ".producer", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".producer",
+                    expected: "ITtscGraphDump.IProducer",
+                    value: input.producer
+                }, _errorFactory)) && (("object" === typeof input.universe && null !== input.universe || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".universe",
+                    expected: "ITtscGraphDump.IUniverse",
+                    value: input.universe
+                }, _errorFactory)) && _ao4(input.universe, _path + ".universe", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".universe",
+                    expected: "ITtscGraphDump.IUniverse",
+                    value: input.universe
+                }, _errorFactory)) && ((Array.isArray(input.sources) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".sources",
+                    expected: "Array<ITtscGraphDump.ISourceDigest>",
+                    value: input.sources
+                }, _errorFactory)) && input.sources.every((elem, _index17) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".sources[" + _index17 + "]",
+                    expected: "ITtscGraphDump.ISourceDigest",
+                    value: elem
+                }, _errorFactory)) && _ao7(elem, _path + ".sources[" + _index17 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".sources[" + _index17 + "]",
+                    expected: "ITtscGraphDump.ISourceDigest",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".sources",
+                    expected: "Array<ITtscGraphDump.ISourceDigest>",
+                    value: input.sources
+                }, _errorFactory));
+                const _ao3 = (input, _path, _exceptionable = true) => ("string" === typeof input.tool || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".tool",
+                    expected: "string",
+                    value: input.tool
+                }, _errorFactory)) && ("string" === typeof input.version || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".version",
+                    expected: "string",
+                    value: input.version
+                }, _errorFactory)) && ("string" === typeof input.typescript || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".typescript",
+                    expected: "string",
+                    value: input.typescript
+                }, _errorFactory));
+                const _ao4 = (input, _path, _exceptionable = true) => ((Array.isArray(input.configs) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".configs",
+                    expected: "Array<ITtscGraphDump.IFileDigest>",
+                    value: input.configs
+                }, _errorFactory)) && input.configs.every((elem, _index18) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".configs[" + _index18 + "]",
+                    expected: "ITtscGraphDump.IFileDigest",
+                    value: elem
+                }, _errorFactory)) && _ao5(elem, _path + ".configs[" + _index18 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".configs[" + _index18 + "]",
+                    expected: "ITtscGraphDump.IFileDigest",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".configs",
+                    expected: "Array<ITtscGraphDump.IFileDigest>",
+                    value: input.configs
+                }, _errorFactory)) && ((Array.isArray(input.roots) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".roots",
+                    expected: "Array<ITtscGraphDump.IRootFile>",
+                    value: input.roots
+                }, _errorFactory)) && input.roots.every((elem, _index19) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".roots[" + _index19 + "]",
+                    expected: "ITtscGraphDump.IRootFile",
+                    value: elem
+                }, _errorFactory)) && _ao6(elem, _path + ".roots[" + _index19 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".roots[" + _index19 + "]",
+                    expected: "ITtscGraphDump.IRootFile",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".roots",
+                    expected: "Array<ITtscGraphDump.IRootFile>",
+                    value: input.roots
+                }, _errorFactory));
+                const _ao5 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && ("string" === typeof input.digest || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".digest",
+                    expected: "string",
+                    value: input.digest
+                }, _errorFactory));
+                const _ao6 = (input, _path, _exceptionable = true) => ("string" === typeof input.config || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".config",
+                    expected: "string",
+                    value: input.config
+                }, _errorFactory)) && _ap1(input, _path, true && _exceptionable);
+                const _ao7 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && ("string" === typeof input.checkerDigest || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".checkerDigest",
+                    expected: "string",
+                    value: input.checkerDigest
+                }, _errorFactory)) && ("string" === typeof input.diskDigest || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".diskDigest",
+                    expected: "string",
+                    value: input.diskDigest
+                }, _errorFactory));
+                const _ao8 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && ("number" === typeof input.line || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".line",
+                    expected: "number",
+                    value: input.line
+                }, _errorFactory)) && ("number" === typeof input.column || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".column",
+                    expected: "number",
+                    value: input.column
+                }, _errorFactory)) && ("number" === typeof input.code || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".code",
+                    expected: "number",
+                    value: input.code
+                }, _errorFactory)) && ("error" === input.category || "warning" === input.category || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".category",
+                    expected: "(\"error\" | \"warning\")",
+                    value: input.category
+                }, _errorFactory)) && ("string" === typeof input.message || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".message",
+                    expected: "string",
+                    value: input.message
+                }, _errorFactory));
+                const _ao9 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_1._assertGuard(_exceptionable, {
                     method: "typia.assert",
                     path: _path + ".id",
                     expected: "string",
@@ -206,17 +617,12 @@ class TtscGraphSession {
                     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, {
+                }, _errorFactory)) && _ap2(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, {
+                }, _errorFactory)) && _ap1(input, _path, true && _exceptionable) && ("boolean" === typeof input.external || _assertGuard_1._assertGuard(_exceptionable, {
                     method: "typia.assert",
                     path: _path + ".external",
                     expected: "boolean",
@@ -241,9 +647,9 @@ class TtscGraphSession {
                     path: _path + ".modifiers",
                     expected: "(Array<TtscGraphNodeModifier> | undefined)",
                     value: input.modifiers
-                }, _errorFactory)) && input.modifiers.every((elem, _index8) => true === _av1.has(elem) || _assertGuard_1._assertGuard(_exceptionable, {
+                }, _errorFactory)) && input.modifiers.every((elem, _index20) => true === _av1.has(elem) || _assertGuard_1._assertGuard(_exceptionable, {
                     method: "typia.assert",
-                    path: _path + ".modifiers[" + _index8 + "]",
+                    path: _path + ".modifiers[" + _index20 + "]",
                     expected: _ae1,
                     value: elem
                 }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -251,19 +657,54 @@ class TtscGraphSession {
                     path: _path + ".modifiers",
                     expected: "(Array<TtscGraphNodeModifier> | undefined)",
                     value: input.modifiers
+                }, _errorFactory)) && (undefined === input.literals || (Array.isArray(input.literals) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".literals",
+                    expected: "(Array<string> | undefined)",
+                    value: input.literals
+                }, _errorFactory)) && input.literals.every((elem, _index21) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".literals[" + _index21 + "]",
+                    expected: "string",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".literals",
+                    expected: "(Array<string> | undefined)",
+                    value: input.literals
+                }, _errorFactory)) && (undefined === input.enumMembers || (Array.isArray(input.enumMembers) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".enumMembers",
+                    expected: "(Array<ITtscGraphNode.IEnumMember> | undefined)",
+                    value: input.enumMembers
+                }, _errorFactory)) && input.enumMembers.every((elem, _index22) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".enumMembers[" + _index22 + "]",
+                    expected: "ITtscGraphNode.IEnumMember",
+                    value: elem
+                }, _errorFactory)) && _ao10(elem, _path + ".enumMembers[" + _index22 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".enumMembers[" + _index22 + "]",
+                    expected: "ITtscGraphNode.IEnumMember",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path + ".enumMembers",
+                    expected: "(Array<ITtscGraphNode.IEnumMember> | undefined)",
+                    value: input.enumMembers
                 }, _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, {
+                }, _errorFactory)) && input.decorators.every((elem, _index23) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
                     method: "typia.assert",
-                    path: _path + ".decorators[" + _index9 + "]",
+                    path: _path + ".decorators[" + _index23 + "]",
                     expected: "ITtscGraphDecorator",
                     value: elem
-                }, _errorFactory)) && _ao2(elem, _path + ".decorators[" + _index9 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                }, _errorFactory)) && _ao11(elem, _path + ".decorators[" + _index23 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
                     method: "typia.assert",
-                    path: _path + ".decorators[" + _index9 + "]",
+                    path: _path + ".decorators[" + _index23 + "]",
                     expected: "ITtscGraphDecorator",
                     value: elem
                 }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -271,92 +712,32 @@ class TtscGraphSession {
                     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, {
+                }, _errorFactory)) && _ap3(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, {
+                }, _errorFactory)) && _ao13(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 _io0 = input => "number" === typeof input.id && "number" === typeof input.protocolVersion && ("error" === input.mode || "incremental" === input.mode || "initial" === input.mode || "rebuild" === input.mode || "reload" === input.mode || "unchanged" === input.mode) && _ip0(input) && "boolean" === typeof input.changed && (undefined === input.dump || "object" === typeof input.dump && null !== input.dump && _io1(input.dump)) && (undefined === input.error || "string" === typeof input.error);
+                const _io1 = input => "string" === typeof input.project && "string" === typeof input.tsconfig && ("object" === typeof input.provenance && null !== input.provenance && _io2(input.provenance)) && (Array.isArray(input.diagnostics) && input.diagnostics.every(elem => "object" === typeof elem && null !== elem && _io8(elem))) && (Array.isArray(input.nodes) && input.nodes.every(elem => "object" === typeof elem && null !== elem && _io9(elem))) && (Array.isArray(input.edges) && input.edges.every(elem => "object" === typeof elem && null !== elem && _io14(elem)));
+                const _io10 = input => _ip2(input) && (undefined === input.value || "string" === typeof input.value);
+                const _io11 = input => _ip2(input) && (Array.isArray(input.arguments) && input.arguments.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _io12(elem)));
+                const _io12 = input => undefined === input.literal || "string" === typeof input.literal || "number" === typeof input.literal || "boolean" === typeof input.literal;
+                const _io13 = 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 _io14 = input => "string" === typeof input.from && "string" === typeof input.to && true === _iv2.has(input.kind) && _ip3(input);
+                const _io2 = input => "number" === typeof input.schemaVersion && _ip0(input) && ("object" === typeof input.producer && null !== input.producer && _io3(input.producer)) && ("object" === typeof input.universe && null !== input.universe && _io4(input.universe)) && (Array.isArray(input.sources) && input.sources.every(elem => "object" === typeof elem && null !== elem && _io7(elem)));
+                const _io3 = input => "string" === typeof input.tool && "string" === typeof input.version && "string" === typeof input.typescript;
+                const _io4 = input => Array.isArray(input.configs) && input.configs.every(elem => "object" === typeof elem && null !== elem && _io5(elem)) && (Array.isArray(input.roots) && input.roots.every(elem => "object" === typeof elem && null !== elem && _io6(elem)));
+                const _io5 = input => _ip1(input) && "string" === typeof input.digest;
+                const _io6 = input => "string" === typeof input.config && _ip1(input);
+                const _io7 = input => _ip1(input) && "string" === typeof input.checkerDigest && "string" === typeof input.diskDigest;
+                const _io8 = input => _ip1(input) && "number" === typeof input.line && "number" === typeof input.column && "number" === typeof input.code && ("error" === input.category || "warning" === input.category) && "string" === typeof input.message;
+                const _io9 = input => "string" === typeof input.id && true === _iv0.has(input.kind) && _ip2(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.closure || "boolean" === typeof input.closure) && (undefined === input.modifiers || Array.isArray(input.modifiers) && input.modifiers.every(elem => true === _iv1.has(elem))) && (undefined === input.literals || Array.isArray(input.literals) && input.literals.every(elem => "string" === typeof elem)) && (undefined === input.enumMembers || Array.isArray(input.enumMembers) && input.enumMembers.every(elem => "object" === typeof elem && null !== elem && _io10(elem))) && (undefined === input.decorators || Array.isArray(input.decorators) && input.decorators.every(elem => "object" === typeof elem && null !== elem && _io11(elem))) && _ip3(input) && (undefined === input.implementation || "object" === typeof input.implementation && null !== input.implementation && _io13(input.implementation));
                 const __is = input => "object" === typeof input && null !== input && _io0(input);
                 let _errorFactory;
                 return (input, errorFactory) => {
@@ -365,72 +746,38 @@ class TtscGraphSession {
                         ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _assertGuard_1._assertGuard(true, {
                             method: "typia.assert",
                             path: _path + "",
-                            expected: "ITtscGraphDump",
+                            expected: "ITtscGraphSnapshot",
                             value: input
                         }, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard_1._assertGuard(true, {
                             method: "typia.assert",
                             path: _path + "",
-                            expected: "ITtscGraphDump",
+                            expected: "ITtscGraphSnapshot",
                             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);
+            })()(parsed);
         }
         catch (error) {
-            this.failPending(new Error(`@ttsc/graph: native session returned invalid JSON: ${asError(error).message}`));
+            this.failPending(new Error(`@ttsc/graph: native session returned an unreadable response: ${asError(error).message}`));
+            return;
+        }
+        // The envelope's version is not the body's, and only the envelope has been
+        // held to one so far. A producer can speak this protocol and still carry a
+        // dump from another schema — the two move apart the moment a node field is
+        // added without the frame around it changing — and then the facts that field
+        // holds are silently absent rather than refused. `literals` is exactly that
+        // shape: an older producer resolves no value set, so a union comes back
+        // looking like a type with no members. Hold the body to its own number too,
+        // once the frame is understood.
+        if (response.dump !== undefined &&
+            response.dump.provenance.schemaVersion !== loadGraph_1.DUMP_SCHEMA_VERSION) {
+            // Session-wide, for the same reason the protocol mismatch above is: it is
+            // the wrong binary, not one bad frame.
+            this.failPending(new Error(`@ttsc/graph: ttscgraph sends dump schema v${String(response.dump.provenance.schemaVersion)}, this client reads v${String(loadGraph_1.DUMP_SCHEMA_VERSION)}. ` +
+                "Install a matching `ttsc` (the binary resolves from the target " +
+                "project, or from TTSC_GRAPH_BINARY)."));
             return;
         }
         const pending = this.pending.get(response.id);