@ttsc/graph 0.18.3 → 0.19.0

package/lib/model/loadGraph.js

@@ -37,7 +37,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadGraph = loadGraph;
-const _a = __importStar(require("typia/lib/internal/_assertGuard"));
+const _assertGuard_1 = __importStar(require("typia/lib/internal/_assertGuard"));
 const node_child_process_1 = require("node:child_process");
 const typia_1 = __importDefault(require("typia"));
 const nativeExecutable_1 = require("../nativeExecutable");
@@ -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
@@ -60,7 +60,9 @@ const MAX_DUMP_BYTES = 1024 * 1024 * 1024;
 function loadGraph(options = {}) {
     const cwd = options.cwd ?? process.cwd();
     const tsconfig = options.tsconfig ?? "tsconfig.json";
-    const binary = options.binary ?? (0, resolveGraphBinary_1.resolveGraphBinary)();
+    // Resolve the platform binary from the selected project cwd, not the caller's
+    // process directory, so a one-shot load names its own installation.
+    const binary = options.binary ?? (0, resolveGraphBinary_1.resolveGraphBinary)(process.env, cwd);
     if (binary === null) {
         throw new Error("@ttsc/graph: could not resolve the ttscgraph binary. " +
             "Install `ttsc` so its platform package is present, " +
@@ -93,304 +95,255 @@ function parseDump(json) {
     return (() => {
         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 _ip1 = input => undefined === input["evidence"] || "object" === typeof input["evidence"] && null !== input["evidence"] && _io4(input["evidence"]);
+        const _iv2 = new Set(["accesses", "calls", "contains", "decorates", "dispatches", "exports", "extends", "implements", "imports", "instantiates", "overrides", "renders", "tests", "type_ref"]);
         const _av0 = new Set(["class", "enum", "external_symbol", "file", "function", "interface", "method", "module", "namespace", "package", "parameter", "property", "type", "variable"]);
         const _ae0 = "(\"class\" | \"enum\" | \"external_symbol\" | \"file\" | \"function\" | \"interface\" | \"method\" | \"module\" | \"namespace\" | \"package\" | \"parameter\" | \"property\" | \"type\" | \"variable\")";
-        const _ap0 = (input, _path, _exceptionable = true) => "string" === typeof input["name"] || _a._assertGuard(_exceptionable, {
+        const _ap0 = (input, _path, _exceptionable = true) => "string" === typeof input["name"] || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".name",
             expected: "string",
             value: input["name"]
         }, _errorFactory);
-        const _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, {
+        const _ap1 = (input, _path, _exceptionable = true) => undefined === input["evidence"] || ("object" === typeof input["evidence"] && null !== input["evidence"] || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".evidence",
-            expected: "(ITtscGraphEvidence | undefined)",
+            expected: "(ITtscGraphSpan | undefined)",
             value: input["evidence"]
-        }, _errorFactory)) && _ao4(input["evidence"], _path + ".evidence", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) && _ao4(input["evidence"], _path + ".evidence", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".evidence",
-            expected: "(ITtscGraphEvidence | undefined)",
+            expected: "(ITtscGraphSpan | 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, {
+        const _av2 = new Set(["accesses", "calls", "contains", "decorates", "dispatches", "exports", "extends", "implements", "imports", "instantiates", "overrides", "renders", "tests", "type_ref"]);
+        const _ae2 = "(\"accesses\" | \"calls\" | \"contains\" | \"decorates\" | \"dispatches\" | \"exports\" | \"extends\" | \"implements\" | \"imports\" | \"instantiates\" | \"overrides\" | \"renders\" | \"tests\" | \"type_ref\")";
+        const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.project || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".project",
             expected: "string",
             value: input.project
-        }, _errorFactory)) && ("string" === typeof input.tsconfig || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) && ("string" === typeof input.tsconfig || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".tsconfig",
             expected: "string",
             value: input.tsconfig
-        }, _errorFactory)) && ((Array.isArray(input.nodes) || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) && ((Array.isArray(input.nodes) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".nodes",
-            expected: "Array<ITtscGraphNode>",
+            expected: "Array<ITtscGraphDump.INode>",
             value: input.nodes
-        }, _errorFactory)) && input.nodes.every((elem, _index7) => ("object" === typeof elem && null !== elem || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) && input.nodes.every((elem, _index6) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".nodes[" + _index7 + "]",
-            expected: "ITtscGraphNode",
+            path: _path + ".nodes[" + _index6 + "]",
+            expected: "ITtscGraphDump.INode",
             value: elem
-        }, _errorFactory)) && _ao1(elem, _path + ".nodes[" + _index7 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) && _ao1(elem, _path + ".nodes[" + _index6 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".nodes[" + _index7 + "]",
-            expected: "ITtscGraphNode",
+            path: _path + ".nodes[" + _index6 + "]",
+            expected: "ITtscGraphDump.INode",
             value: elem
-        }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".nodes",
-            expected: "Array<ITtscGraphNode>",
+            expected: "Array<ITtscGraphDump.INode>",
             value: input.nodes
-        }, _errorFactory)) && ((Array.isArray(input.edges) || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) && ((Array.isArray(input.edges) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".edges",
-            expected: "Array<ITtscGraphEdge>",
+            expected: "Array<ITtscGraphDump.IEdge>",
             value: input.edges
-        }, _errorFactory)) && input.edges.every((elem, _index8) => ("object" === typeof elem && null !== elem || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) && input.edges.every((elem, _index7) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".edges[" + _index8 + "]",
-            expected: "ITtscGraphEdge",
+            path: _path + ".edges[" + _index7 + "]",
+            expected: "ITtscGraphDump.IEdge",
             value: elem
-        }, _errorFactory)) && _ao5(elem, _path + ".edges[" + _index8 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) && _ao5(elem, _path + ".edges[" + _index7 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".edges[" + _index8 + "]",
-            expected: "ITtscGraphEdge",
+            path: _path + ".edges[" + _index7 + "]",
+            expected: "ITtscGraphDump.IEdge",
             value: elem
-        }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".edges",
-            expected: "Array<ITtscGraphEdge>",
+            expected: "Array<ITtscGraphDump.IEdge>",
             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, {
+        const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".id",
             expected: "string",
             value: input.id
-        }, _errorFactory)) && (true === _av0.has(input.kind) || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) && (true === _av0.has(input.kind) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".kind",
             expected: _ae0,
             value: input.kind
-        }, _errorFactory)) && _ap0(input, _path, true && _exceptionable) && (undefined === input.qualifiedName || "string" === typeof input.qualifiedName || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) && _ap0(input, _path, true && _exceptionable) && (undefined === input.qualifiedName || "string" === typeof input.qualifiedName || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".qualifiedName",
             expected: "(string | undefined)",
             value: input.qualifiedName
-        }, _errorFactory)) && _ap1(input, _path, true && _exceptionable) && ("boolean" === typeof input.external || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) && ("string" === typeof input.file || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".file",
+            expected: "string",
+            value: input.file
+        }, _errorFactory)) && ("boolean" === typeof input.external || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".external",
             expected: "boolean",
             value: input.external
-        }, _errorFactory)) && (undefined === input.ignored || "boolean" === typeof input.ignored || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) && (undefined === input.ignored || "boolean" === typeof input.ignored || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".ignored",
             expected: "(boolean | undefined)",
             value: input.ignored
-        }, _errorFactory)) && (undefined === input.exported || "boolean" === typeof input.exported || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) && (undefined === input.exported || "boolean" === typeof input.exported || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".exported",
             expected: "(boolean | undefined)",
             value: input.exported
-        }, _errorFactory)) && (undefined === input.modifiers || (Array.isArray(input.modifiers) || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) && (undefined === input.closure || "boolean" === typeof input.closure || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".closure",
+            expected: "(boolean | undefined)",
+            value: input.closure
+        }, _errorFactory)) && (undefined === input.modifiers || (Array.isArray(input.modifiers) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".modifiers",
             expected: "(Array<TtscGraphNodeModifier> | undefined)",
             value: input.modifiers
-        }, _errorFactory)) && input.modifiers.every((elem, _index10) => true === _av1.has(elem) || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) && input.modifiers.every((elem, _index8) => true === _av1.has(elem) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".modifiers[" + _index10 + "]",
+            path: _path + ".modifiers[" + _index8 + "]",
             expected: _ae1,
             value: elem
-        }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".modifiers",
             expected: "(Array<TtscGraphNodeModifier> | undefined)",
             value: input.modifiers
-        }, _errorFactory)) && (undefined === input.decorators || (Array.isArray(input.decorators) || _a._assertGuard(_exceptionable, {
+        }, _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, _index11) => ("object" === typeof elem && null !== elem || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) && input.decorators.every((elem, _index9) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".decorators[" + _index11 + "]",
+            path: _path + ".decorators[" + _index9 + "]",
             expected: "ITtscGraphDecorator",
             value: elem
-        }, _errorFactory)) && _ao2(elem, _path + ".decorators[" + _index11 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) && _ao2(elem, _path + ".decorators[" + _index9 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".decorators[" + _index11 + "]",
+            path: _path + ".decorators[" + _index9 + "]",
             expected: "ITtscGraphDecorator",
             value: elem
-        }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) || _assertGuard_1._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, {
+        }, _errorFactory)) && _ap1(input, _path, true && _exceptionable) && (undefined === input.implementation || ("object" === typeof input.implementation && null !== input.implementation || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".implementation",
-            expected: "(ITtscGraphEvidence | undefined)",
+            expected: "(ITtscGraphSpan | undefined)",
             value: input.implementation
-        }, _errorFactory)) && _ao4(input.implementation, _path + ".implementation", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) && _ao4(input.implementation, _path + ".implementation", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".implementation",
-            expected: "(ITtscGraphEvidence | undefined)",
+            expected: "(ITtscGraphSpan | undefined)",
             value: input.implementation
         }, _errorFactory));
-        const _ao2 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && ((Array.isArray(input.arguments) || _a._assertGuard(_exceptionable, {
+        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, _index12) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || _a._assertGuard(_exceptionable, {
+        }, _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[" + _index12 + "]",
+            path: _path + ".arguments[" + _index10 + "]",
             expected: "ITtscGraphDecorator.IArgument",
             value: elem
-        }, _errorFactory)) && _ao3(elem, _path + ".arguments[" + _index12 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) && _ao3(elem, _path + ".arguments[" + _index10 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".arguments[" + _index12 + "]",
+            path: _path + ".arguments[" + _index10 + "]",
             expected: "ITtscGraphDecorator.IArgument",
             value: elem
-        }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+        }, _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 || _a._assertGuard(_exceptionable, {
+        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) => _ap1(input, _path, true && _exceptionable) && ("number" === typeof input.startLine || _a._assertGuard(_exceptionable, {
+        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 || _a._assertGuard(_exceptionable, {
+        }, _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 || _a._assertGuard(_exceptionable, {
+        }, _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 || _a._assertGuard(_exceptionable, {
+        }, _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 || _a._assertGuard(_exceptionable, {
+        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 || _a._assertGuard(_exceptionable, {
+        }, _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) || _a._assertGuard(_exceptionable, {
+        }, _errorFactory)) && (true === _av2.has(input.kind) || _assertGuard_1._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));
+        }, _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 => _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 _io4 = input => (undefined === input.file || "string" === typeof input.file) && "number" === typeof input.startLine && (undefined === input.startCol || "number" === typeof input.startCol) && (undefined === input.endLine || "number" === typeof input.endLine) && (undefined === input.endCol || "number" === typeof input.endCol);
+        const _io5 = input => "string" === typeof input.from && "string" === typeof input.to && true === _iv2.has(input.kind) && _ip1(input);
         const __is = input => "object" === typeof input && null !== input && _io0(input);
         let _errorFactory;
         return (input, errorFactory) => {
             if (false === __is(input)) {
                 _errorFactory = errorFactory;
-                ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _a._assertGuard(true, {
+                ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _assertGuard_1._assertGuard(true, {
                     method: "typia.assert",
                     path: _path + "",
                     expected: "ITtscGraphDump",
                     value: input
-                }, _errorFactory)) && _ao0(input, _path + "", true) || _a._assertGuard(true, {
+                }, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard_1._assertGuard(true, {
                     method: "typia.assert",
                     path: _path + "",
                     expected: "ITtscGraphDump",

package/lib/model/loadGraph.js.map

@@ -1 +1 @@
-{"version":3,"file":"loadGraph.js","sourceRoot":"","sources":["../../src/model/loadGraph.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2DAA+C;AAC/C,kDAA0B;AAE1B,0DAAuD;AACvD,8DAA2D;AAE3D,uDAAoD;AAEpD,4EAA4E;AAC5E,+EAA+E;AAC/E,uDAAuD;AACvD,MAAM,cAAc,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAE1C;;;;;;;;;GASG;AACH,mBACE,OAAO,GAWH,EAAE;IAEN,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;IACzC,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,eAAe,CAAC;IACrD,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,IAAA,uCAAkB,GAAE,CAAC;IACtD,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CACb,uDAAuD;YACrD,qDAAqD;YACrD,+CAA+C,CAClD,CAAC;IACJ,CAAC;IACD,IAAA,mCAAgB,EAAC,MAAM,CAAC,CAAC;IAEzB,MAAM,MAAM,GAAG,IAAA,8BAAS,EACtB,MAAM,EACN,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,YAAY,EAAE,QAAQ,CAAC,EAC9C,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,WAAW,EAAE,IAAI,EAAE,CACnE,CAAC;IACF,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CACb,uCAAuC,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,CAC9D,CAAC;IACJ,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CACb,2CAA2C,MAAM,CAAC,MAAM,KAAK,CAAC,MAAM,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAC5F,CAAC;IACJ,CAAC;IAED,OAAO,iCAAe,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;AACxD,CAAC;AAED;;;;;GAKG;AACH,SAAS,SAAS,CAAC,IAAY;IAC7B,IAAI,KAAc,CAAC;IACnB,IAAI,CAAC;QACH,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CACb,+CACE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CACvD,EAAE,CACH,CAAC;IACJ,CAAC;IACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAAoC,KAAK,EAAE;AAC7C,CAAC"}
+{"version":3,"file":"loadGraph.js","sourceRoot":"","sources":["../../src/model/loadGraph.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2DAA+C;AAC/C,kDAA0B;AAE1B,0DAAuD;AACvD,8DAA2D;AAE3D,uDAAoD;AAEpD,4EAA4E;AAC5E,+EAA+E;AAC/E,uDAAuD;AACvD,MAAM,cAAc,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAE1C;;;;;;;;;GASG;AACH,mBACE,OAAO,GAWH,EAAE;IAEN,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;IACzC,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,eAAe,CAAC;IACrD,8EAA8E;IAC9E,oEAAoE;IACpE,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,IAAA,uCAAkB,EAAC,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IACtE,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CACb,uDAAuD;YACrD,qDAAqD;YACrD,+CAA+C,CAClD,CAAC;IACJ,CAAC;IACD,IAAA,mCAAgB,EAAC,MAAM,CAAC,CAAC;IAEzB,MAAM,MAAM,GAAG,IAAA,8BAAS,EACtB,MAAM,EACN,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,YAAY,EAAE,QAAQ,CAAC,EAC9C,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,WAAW,EAAE,IAAI,EAAE,CACnE,CAAC;IACF,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CACb,uCAAuC,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,CAC9D,CAAC;IACJ,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CACb,2CAA2C,MAAM,CAAC,MAAM,KAAK,CAAC,MAAM,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAC5F,CAAC;IACJ,CAAC;IAED,OAAO,iCAAe,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;AACxD,CAAC;AAED;;;;;GAKG;AACH,SAAS,SAAS,CAAC,IAAY;IAC7B,IAAI,KAAc,CAAC;IACnB,IAAI,CAAC;QACH,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CACb,+CACE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CACvD,EAAE,CACH,CAAC;IACJ,CAAC;IACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAAoC,KAAK,EAAE;AAC7C,CAAC"}

package/lib/resolveGraphBinary.d.ts

@@ -12,7 +12,9 @@
  * 2. The per-platform npm package `@ttsc/<platform>-<arch>/bin/ttscgraph[.exe]`.
  *    That package carries `ttsc`, `ttscserver`, and `ttscgraph` together and is
  *    an `optionalDependency` of `ttsc`, so it is resolved from `ttsc`'s
- *    location — found from `process.cwd()` (the project where the agent ran the
- *    server).
+ *    location — found from `cwd`, the project the caller selected (via `--cwd`
+ *    or an API `cwd` option), defaulting to `process.cwd()` when no project was
+ *    named. A launcher started from an unrelated directory still resolves the
+ *    `ttsc` installed under the target project it was asked to graph.
  */
 export declare function resolveGraphBinary(env?: NodeJS.ProcessEnv, cwd?: string): string | null;

package/lib/resolveGraphBinary.js

@@ -20,8 +20,10 @@ const node_path_1 = __importDefault(require("node:path"));
  * 2. The per-platform npm package `@ttsc/<platform>-<arch>/bin/ttscgraph[.exe]`.
  *    That package carries `ttsc`, `ttscserver`, and `ttscgraph` together and is
  *    an `optionalDependency` of `ttsc`, so it is resolved from `ttsc`'s
- *    location — found from `process.cwd()` (the project where the agent ran the
- *    server).
+ *    location — found from `cwd`, the project the caller selected (via `--cwd`
+ *    or an API `cwd` option), defaulting to `process.cwd()` when no project was
+ *    named. A launcher started from an unrelated directory still resolves the
+ *    `ttsc` installed under the target project it was asked to graph.
  */
 function resolveGraphBinary(env = process.env, cwd = process.cwd()) {
     if (env.TTSC_GRAPH_BINARY && node_path_1.default.isAbsolute(env.TTSC_GRAPH_BINARY)) {
@@ -29,8 +31,10 @@ function resolveGraphBinary(env = process.env, cwd = process.cwd()) {
     }
     const exe = process.platform === "win32" ? "ttscgraph.exe" : "ttscgraph";
     try {
+        // Anchor package lookup at the absolute project root so a relative `--cwd`
+        // resolves the same way the native process interprets it.
         const ttscPackageJson = require.resolve("ttsc/package.json", {
-            paths: [cwd],
+            paths: [node_path_1.default.resolve(cwd)],
         });
         const fromTtsc = (0, node_module_1.createRequire)(ttscPackageJson);
         return fromTtsc.resolve(`@ttsc/${process.platform}-${process.arch}/bin/${exe}`);

package/lib/resolveGraphBinary.js.map

@@ -1 +1 @@
-{"version":3,"file":"resolveGraphBinary.js","sourceRoot":"","sources":["../src/resolveGraphBinary.ts"],"names":[],"mappings":";;;;;;AAAA,6CAA4C;AAC5C,0DAA6B;AAE7B;;;;;;;;;;;;;;;;GAgBG;AACH,4BACE,GAAG,GAAsB,OAAO,CAAC,GAAG,EACpC,GAAG,GAAW,OAAO,CAAC,GAAG,EAAE;IAE3B,IAAI,GAAG,CAAC,iBAAiB,IAAI,mBAAI,CAAC,UAAU,CAAC,GAAG,CAAC,iBAAiB,CAAC,EAAE,CAAC;QACpE,OAAO,GAAG,CAAC,iBAAiB,CAAC;IAC/B,CAAC;IACD,MAAM,GAAG,GAAG,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,WAAW,CAAC;IACzE,IAAI,CAAC;QACH,MAAM,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,mBAAmB,EAAE;YAC3D,KAAK,EAAE,CAAC,GAAG,CAAC;SACb,CAAC,CAAC;QACH,MAAM,QAAQ,GAAG,IAAA,2BAAa,EAAC,eAAe,CAAC,CAAC;QAChD,OAAO,QAAQ,CAAC,OAAO,CACrB,SAAS,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,IAAI,QAAQ,GAAG,EAAE,CACvD,CAAC;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC"}
+{"version":3,"file":"resolveGraphBinary.js","sourceRoot":"","sources":["../src/resolveGraphBinary.ts"],"names":[],"mappings":";;;;;;AAAA,6CAA4C;AAC5C,0DAA6B;AAE7B;;;;;;;;;;;;;;;;;;GAkBG;AACH,4BACE,GAAG,GAAsB,OAAO,CAAC,GAAG,EACpC,GAAG,GAAW,OAAO,CAAC,GAAG,EAAE;IAE3B,IAAI,GAAG,CAAC,iBAAiB,IAAI,mBAAI,CAAC,UAAU,CAAC,GAAG,CAAC,iBAAiB,CAAC,EAAE,CAAC;QACpE,OAAO,GAAG,CAAC,iBAAiB,CAAC;IAC/B,CAAC;IACD,MAAM,GAAG,GAAG,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,WAAW,CAAC;IACzE,IAAI,CAAC;QACH,2EAA2E;QAC3E,0DAA0D;QAC1D,MAAM,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,mBAAmB,EAAE;YAC3D,KAAK,EAAE,CAAC,mBAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;SAC3B,CAAC,CAAC;QACH,MAAM,QAAQ,GAAG,IAAA,2BAAa,EAAC,eAAe,CAAC,CAAC;QAChD,OAAO,QAAQ,CAAC,OAAO,CACrB,SAAS,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,IAAI,QAAQ,GAAG,EAAE,CACvD,CAAC;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC"}

package/lib/server/createServer.d.ts

@@ -1,15 +1,22 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { TtscGraphSource } from "../TtscGraphApplication";
 /**
- * Build the MCP server for a graph. `typia.llm.application` reflects
- * {@link ITtscGraphApplication} into the tool schema and validator (no
- * hand-written schema), and `createMcpServer` from `@typia/mcp` handles the
- * list/call registration, argument validation, and structured output.
+ * Build the MCP server for a graph.
  *
- * We assemble the `ILlmController` (`{ protocol, name, application, execute }`)
- * directly rather than via `typia.llm.controller` so the server is named
- * "ttsc-graph" on our terms, not coupled to a reflected class name. Handshake
- * instructions come from the class JSDoc; the single tool is named from its
- * method, `inspect_typescript_graph`.
+ * `typia.llm.controller` reflects {@link ITtscGraphApplication} into the tool's
+ * input and output schemas and its argument validator, with no hand-written
+ * schema: the interface's JSDoc becomes the handshake instructions, the
+ * method's becomes the tool description, and every property's becomes the
+ * description of that field — including `audit`, whose JSDoc is how a caller
+ * learns what the server checked before it answered.
+ *
+ * The registration was hand-written here for a while, because a tool that
+ * declares an output schema must answer with `structuredContent` and the helper
+ * also serialized the same JSON into a text block: the payload crossed the wire
+ * twice, a client counted both copies against its tool-result cap, and a 30 KB
+ * tour arrived as 60 KB, blew the cap, and was spilled to a file the model then
+ * shelled out to read back. `@typia/mcp` 13.1.0 ships the structured result
+ * once (samchon/typia#2020), so the hand-written server had nothing left to fix
+ * and the library owns the registration again.
  */
 export declare function createServer(graph: TtscGraphSource, version: string): McpServer;