@ttsc/graph 0.19.2 → 0.19.3

package/lib/model/loadGraph.js

@@ -36,6 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DUMP_SCHEMA_VERSION = void 0;
 exports.loadGraph = loadGraph;
 const _assertGuard_1 = __importStar(require("typia/lib/internal/_assertGuard"));
 const node_child_process_1 = require("node:child_process");
@@ -54,8 +55,13 @@ const MAX_DUMP_BYTES = 1024 * 1024 * 1024;
  * `packages/ttsc/internal/graph/provenance.go`. The two are hand-synchronized,
  * and `dump_schema_version_matches_the_typescript_client_test.go` reads this
  * constant out of this file and fails if the pair drifts.
+ *
+ * Exported because the resident session reads the same dump body over the serve
+ * protocol and has to hold it to the same number: the envelope's version and the
+ * body's are independent, so a producer can speak this protocol and still send a
+ * body from another schema.
  */
-const DUMP_SCHEMA_VERSION = 1;
+exports.DUMP_SCHEMA_VERSION = 3;
 /**
  * Build the resident {@link TtscGraphMemory} for a project by running `ttscgraph
  * dump` once and loading its JSON. This is the one-shot path for direct callers
@@ -114,8 +120,8 @@ function parseDump(json) {
         return input => "object" === typeof input && null !== input && _io0(input);
     })()(value) ? value.provenance.schemaVersion
         : undefined;
-    if (version !== DUMP_SCHEMA_VERSION) {
-        throw new Error(`@ttsc/graph: ttscgraph dump is schema ${version === undefined ? "unknown" : `v${String(version)}`}, this client reads v${String(DUMP_SCHEMA_VERSION)}. ` +
+    if (version !== exports.DUMP_SCHEMA_VERSION) {
+        throw new Error(`@ttsc/graph: ttscgraph dump is schema ${version === undefined ? "unknown" : `v${String(version)}`}, this client reads v${String(exports.DUMP_SCHEMA_VERSION)}. ` +
             "Install a matching `ttsc` (the binary resolves from the target " +
             "project, or from TTSC_GRAPH_BINARY).");
     }
@@ -124,7 +130,7 @@ function parseDump(json) {
         const _iv0 = new Set(["class", "enum", "external_symbol", "file", "function", "interface", "method", "module", "namespace", "package", "parameter", "property", "type", "variable"]);
         const _ip1 = input => "string" === typeof input["name"];
         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"] && _io11(input["evidence"]);
+        const _ip2 = input => undefined === input["evidence"] || "object" === typeof input["evidence"] && null !== input["evidence"] && _io12(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) => "string" === typeof input["file"] || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
@@ -147,7 +153,7 @@ function parseDump(json) {
             path: _path + ".evidence",
             expected: "(ITtscGraphSpan | undefined)",
             value: input["evidence"]
-        }, _errorFactory)) && _ao11(input["evidence"], _path + ".evidence", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && _ao12(input["evidence"], _path + ".evidence", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".evidence",
             expected: "(ITtscGraphSpan | undefined)",
@@ -180,14 +186,14 @@ function parseDump(json) {
             path: _path + ".diagnostics",
             expected: "Array<ITtscGraphDump.IDiagnostic>",
             value: input.diagnostics
-        }, _errorFactory)) && input.diagnostics.every((elem, _index11) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && input.diagnostics.every((elem, _index13) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".diagnostics[" + _index11 + "]",
+            path: _path + ".diagnostics[" + _index13 + "]",
             expected: "ITtscGraphDump.IDiagnostic",
             value: elem
-        }, _errorFactory)) && _ao7(elem, _path + ".diagnostics[" + _index11 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && _ao7(elem, _path + ".diagnostics[" + _index13 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".diagnostics[" + _index11 + "]",
+            path: _path + ".diagnostics[" + _index13 + "]",
             expected: "ITtscGraphDump.IDiagnostic",
             value: elem
         }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -200,14 +206,14 @@ function parseDump(json) {
             path: _path + ".nodes",
             expected: "Array<ITtscGraphDump.INode>",
             value: input.nodes
-        }, _errorFactory)) && input.nodes.every((elem, _index12) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && input.nodes.every((elem, _index14) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".nodes[" + _index12 + "]",
+            path: _path + ".nodes[" + _index14 + "]",
             expected: "ITtscGraphDump.INode",
             value: elem
-        }, _errorFactory)) && _ao8(elem, _path + ".nodes[" + _index12 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && _ao8(elem, _path + ".nodes[" + _index14 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".nodes[" + _index12 + "]",
+            path: _path + ".nodes[" + _index14 + "]",
             expected: "ITtscGraphDump.INode",
             value: elem
         }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -220,14 +226,14 @@ function parseDump(json) {
             path: _path + ".edges",
             expected: "Array<ITtscGraphDump.IEdge>",
             value: input.edges
-        }, _errorFactory)) && input.edges.every((elem, _index13) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && input.edges.every((elem, _index15) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".edges[" + _index13 + "]",
+            path: _path + ".edges[" + _index15 + "]",
             expected: "ITtscGraphDump.IEdge",
             value: elem
-        }, _errorFactory)) && _ao12(elem, _path + ".edges[" + _index13 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && _ao13(elem, _path + ".edges[" + _index15 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".edges[" + _index13 + "]",
+            path: _path + ".edges[" + _index15 + "]",
             expected: "ITtscGraphDump.IEdge",
             value: elem
         }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -246,9 +252,9 @@ function parseDump(json) {
             path: _path + ".capabilities",
             expected: "Array<string>",
             value: input.capabilities
-        }, _errorFactory)) && input.capabilities.every((elem, _index14) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && input.capabilities.every((elem, _index16) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".capabilities[" + _index14 + "]",
+            path: _path + ".capabilities[" + _index16 + "]",
             expected: "string",
             value: elem
         }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -281,14 +287,14 @@ function parseDump(json) {
             path: _path + ".sources",
             expected: "Array<ITtscGraphDump.ISourceDigest>",
             value: input.sources
-        }, _errorFactory)) && input.sources.every((elem, _index15) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && input.sources.every((elem, _index17) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".sources[" + _index15 + "]",
+            path: _path + ".sources[" + _index17 + "]",
             expected: "ITtscGraphDump.ISourceDigest",
             value: elem
-        }, _errorFactory)) && _ao6(elem, _path + ".sources[" + _index15 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && _ao6(elem, _path + ".sources[" + _index17 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".sources[" + _index15 + "]",
+            path: _path + ".sources[" + _index17 + "]",
             expected: "ITtscGraphDump.ISourceDigest",
             value: elem
         }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -297,13 +303,34 @@ function parseDump(json) {
             expected: "Array<ITtscGraphDump.ISourceDigest>",
             value: input.sources
         }, _errorFactory));
-        const _ao10 = (input, _path, _exceptionable = true) => undefined === input.literal || "string" === typeof input.literal || "number" === typeof input.literal || "boolean" === typeof input.literal || _assertGuard_1._assertGuard(_exceptionable, {
+        const _ao10 = (input, _path, _exceptionable = true) => _ap1(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)) && _ao11(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 _ao11 = (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 _ao11 = (input, _path, _exceptionable = true) => (undefined === input.file || "string" === typeof input.file || _assertGuard_1._assertGuard(_exceptionable, {
+        const _ao12 = (input, _path, _exceptionable = true) => (undefined === input.file || "string" === typeof input.file || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".file",
             expected: "(string | undefined)",
@@ -329,7 +356,7 @@ function parseDump(json) {
             expected: "(number | undefined)",
             value: input.endCol
         }, _errorFactory));
-        const _ao12 = (input, _path, _exceptionable = true) => ("string" === typeof input.from || _assertGuard_1._assertGuard(_exceptionable, {
+        const _ao13 = (input, _path, _exceptionable = true) => ("string" === typeof input.from || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".from",
             expected: "string",
@@ -366,14 +393,14 @@ function parseDump(json) {
             path: _path + ".configs",
             expected: "Array<ITtscGraphDump.IFileDigest>",
             value: input.configs
-        }, _errorFactory)) && input.configs.every((elem, _index16) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && input.configs.every((elem, _index18) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".configs[" + _index16 + "]",
+            path: _path + ".configs[" + _index18 + "]",
             expected: "ITtscGraphDump.IFileDigest",
             value: elem
-        }, _errorFactory)) && _ao4(elem, _path + ".configs[" + _index16 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && _ao4(elem, _path + ".configs[" + _index18 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".configs[" + _index16 + "]",
+            path: _path + ".configs[" + _index18 + "]",
             expected: "ITtscGraphDump.IFileDigest",
             value: elem
         }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -386,14 +413,14 @@ function parseDump(json) {
             path: _path + ".roots",
             expected: "Array<ITtscGraphDump.IRootFile>",
             value: input.roots
-        }, _errorFactory)) && input.roots.every((elem, _index17) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && input.roots.every((elem, _index19) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".roots[" + _index17 + "]",
+            path: _path + ".roots[" + _index19 + "]",
             expected: "ITtscGraphDump.IRootFile",
             value: elem
-        }, _errorFactory)) && _ao5(elem, _path + ".roots[" + _index17 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && _ao5(elem, _path + ".roots[" + _index19 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".roots[" + _index17 + "]",
+            path: _path + ".roots[" + _index19 + "]",
             expected: "ITtscGraphDump.IRootFile",
             value: elem
         }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -491,9 +518,9 @@ function parseDump(json) {
             path: _path + ".modifiers",
             expected: "(Array<TtscGraphNodeModifier> | undefined)",
             value: input.modifiers
-        }, _errorFactory)) && input.modifiers.every((elem, _index18) => 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[" + _index18 + "]",
+            path: _path + ".modifiers[" + _index20 + "]",
             expected: _ae1,
             value: elem
         }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -501,19 +528,54 @@ function parseDump(json) {
             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)) && _ao9(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, _index19) => ("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[" + _index19 + "]",
+            path: _path + ".decorators[" + _index23 + "]",
             expected: "ITtscGraphDecorator",
             value: elem
-        }, _errorFactory)) && _ao9(elem, _path + ".decorators[" + _index19 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && _ao10(elem, _path + ".decorators[" + _index23 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".decorators[" + _index19 + "]",
+            path: _path + ".decorators[" + _index23 + "]",
             expected: "ITtscGraphDecorator",
             value: elem
         }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -526,46 +588,32 @@ function parseDump(json) {
             path: _path + ".implementation",
             expected: "(ITtscGraphSpan | undefined)",
             value: input.implementation
-        }, _errorFactory)) && _ao11(input.implementation, _path + ".implementation", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && _ao12(input.implementation, _path + ".implementation", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".implementation",
             expected: "(ITtscGraphSpan | undefined)",
             value: input.implementation
         }, _errorFactory));
-        const _ao9 = (input, _path, _exceptionable = true) => _ap1(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, _index20) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || _assertGuard_1._assertGuard(_exceptionable, {
+        const _ao9 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && (undefined === input.value || "string" === typeof input.value || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".arguments[" + _index20 + "]",
-            expected: "ITtscGraphDecorator.IArgument",
-            value: elem
-        }, _errorFactory)) && _ao10(elem, _path + ".arguments[" + _index20 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
-            method: "typia.assert",
-            path: _path + ".arguments[" + _index20 + "]",
-            expected: "ITtscGraphDecorator.IArgument",
-            value: elem
-        }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
-            method: "typia.assert",
-            path: _path + ".arguments",
-            expected: "Array<ITtscGraphDecorator.IArgument>",
-            value: input.arguments
+            path: _path + ".value",
+            expected: "(string | undefined)",
+            value: input.value
         }, _errorFactory));
-        const _io0 = input => "string" === typeof input.project && "string" === typeof input.tsconfig && ("object" === typeof input.provenance && null !== input.provenance && _io1(input.provenance)) && (Array.isArray(input.diagnostics) && input.diagnostics.every(elem => "object" === typeof elem && null !== elem && _io7(elem))) && (Array.isArray(input.nodes) && input.nodes.every(elem => "object" === typeof elem && null !== elem && _io8(elem))) && (Array.isArray(input.edges) && input.edges.every(elem => "object" === typeof elem && null !== elem && _io12(elem)));
+        const _io0 = input => "string" === typeof input.project && "string" === typeof input.tsconfig && ("object" === typeof input.provenance && null !== input.provenance && _io1(input.provenance)) && (Array.isArray(input.diagnostics) && input.diagnostics.every(elem => "object" === typeof elem && null !== elem && _io7(elem))) && (Array.isArray(input.nodes) && input.nodes.every(elem => "object" === typeof elem && null !== elem && _io8(elem))) && (Array.isArray(input.edges) && input.edges.every(elem => "object" === typeof elem && null !== elem && _io13(elem)));
         const _io1 = input => "number" === typeof input.schemaVersion && (Array.isArray(input.capabilities) && input.capabilities.every(elem => "string" === typeof elem)) && ("object" === typeof input.producer && null !== input.producer && _io2(input.producer)) && ("object" === typeof input.universe && null !== input.universe && _io3(input.universe)) && (Array.isArray(input.sources) && input.sources.every(elem => "object" === typeof elem && null !== elem && _io6(elem)));
-        const _io10 = input => undefined === input.literal || "string" === typeof input.literal || "number" === typeof input.literal || "boolean" === typeof input.literal;
-        const _io11 = 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 _io12 = input => "string" === typeof input.from && "string" === typeof input.to && true === _iv2.has(input.kind) && _ip2(input);
+        const _io10 = input => _ip1(input) && (Array.isArray(input.arguments) && input.arguments.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _io11(elem)));
+        const _io11 = input => undefined === input.literal || "string" === typeof input.literal || "number" === typeof input.literal || "boolean" === typeof input.literal;
+        const _io12 = 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 _io13 = input => "string" === typeof input.from && "string" === typeof input.to && true === _iv2.has(input.kind) && _ip2(input);
         const _io2 = input => "string" === typeof input.tool && "string" === typeof input.version && "string" === typeof input.typescript;
         const _io3 = input => Array.isArray(input.configs) && input.configs.every(elem => "object" === typeof elem && null !== elem && _io4(elem)) && (Array.isArray(input.roots) && input.roots.every(elem => "object" === typeof elem && null !== elem && _io5(elem)));
         const _io4 = input => _ip0(input) && "string" === typeof input.digest;
         const _io5 = input => "string" === typeof input.config && _ip0(input);
         const _io6 = input => _ip0(input) && "string" === typeof input.checkerDigest && "string" === typeof input.diskDigest;
         const _io7 = input => _ip0(input) && "number" === typeof input.line && "number" === typeof input.column && "number" === typeof input.code && ("error" === input.category || "warning" === input.category) && "string" === typeof input.message;
-        const _io8 = input => "string" === typeof input.id && true === _iv0.has(input.kind) && _ip1(input) && (undefined === input.qualifiedName || "string" === typeof input.qualifiedName) && _ip0(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.decorators || Array.isArray(input.decorators) && input.decorators.every(elem => "object" === typeof elem && null !== elem && _io9(elem))) && _ip2(input) && (undefined === input.implementation || "object" === typeof input.implementation && null !== input.implementation && _io11(input.implementation));
-        const _io9 = input => _ip1(input) && (Array.isArray(input.arguments) && input.arguments.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _io10(elem)));
+        const _io8 = input => "string" === typeof input.id && true === _iv0.has(input.kind) && _ip1(input) && (undefined === input.qualifiedName || "string" === typeof input.qualifiedName) && _ip0(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 && _io9(elem))) && (undefined === input.decorators || Array.isArray(input.decorators) && input.decorators.every(elem => "object" === typeof elem && null !== elem && _io10(elem))) && _ip2(input) && (undefined === input.implementation || "object" === typeof input.implementation && null !== input.implementation && _io12(input.implementation));
+        const _io9 = input => _ip1(input) && (undefined === input.value || "string" === typeof input.value);
         const __is = input => "object" === typeof input && null !== input && _io0(input);
         let _errorFactory;
         return (input, errorFactory) => {

package/lib/model/loadGraph.js.map

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

package/lib/resolveGraphBinary.d.ts

@@ -2,9 +2,15 @@
  * Resolve the per-platform `ttscgraph` binary, or `null` when it cannot be
  * located.
  *
- * `ttsc` is a peer the user installs alongside `@ttsc/graph` (not a dependency
- * of this launcher), so resolution starts from the user's project, not from
- * this package's own tree.
+ * `ttsc` is a peer dependency pinned to this package's own version, installed
+ * alongside `@ttsc/graph` in the user's project rather than nested under this
+ * launcher, so resolution starts from the user's project, not from this
+ * package's own tree.
+ *
+ * The pin is what keeps the two halves of the graph in step. `literals` and the
+ * rest of the node facts are resolved by the Go builder and ride the dump, so a
+ * newer `@ttsc/graph` reading an older `ttscgraph` would find those fields
+ * simply absent and answer from a graph missing facts it believes are there.
  *
  * Resolution order:
  *

package/lib/resolveGraphBinary.js

@@ -10,9 +10,15 @@ const node_path_1 = __importDefault(require("node:path"));
  * Resolve the per-platform `ttscgraph` binary, or `null` when it cannot be
  * located.
  *
- * `ttsc` is a peer the user installs alongside `@ttsc/graph` (not a dependency
- * of this launcher), so resolution starts from the user's project, not from
- * this package's own tree.
+ * `ttsc` is a peer dependency pinned to this package's own version, installed
+ * alongside `@ttsc/graph` in the user's project rather than nested under this
+ * launcher, so resolution starts from the user's project, not from this
+ * package's own tree.
+ *
+ * The pin is what keeps the two halves of the graph in step. `literals` and the
+ * rest of the node facts are resolved by the Go builder and ride the dump, so a
+ * newer `@ttsc/graph` reading an older `ttscgraph` would find those fields
+ * simply absent and answer from a graph missing facts it believes are there.
  *
  * Resolution order:
  *

package/lib/resolveGraphBinary.js.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"resolveGraphBinary.js","sourceRoot":"","sources":["../src/resolveGraphBinary.ts"],"names":[],"mappings":";;;;;;AAAA,6CAA4C;AAC5C,0DAA6B;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;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.js

@@ -78,7 +78,7 @@ function createServer(graph, version) {
                         properties: {
                             audit: {
                                 type: "string",
-                                description: "What the server audited this result against before returning it, in its\nown words: every node, span, edge, signature, member, and step in it\nresolves to the type-checked program for the snapshot the call synced to,\nso opening a file it cites only returns a fact already in it.\n\nThe audit is operation-aware. For the exact operations (`trace`,\n`details`, `overview`) it reports the result as the structure the graph\nholds for the handles named, bounded only where `truncated` says. For the\nranked operations (`lookup`, `entrypoints`, `tour`) it adds that the\nselection is heuristic \u2014 matched, scored, ranked, and limited against the\nquestion \u2014 so the facts are verified but the shortlist's coverage is the\ncaller's to judge."
+                                description: "What the server audited this result against before returning it, in its\nown words: every node, span, edge, signature, member, and step in it\nresolves to the type-checked program for the snapshot the call synced to,\nso opening a file it cites only returns a fact already in it.\n\nThe audit is operation-aware. For the walks from a named handle (`trace`,\n`overview`) it reports the result as the structure the graph holds,\nbounded where `truncated` says. For `details` it reports the two halves of\na resolved symbol: its own shape returned whole, its fan-out returned as a\nslice with `trace` for the rest. For the ranked operations (`lookup`,\n`entrypoints`, `tour`) it adds that the selection is heuristic \u2014 matched,\nscored, ranked, and limited against the question \u2014 so the facts are\nverified but the shortlist's coverage is the caller's to judge."
                             },
                             next: {
                                 $ref: "#/$defs/ITtscGraphNext",
@@ -372,7 +372,7 @@ function createServer(graph, version) {
                                         items: {
                                             type: "string"
                                         },
-                                        description: "String literal values from the signature."
+                                        description: "The complete value set a type alias or enum admits, in TypeScript source\nform (`\"a\"`, `1`, `true`, `null`) \u2014 the checker's resolved union members,\nnot the quoted tokens that happened to fit in `signature`.\n\nAbsent when the type has no enumerable value set. A `signature` is capped\nat the declaration head, so for a union or enum written across several\nlines this is the field that carries the members."
                                     },
                                     members: {
                                         type: "array",
@@ -1679,15 +1679,15 @@ function createServer(graph, version) {
                                     },
                                     neighborLimit: {
                                         type: "number",
-                                        description: "Maximum dependencies and dependents per side when `neighbors:true`. Above\na few is usually overfetch; call `trace` for flow instead."
+                                        description: "Dependencies and dependents per side when `neighbors:true`. A small\norientation slice by default; what uses a symbol grows with its\npopularity, so `trace` answers the whole \"who uses this\"."
                                     },
                                     memberLimit: {
                                         type: "number",
-                                        description: "Maximum owned members for a container or object literal."
+                                        description: "Owned members for a container or object literal. The complete outline by\ndefault \u2014 a class's members and an enum's are the symbol itself, so they\nare not sampled. Pass a number to cap."
                                     },
                                     dependencyLimit: {
                                         type: "number",
-                                        description: "Maximum direct execution and type references per group."
+                                        description: "Direct execution and type references per group. A small orientation slice\nby default; `trace` follows the whole fan-out."
                                     },
                                     includeExternal: {
                                         type: "boolean",

package/lib/server/resultAudit.d.ts

@@ -47,14 +47,18 @@
  * payload, and told it to stop where the shortlist's coverage was exactly what
  * needed judging.
  *
- * So there are two audits. {@link RESULT_AUDIT} covers the operations that walk
- * from an explicit handle or structure (`trace`, `details`, `overview`): the
- * result is what the graph holds for what you named, bounded only where
- * `truncated` says. {@link RESULT_AUDIT_SELECTION} covers the ranked shortlists
- * (`lookup`, `entrypoints`, `tour`): it keeps the same fact-verification and
- * adds that the _selection_ is heuristic, so whether the shortlist covers the
- * question is the caller's to judge — and a follow-up request or a read of a
- * cited span is a sound next step, not a failure to trust the result.
+ * So the audits split by what the reader must judge. {@link RESULT_AUDIT}
+ * covers the walks from an explicit handle or structure (`trace`, `overview`):
+ * the result is what the graph holds for what you named, bounded where
+ * `truncated` says. {@link RESULT_AUDIT_DETAILS} covers `details`, whose result
+ * is not one bounded whole but two halves — a symbol's own shape, returned
+ * complete, and its fan-out, returned as a slice with `trace` for the rest — so
+ * it names which half to trust outright and which to follow. {@link
+ * RESULT_AUDIT_SELECTION} covers the ranked shortlists (`lookup`, `entrypoints`,
+ * `tour`): it keeps the same fact-verification and adds that the _selection_ is
+ * heuristic, so whether the shortlist covers the question is the caller's to
+ * judge — and a follow-up request or a read of a cited span is a sound next
+ * step, not a failure to trust the result.
  *
  * Keep both narrow, and keep the stop-or-continue decision with the result's
  * `next`, so neither contradicts a partial result that legitimately asks for
@@ -70,5 +74,22 @@ export declare const RESULT_AUDIT: string;
  * many — is heuristic, so coverage is the caller's to judge.
  */
 export declare const RESULT_AUDIT_SELECTION: string;
+/**
+ * The audit for `details`, whose contract is not the other exact operations'.
+ *
+ * `trace` walks and marks where the walk was cut with `truncated`; `details`
+ * does not walk. It resolves a named handle, and its result splits in two. What
+ * a symbol *is* — its members, its values, its signature — is bounded by the
+ * declaration and returned whole, so the old "trust it, do not open the file"
+ * is finally true of it rather than contradicted by a capped member list. What
+ * a symbol *reaches or is reached by* — its calls, its type references, its
+ * implementers, its dependents — is bounded by how widely it is used, not by
+ * the symbol, so returning it whole is a `trace`/impact answer of a thousand
+ * refs in a "what is this" call. That half is a short orientation slice, and
+ * the audit has to say which half is which so the reader trusts the complete
+ * one and reaches for `trace` on the other, instead of reading the file for a
+ * member list that is already here.
+ */
+export declare const RESULT_AUDIT_DETAILS: string;
 /** The escape branch carries no graph facts, so it claims none. */
 export declare const RESULT_AUDIT_ESCAPE: string;

package/lib/server/resultAudit.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RESULT_AUDIT_ESCAPE = exports.RESULT_AUDIT_SELECTION = exports.RESULT_AUDIT = void 0;
+exports.RESULT_AUDIT_ESCAPE = exports.RESULT_AUDIT_DETAILS = exports.RESULT_AUDIT_SELECTION = exports.RESULT_AUDIT = void 0;
 /**
  * The audit stamped as the first property of every
  * {@link ITtscGraphApplication.IOutput}. Because it serializes before `result`,
@@ -50,14 +50,18 @@ exports.RESULT_AUDIT_ESCAPE = exports.RESULT_AUDIT_SELECTION = exports.RESULT_AU
  * payload, and told it to stop where the shortlist's coverage was exactly what
  * needed judging.
  *
- * So there are two audits. {@link RESULT_AUDIT} covers the operations that walk
- * from an explicit handle or structure (`trace`, `details`, `overview`): the
- * result is what the graph holds for what you named, bounded only where
- * `truncated` says. {@link RESULT_AUDIT_SELECTION} covers the ranked shortlists
- * (`lookup`, `entrypoints`, `tour`): it keeps the same fact-verification and
- * adds that the _selection_ is heuristic, so whether the shortlist covers the
- * question is the caller's to judge — and a follow-up request or a read of a
- * cited span is a sound next step, not a failure to trust the result.
+ * So the audits split by what the reader must judge. {@link RESULT_AUDIT}
+ * covers the walks from an explicit handle or structure (`trace`, `overview`):
+ * the result is what the graph holds for what you named, bounded where
+ * `truncated` says. {@link RESULT_AUDIT_DETAILS} covers `details`, whose result
+ * is not one bounded whole but two halves — a symbol's own shape, returned
+ * complete, and its fan-out, returned as a slice with `trace` for the rest — so
+ * it names which half to trust outright and which to follow. {@link
+ * RESULT_AUDIT_SELECTION} covers the ranked shortlists (`lookup`, `entrypoints`,
+ * `tour`): it keeps the same fact-verification and adds that the _selection_ is
+ * heuristic, so whether the shortlist covers the question is the caller's to
+ * judge — and a follow-up request or a read of a cited span is a sound next
+ * step, not a failure to trust the result.
  *
  * Keep both narrow, and keep the stop-or-continue decision with the result's
  * `next`, so neither contradicts a partial result that legitimately asks for
@@ -105,6 +109,40 @@ span is a sound next step, not a failure to trust the result.
 
 Follow \`next\` for where that leaves the question.
 `.trim();
+/**
+ * The audit for `details`, whose contract is not the other exact operations'.
+ *
+ * `trace` walks and marks where the walk was cut with `truncated`; `details`
+ * does not walk. It resolves a named handle, and its result splits in two. What
+ * a symbol *is* — its members, its values, its signature — is bounded by the
+ * declaration and returned whole, so the old "trust it, do not open the file"
+ * is finally true of it rather than contradicted by a capped member list. What
+ * a symbol *reaches or is reached by* — its calls, its type references, its
+ * implementers, its dependents — is bounded by how widely it is used, not by
+ * the symbol, so returning it whole is a `trace`/impact answer of a thousand
+ * refs in a "what is this" call. That half is a short orientation slice, and
+ * the audit has to say which half is which so the reader trusts the complete
+ * one and reaches for `trace` on the other, instead of reading the file for a
+ * member list that is already here.
+ */
+exports.RESULT_AUDIT_DETAILS = `
+AUDITED BEFORE RETURNING. READ FIRST.
+
+The server assembled this \`result\`, then checked it: every fact in it — each name, span,
+edge, signature, member, and value — was taken back to the type-checked program for the
+snapshot this call synced to, and resolved there, so for this snapshot a fact here cannot be
+wrong.
+
+This is the structure the graph holds for the handles you named. What a symbol is — its
+members, its values, its signature — is complete: trust it and do not open the file to read
+what is already here. What a symbol reaches or is reached by — its calls, its type
+references, its implementers, and under \`neighbors\` its dependents — is a short orientation
+slice, not the whole set, because that grows with how widely a symbol is used; \`trace\`
+follows it in full.
+
+Follow \`next\`: answer from this result, and re-call the graph only when it says inspect, or
+after you edit the source.
+`.trim();
 /** The escape branch carries no graph facts, so it claims none. */
 exports.RESULT_AUDIT_ESCAPE = "This escape carries no graph facts to audit.";
 //# sourceMappingURL=resultAudit.js.map

package/lib/server/resultAudit.js.map

@@ -1 +1 @@
-{"version":3,"file":"resultAudit.js","sourceRoot":"","sources":["../../src/server/resultAudit.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACU,QAAA,YAAY,GAAW;;;;;;;;;;;;;;;CAenC,CAAC,IAAI,EAAE,CAAC;AAET;;;;;GAKG;AACU,QAAA,sBAAsB,GAAW;;;;;;;;;;;;;;;;;CAiB7C,CAAC,IAAI,EAAE,CAAC;AAET,mEAAmE;AACtD,QAAA,mBAAmB,GAC9B,8CAA8C,CAAC"}
+{"version":3,"file":"resultAudit.js","sourceRoot":"","sources":["../../src/server/resultAudit.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACU,QAAA,YAAY,GAAW;;;;;;;;;;;;;;;CAenC,CAAC,IAAI,EAAE,CAAC;AAET;;;;;GAKG;AACU,QAAA,sBAAsB,GAAW;;;;;;;;;;;;;;;;;CAiB7C,CAAC,IAAI,EAAE,CAAC;AAET;;;;;;;;;;;;;;;GAeG;AACU,QAAA,oBAAoB,GAAW;;;;;;;;;;;;;;;;;CAiB3C,CAAC,IAAI,EAAE,CAAC;AAET,mEAAmE;AACtD,QAAA,mBAAmB,GAC9B,8CAA8C,CAAC"}