@ttsc/graph 0.19.2 → 0.20.0

package/lib/reduce.d.ts

@@ -4,6 +4,7 @@ export interface RawNode {
     kind: string;
     file: string;
     external?: boolean;
+    ignored?: boolean;
 }
 export interface RawEdge {
     from: string;
@@ -35,12 +36,14 @@ export interface ViewerPayload {
         nodes: number;
         links: number;
         droppedExternal: number;
+        droppedIgnored: number;
         droppedByCap: number;
     };
     nodes: ViewerNode[];
     links: ViewerLink[];
 }
-export declare function reduce(raw: RawDump, { maxNodes, keepExternal }?: {
+export declare function reduce(raw: RawDump, { maxNodes, keepExternal, keepIgnored }?: {
     maxNodes?: number;
     keepExternal?: boolean;
+    keepIgnored?: boolean;
 }): ViewerPayload;

package/lib/reduce.js

@@ -8,18 +8,34 @@ exports.reduce = reduce;
 function posix(p) {
     return p.replace(/\\/g, "/");
 }
-/** An absolute path (POSIX or Windows drive); relative dumps skip rerooting. */
+/** Absolute POSIX, Windows drive, or UNC path; relative dumps skip rerooting. */
 function isAbsolute(p) {
     return /^(?:[A-Za-z]:)?\//.test(posix(p));
 }
-function commonRoot(files) {
-    if (files.length === 0)
+function isWindowsPath(p) {
+    const normalized = posix(p);
+    return /^[A-Za-z]:(?:\/|$)/.test(normalized) || normalized.startsWith("//");
+}
+function directoryOf(file) {
+    const normalized = posix(file).replace(/\/+$/, "");
+    const slash = normalized.lastIndexOf("/");
+    if (slash < 0)
+        return "";
+    return slash === 0 ? "/" : normalized.slice(0, slash);
+}
+function commonRoot(directories) {
+    if (directories.length === 0)
         return "";
-    let parts = posix(files[0]).split("/");
-    for (const file of files.slice(1)) {
-        const other = posix(file).split("/");
+    let parts = posix(directories[0]).split("/");
+    const caseInsensitive = directories.every(isWindowsPath);
+    for (const directory of directories.slice(1)) {
+        const other = posix(directory).split("/");
         let i = 0;
-        while (i < parts.length && i < other.length && parts[i] === other[i])
+        while (i < parts.length &&
+            i < other.length &&
+            (caseInsensitive
+                ? parts[i].toLowerCase() === other[i].toLowerCase()
+                : parts[i] === other[i]))
             i++;
         parts = parts.slice(0, i);
         if (parts.length === 0)
@@ -27,26 +43,72 @@ function commonRoot(files) {
     }
     return parts.join("/");
 }
-// An empty root means the dump's paths are already project-relative (the
-// current `ttscgraph dump` contract); they pass through structure-intact.
+// A null root means the dump's paths are already project-relative (the current
+// `ttscgraph dump` contract); they pass through structure-intact.
 function relativize(abs, root) {
     const a = posix(abs);
-    const r = posix(root).replace(/\/+$/, "");
-    if (!r)
+    if (root === null)
         return a;
-    if (a === r || a.startsWith(r + "/"))
+    const normalizedRoot = posix(root);
+    const r = normalizedRoot === "/" ? "/" : normalizedRoot.replace(/\/+$/, "");
+    const caseInsensitive = isWindowsPath(a) && isWindowsPath(r);
+    const comparedPath = caseInsensitive ? a.toLowerCase() : a;
+    const comparedRoot = caseInsensitive ? r.toLowerCase() : r;
+    if (comparedRoot &&
+        (comparedRoot === "/" ||
+            comparedPath === comparedRoot ||
+            comparedPath.startsWith(comparedRoot + "/")))
         return a.slice(r.length).replace(/^\/+/, "");
     const nm = a.lastIndexOf("node_modules/");
+    // A package tail is a deliberate normalization: the same dependency reached
+    // through two roots is one thing to look at.
     if (nm >= 0)
         return a.slice(nm);
-    const slash = a.lastIndexOf("/");
-    return slash >= 0 ? a.slice(slash + 1) : a;
+    // Anything else keeps its whole path. Collapsing to the basename made the
+    // projection non-injective, and node ids are rewritten with it, so two
+    // declarations in two files could become one viewer node and an edge could
+    // resolve back to the wrong end. A longer label is a cosmetic cost; a
+    // collided id is a wrong picture.
+    return a;
 }
 function rewriteId(id, root) {
-    const hash = id.indexOf("#");
+    const hash = graphNodeIdHash(id);
     if (hash < 0)
         return id;
-    return relativize(id.slice(0, hash), root) + id.slice(hash);
+    return (escapeGraphNodeIdPart(relativize(unescapeGraphNodeIdPart(id.slice(0, hash)), root)) + id.slice(hash));
+}
+function escapeGraphNodeIdPart(value) {
+    return value.replaceAll("\\", "\\\\").replaceAll("#", "\\#");
+}
+function unescapeGraphNodeIdPart(value) {
+    let result = "";
+    for (let index = 0; index < value.length; index++) {
+        const next = value[index + 1];
+        if (value[index] === "\\" && next !== undefined) {
+            if (next === "#" || (next === "\\" && !legacyUNCStart(value, index))) {
+                result += next;
+                index++;
+                continue;
+            }
+        }
+        result += value[index];
+    }
+    return result;
+}
+function legacyUNCStart(value, index) {
+    return (index === 0 && value.length > 2 && value[2] !== "\\" && value[2] !== "#");
+}
+function graphNodeIdHash(id) {
+    for (let index = 0; index < id.length; index++) {
+        if (id[index] !== "#")
+            continue;
+        let slashes = 0;
+        for (let slash = index - 1; slash >= 0 && id[slash] === "\\"; slash--)
+            slashes++;
+        if (slashes % 2 === 0)
+            return index;
+    }
+    return -1;
 }
 function degreeOf(nodes, edges) {
     const degree = new Map(nodes.map((n) => [n.id, 0]));
@@ -60,9 +122,9 @@ function degreeOf(nodes, edges) {
 }
 /**
  * Collapse the fine-grained wire kinds `ttscgraph dump` emits (calls,
- * instantiates, renders, accesses, type_ref, extends, implements) into the
- * three display families the viewer colors and its legend name. An unknown kind
- * passes through and renders with the fallback color.
+ * instantiates, renders, accesses, type_ref, extends, implements, overrides)
+ * into the three display families the viewer colors and its legend name. An
+ * unknown kind passes through and renders with the fallback color.
  */
 const DISPLAY_KIND = {
     calls: "value-call",
@@ -72,28 +134,41 @@ const DISPLAY_KIND = {
     type_ref: "type-ref",
     extends: "heritage",
     implements: "heritage",
+    overrides: "heritage",
 };
 function displayKind(kind) {
     return DISPLAY_KIND[kind] ?? kind;
 }
-function reduce(raw, { maxNodes = 1200, keepExternal = false, } = {}) {
-    const keptByExternal = raw.nodes.filter((n) => keepExternal || !n.external);
+function reduce(raw, { maxNodes = 1200, keepExternal = false, keepIgnored = false, } = {}) {
+    // Drop external boundary leaves and git-ignored generated code (a Prisma
+    // client and the like, tagged `ignored` by the dump) so the authored graph is
+    // not buried under codegen. The cap is by degree, and generated clients are
+    // large and densely connected, so leaving them in does not merely add noise:
+    // they outrank authored code for the surviving slots.
+    const keep = (n) => (keepExternal || !n.external) && (keepIgnored || !n.ignored);
+    const keptByBoundary = raw.nodes.filter(keep);
     // Reroot only absolute paths (the legacy dump contract); a current dump's
     // paths are already project-relative and keep their structure as-is.
-    const projectFiles = raw.nodes.filter((n) => !n.external).map((n) => n.file);
+    const projectFiles = raw.nodes
+        .filter((n) => !n.external && !n.ignored)
+        .map((n) => n.file);
     const root = projectFiles.length > 0 && isAbsolute(projectFiles[0])
-        ? commonRoot(projectFiles)
-        : "";
-    const liveIds = new Set(keptByExternal.map((n) => n.id));
+        ? // A dump may mix path forms from one valid project: in-project sources
+            // are relative, package sources carry a node_modules tail, and other
+            // out-of-project sources stay absolute. Mixing those into one common
+            // root yields the empty string, so only absolute directories vote.
+            commonRoot(projectFiles.filter(isAbsolute).map(directoryOf))
+        : null;
+    const liveIds = new Set(keptByBoundary.map((n) => n.id));
     const liveEdges = raw.edges.filter((e) => liveIds.has(e.from) && liveIds.has(e.to));
-    const degree = degreeOf(keptByExternal, liveEdges);
-    let kept = keptByExternal;
+    const degree = degreeOf(keptByBoundary, liveEdges);
+    let kept = keptByBoundary;
     let droppedByCap = 0;
     if (kept.length > maxNodes) {
         kept = [...kept]
             .sort((a, b) => (degree.get(b.id) ?? 0) - (degree.get(a.id) ?? 0))
             .slice(0, maxNodes);
-        droppedByCap = keptByExternal.length - kept.length;
+        droppedByCap = keptByBoundary.length - kept.length;
     }
     const keptIds = new Set(kept.map((n) => n.id));
     const edges = liveEdges.filter((e) => keptIds.has(e.from) && keptIds.has(e.to));
@@ -122,7 +197,15 @@ function reduce(raw, { maxNodes = 1200, keepExternal = false, } = {}) {
             rawEdges: raw.edges.length,
             nodes: nodes.length,
             links: links.length,
-            droppedExternal: raw.nodes.length - keptByExternal.length,
+            // Each counter reports what its own filter dropped, and reports zero when
+            // that filter was turned off. The two are disjoint: an external node is
+            // counted as external whether or not it is also ignored.
+            droppedExternal: keepExternal
+                ? 0
+                : raw.nodes.filter((n) => n.external).length,
+            droppedIgnored: keepIgnored
+                ? 0
+                : raw.nodes.filter((n) => n.ignored && !n.external).length,
             droppedByCap,
         },
         nodes,

package/lib/reduce.js.map

@@ -1 +1 @@
-{"version":3,"file":"reduce.js","sourceRoot":"","sources":["../src/reduce.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"reduce.js","sourceRoot":"","sources":["../src/reduce.ts"],"names":[],"mappings":";AAAA,8EAA8E;AAC9E,0EAA0E;AAC1E,+EAA+E;AAC/E,mEAAmE;;;AAoDnE,SAAS,KAAK,CAAC,CAAS;IACtB,OAAO,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;AAC/B,CAAC;AAED,iFAAiF;AACjF,SAAS,UAAU,CAAC,CAAS;IAC3B,OAAO,mBAAmB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAC5C,CAAC;AAED,SAAS,aAAa,CAAC,CAAS;IAC9B,MAAM,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAC5B,OAAO,oBAAoB,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;AAC9E,CAAC;AAED,SAAS,WAAW,CAAC,IAAY;IAC/B,MAAM,UAAU,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IACnD,MAAM,KAAK,GAAG,UAAU,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IAC1C,IAAI,KAAK,GAAG,CAAC;QAAE,OAAO,EAAE,CAAC;IACzB,OAAO,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;AACxD,CAAC;AAED,SAAS,UAAU,CAAC,WAAqB;IACvC,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IACxC,IAAI,KAAK,GAAG,KAAK,CAAC,WAAW,CAAC,CAAC,CAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC9C,MAAM,eAAe,GAAG,WAAW,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;IACzD,KAAK,MAAM,SAAS,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;QAC7C,MAAM,KAAK,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC1C,IAAI,CAAC,GAAG,CAAC,CAAC;QACV,OACE,CAAC,GAAG,KAAK,CAAC,MAAM;YAChB,CAAC,GAAG,KAAK,CAAC,MAAM;YAChB,CAAC,eAAe;gBACd,CAAC,CAAC,KAAK,CAAC,CAAC,CAAE,CAAC,WAAW,EAAE,KAAK,KAAK,CAAC,CAAC,CAAE,CAAC,WAAW,EAAE;gBACrD,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;YAE1B,CAAC,EAAE,CAAC;QACN,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAC1B,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;YAAE,MAAM;IAChC,CAAC;IACD,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACzB,CAAC;AAED,+EAA+E;AAC/E,kEAAkE;AAClE,SAAS,UAAU,CAAC,GAAW,EAAE,IAAmB;IAClD,MAAM,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;IACrB,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO,CAAC,CAAC;IAC5B,MAAM,cAAc,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;IACnC,MAAM,CAAC,GAAG,cAAc,KAAK,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IAC5E,MAAM,eAAe,GAAG,aAAa,CAAC,CAAC,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC,CAAC;IAC7D,MAAM,YAAY,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3D,MAAM,YAAY,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3D,IACE,YAAY;QACZ,CAAC,YAAY,KAAK,GAAG;YACnB,YAAY,KAAK,YAAY;YAC7B,YAAY,CAAC,UAAU,CAAC,YAAY,GAAG,GAAG,CAAC,CAAC;QAE9C,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IAC/C,MAAM,EAAE,GAAG,CAAC,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC;IAC1C,4EAA4E;IAC5E,6CAA6C;IAC7C,IAAI,EAAE,IAAI,CAAC;QAAE,OAAO,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAChC,0EAA0E;IAC1E,uEAAuE;IACvE,2EAA2E;IAC3E,sEAAsE;IACtE,kCAAkC;IAClC,OAAO,CAAC,CAAC;AACX,CAAC;AAED,SAAS,SAAS,CAAC,EAAU,EAAE,IAAmB;IAChD,MAAM,IAAI,GAAG,eAAe,CAAC,EAAE,CAAC,CAAC;IACjC,IAAI,IAAI,GAAG,CAAC;QAAE,OAAO,EAAE,CAAC;IACxB,OAAO,CACL,qBAAqB,CACnB,UAAU,CAAC,uBAAuB,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAC7D,GAAG,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CACnB,CAAC;AACJ,CAAC;AAED,SAAS,qBAAqB,CAAC,KAAa;IAC1C,OAAO,KAAK,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;AAC/D,CAAC;AAED,SAAS,uBAAuB,CAAC,KAAa;IAC5C,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QAClD,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;QAC9B,IAAI,KAAK,CAAC,KAAK,CAAC,KAAK,IAAI,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YAChD,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC;gBACrE,MAAM,IAAI,IAAI,CAAC;gBACf,KAAK,EAAE,CAAC;gBACR,SAAS;YACX,CAAC;QACH,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC;IACzB,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,cAAc,CAAC,KAAa,EAAE,KAAa;IAClD,OAAO,CACL,KAAK,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,GAAG,CACzE,CAAC;AACJ,CAAC;AAED,SAAS,eAAe,CAAC,EAAU;IACjC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,EAAE,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QAC/C,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,GAAG;YAAE,SAAS;QAChC,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,KAAK,IAAI,KAAK,GAAG,KAAK,GAAG,CAAC,EAAE,KAAK,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,IAAI,EAAE,KAAK,EAAE;YACnE,OAAO,EAAE,CAAC;QACZ,IAAI,OAAO,GAAG,CAAC,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;IACtC,CAAC;IACD,OAAO,CAAC,CAAC,CAAC;AACZ,CAAC;AAED,SAAS,QAAQ,CACf,KAAuB,EACvB,KAAqC;IAErC,MAAM,MAAM,GAAG,IAAI,GAAG,CAAiB,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IACpE,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;QACtB,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;YAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAE,GAAG,CAAC,CAAC,CAAC;QACpE,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;YAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAE,GAAG,CAAC,CAAC,CAAC;IAChE,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;GAKG;AACH,MAAM,YAAY,GAA2B;IAC3C,KAAK,EAAE,YAAY;IACnB,YAAY,EAAE,YAAY;IAC1B,OAAO,EAAE,YAAY;IACrB,QAAQ,EAAE,YAAY;IACtB,QAAQ,EAAE,UAAU;IACpB,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,UAAU;IACtB,SAAS,EAAE,UAAU;CACtB,CAAC;AAEF,SAAS,WAAW,CAAC,IAAY;IAC/B,OAAO,YAAY,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC;AACpC,CAAC;AAED,gBACE,GAAY,EACZ,EACE,QAAQ,GAAG,IAAI,EACf,YAAY,GAAG,KAAK,EACpB,WAAW,GAAG,KAAK,GACpB,GAIG,EAAE;IAEN,yEAAyE;IACzE,8EAA8E;IAC9E,4EAA4E;IAC5E,6EAA6E;IAC7E,sDAAsD;IACtD,MAAM,IAAI,GAAG,CAAC,CAAU,EAAE,EAAE,CAC1B,CAAC,YAAY,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;IAC/D,MAAM,cAAc,GAAG,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC9C,0EAA0E;IAC1E,qEAAqE;IACrE,MAAM,YAAY,GAAG,GAAG,CAAC,KAAK;SAC3B,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC;SACxC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IACtB,MAAM,IAAI,GACR,YAAY,CAAC,MAAM,GAAG,CAAC,IAAI,UAAU,CAAC,YAAY,CAAC,CAAC,CAAE,CAAC;QACrD,CAAC,CAAC,uEAAuE;YACvE,qEAAqE;YACrE,qEAAqE;YACrE,mEAAmE;YACnE,UAAU,CAAC,YAAY,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QAC9D,CAAC,CAAC,IAAI,CAAC;IAEX,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACzD,MAAM,SAAS,GAAG,GAAG,CAAC,KAAK,CAAC,MAAM,CAChC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAChD,CAAC;IAEF,MAAM,MAAM,GAAG,QAAQ,CAAC,cAAc,EAAE,SAAS,CAAC,CAAC;IACnD,IAAI,IAAI,GAAG,cAAc,CAAC;IAC1B,IAAI,YAAY,GAAG,CAAC,CAAC;IACrB,IAAI,IAAI,CAAC,MAAM,GAAG,QAAQ,EAAE,CAAC;QAC3B,IAAI,GAAG,CAAC,GAAG,IAAI,CAAC;aACb,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;aACjE,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;QACtB,YAAY,GAAG,cAAc,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;IACrD,CAAC;IAED,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC/C,MAAM,KAAK,GAAG,SAAS,CAAC,MAAM,CAC5B,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAChD,CAAC;IACF,MAAM,WAAW,GAAG,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAE1C,MAAM,KAAK,GAAiB,IAAI;SAC7B,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;SAC/C,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QACX,EAAE,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,IAAI,CAAC;QACzB,IAAI,EAAE,CAAC,CAAC,IAAI;QACZ,IAAI,EAAE,CAAC,CAAC,IAAI;QACZ,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC;QAC9B,MAAM,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC;KACnC,CAAC,CAAC,CAAC;IAEN,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAChD,MAAM,KAAK,GAAiB,KAAK;SAC9B,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QACX,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC;QAC/B,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,IAAI,CAAC;QAC7B,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC;KAC1B,CAAC,CAAC;SACF,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IAEjE,OAAO;QACL,OAAO,EAAE,GAAG,CAAC,OAAO,IAAI,EAAE;QAC1B,MAAM,EAAE;YACN,QAAQ,EAAE,GAAG,CAAC,KAAK,CAAC,MAAM;YAC1B,QAAQ,EAAE,GAAG,CAAC,KAAK,CAAC,MAAM;YAC1B,KAAK,EAAE,KAAK,CAAC,MAAM;YACnB,KAAK,EAAE,KAAK,CAAC,MAAM;YACnB,0EAA0E;YAC1E,wEAAwE;YACxE,yDAAyD;YACzD,eAAe,EAAE,YAAY;gBAC3B,CAAC,CAAC,CAAC;gBACH,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM;YAC9C,cAAc,EAAE,WAAW;gBACzB,CAAC,CAAC,CAAC;gBACH,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM;YAC5D,YAAY;SACb;QACD,KAAK;QACL,KAAK;KACN,CAAC;AACJ,CAAC"}

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

@@ -62,13 +62,15 @@ const TtscGraphApplication_1 = require("../TtscGraphApplication");
  * and the library owns the registration again.
  */
 function createServer(graph, version) {
-    void version;
-    return (0, mcp_1.createMcpServer)({
+    const server = (0, mcp_1.createMcpServer)({
         "protocol": "class",
         "name": "ttsc-graph",
         "execute": new TtscGraphApplication_1.TtscGraphApplication(graph),
         "application": _llmApplicationFinalize_1._llmApplicationFinalize({
             description: "## Code Graph MCP\n\n`inspect_typescript_graph` returns a compiler-built TypeScript graph contract\nfor the current on-disk source snapshot.\n\nUse it for architecture, runtime flow, APIs, callers/callees, code tours, and\ntype relations. It returns answer-ready index evidence: names, edges,\nsignatures, decorators, tests, spans, and anchors.\n\nEvery returned fact \u2014 each name, edge, signature, and span \u2014 is\ncompiler-resolved and verified for the snapshot that call synchronized, so\ntrust it without re-checking against files. Where an operation ranks a\nshortlist against your question (`lookup`, `entrypoints`, `tour`), the facts\nstay verified but the selection is heuristic: judge whether its coverage\nanswers you, and a follow-up request or a read of a cited span is fair when\nit does not.\n\n## Requests\n\nA request is a union: pick the single type below that best fits the question,\nand submit exactly that one.\n\n- `tour`: architecture, runtime flow, orientation, or a code tour. One call is\n  the whole answer; do not split it. Name the machinery you expect it to be\n  made of in its `reinterpretations`, or send none.\n- `entrypoints`: find where execution starts when entry points are unknown.\n- `lookup`: locate a named symbol.\n- `trace`: follow calls or data flow forward or backward from a symbol, or \u2014\n  with `to` \u2014 the path between two symbols when both ends are known, which is\n  the one call that answers \"how does A reach B\".\n- `details`: signatures, members, and relations of named symbols \u2014 including\n  the classes that implement an interface, which is the one call that answers\n  \"what actually implements this\".\n- `overview`: project layers and folder structure.\n- `escape`: the answer is outside the graph (source body text, non-TypeScript\n  files, exact search).\n\n## Chain of Thought\n\nFill these fields in order before the call; each one narrows the reasoning\ntoward the single request you submit.\n\n- `question`: the code question, in the user's own words.\n- `draft`: `{ reason, type }` \u2014 why the smallest request that could answer it,\n  then that request's `type`.\n- `review`: fix a broad, stale, or duplicate draft. If the graph already\n  answered, or the evidence is outside it, escape.\n- `request`: the final choice. Each branch documents its own fields; fill them\n  from what the branch says, not from what another branch wanted.\n\n## What to trust\n\nBefore source edits, every returned fact is compiler-resolved and verified.\nNever use extra graph calls, repository search, or file reads to doubt,\nfact-check, re-derive, re-narrate, or re-confirm a returned node, span, edge,\nsignature, decorator, test, reference, step, or anchor. The server resolved\neach one to the type-checked program for the snapshot the call synced to, and\n`audit` says so on every result.\n\nSelection is the separate question. `lookup`, `entrypoints`, and `tour` match\nyour question and return a scored, ranked, per-file-capped, limited\nshortlist; their facts are still verified, but whether the shortlist covers\nwhat you asked is yours to judge, and their `audit` says that instead of\nclaiming completeness. A follow-up request or a read of a cited span for\nmissed coverage is legitimate \u2014 re-confirming a fact the graph already\nresolved is not.\n\n## Stop\n\nLet the result's `next` set the pace, and do not re-confirm what the graph\nresolved.\n\n- A span is a citation, not a cue to open the file to re-check a fact.\n- Follow the result's `next`: `answer` means stop and answer from it, `inspect`\n  means make exactly the one request it names, `outside` means escape,\n  `clarify` means restate the request.\n- For a ranked shortlist (`lookup`, `entrypoints`, `tour`), `next` and\n  `truncated` say whether coverage is settled; when it is not, one more\n  request is the right move \u2014 not a file read to re-verify facts already\n  given.",
+            config: {
+                strict: false
+            },
             functions: [
                 {
                     description: "Answer a TypeScript question from the compiler's own index of this\nrepository.\n\nThe graph holds every symbol, call, type, decorator and test, each with its\nfile and line, resolved from the source on disk now. Submit exactly one\nrequest:\n\n- `tour`: architecture, the runtime flow from the public API to the code that\n  does the work, nearby paths, and the tests to read \u2014 a whole orientation\n  in one call\n- `trace`: what a symbol calls, what calls it, or the path from A to B\n- `details`: signatures, members, and what implements an interface\n- `lookup`: where a named symbol is declared\n- `entrypoints`: where execution starts, when the entry is unknown\n- `overview`: the project's layers and folder structure\n\nEvery fact in a result is the checker's own resolution, audited before\nreturn, so no fact needs verifying; for the ranked operations (`lookup`,\n`entrypoints`, `tour`), judge whether the shortlist covers your question.\nRead a file for what the graph does not carry: a body, the text in a span.",
@@ -78,7 +80,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",
@@ -151,7 +153,7 @@ function createServer(graph, version) {
                                     "arguments"
                                 ],
                                 additionalProperties: false,
-                                description: "A decorator as written on a declaration, carried on the decorated\n's `decorators`. Reported faithfully, not interpreted\nper framework: `name` is the decorator as written (`Controller`, `Get`,\n`TypedRoute.Get`, ...), and statically resolvable literal arguments are\npreserved so a consumer applies its own meaning without re-parsing source."
+                                description: "A decorator as written on a declaration, carried on the decorated\nITtscGraphNode's `decorators`. Reported faithfully, not interpreted\nper framework: `name` is the decorator as written (`Controller`, `Get`,\n`TypedRoute.Get`, ...), and statically resolvable literal arguments are\npreserved so a consumer applies its own meaning without re-parsing source."
                             },
                             "ITtscGraphDecorator.IArgument": {
                                 type: "object",
@@ -173,7 +175,7 @@ function createServer(graph, version) {
                                 },
                                 required: [],
                                 additionalProperties: false,
-                                description: "One argument of an . `literal` is set only when\nthe argument is a string, number, or boolean literal the producer could\nresolve statically, so a consumer can use it without evaluating code."
+                                description: "One argument of an ITtscGraphDecorator. `literal` is set only when\nthe argument is a string, number, or boolean literal the producer could\nresolve statically, so a consumer can use it without evaluating code."
                             },
                             ITtscGraphDetails: {
                                 type: "object",
@@ -372,7 +374,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",
@@ -779,7 +781,7 @@ function createServer(graph, version) {
                                     "startLine"
                                 ],
                                 additionalProperties: false,
-                                description: "A source location grounding a node or edge in real code: the declaration span\nfor a node, or the expression range that produced an edge. Display and\ngrounding only, never identity (a node's id is position-invariant, see\n). Lines and columns are 1-based; MCP keeps evidence as\ncoordinates, so read the file yourself when you truly need source text."
+                                description: "A source location grounding a node or edge in real code: the declaration span\nfor a node, or the expression range that produced an edge. Display and\ngrounding only, never identity (a node's id is position-invariant, see\nITtscGraphNode). Lines and columns are 1-based; MCP keeps evidence as\ncoordinates, so read the file yourself when you truly need source text."
                             },
                             ITtscGraphLookup: {
                                 type: "object",
@@ -1337,7 +1339,7 @@ function createServer(graph, version) {
                                     },
                                     truncated: {
                                         type: "boolean",
-                                        description: "True when the trace hit its node or depth cap; the returned flow stands."
+                                        description: "In an open trace, true when a bound omitted an eligible node or hop."
                                     },
                                     target: {
                                         $ref: "#/$defs/ITtscGraphTrace.INode",
@@ -1679,15 +1681,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",
@@ -2162,5 +2164,14 @@ function createServer(graph, version) {
             ]
         })
     });
+    // @typia/mcp 13.1.0 exposes no class-controller version option. The MCP SDK
+    // keeps the initialize implementation on its public inner Server, so update
+    // that already-constructed implementation before any transport connects.
+    const inner = server.server;
+    if (inner._serverInfo === undefined) {
+        throw new Error("@ttsc/graph: MCP SDK omitted the server implementation");
+    }
+    inner._serverInfo.version = version;
+    return server;
 }
 //# sourceMappingURL=createServer.js.map

package/lib/server/createServer.js.map

@@ -1 +1 @@
-{"version":3,"file":"createServer.js","sourceRoot":"","sources":["../../src/server/createServer.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,oCAA6C;AAC7C,kDAA0B;AAE1B,kEAAgF;AAGhF;;;;;;;;;;;;;;;;;;GAkBG;AACH,sBACE,KAAsB,EACtB,OAAe;IAEf,KAAK,OAAO,CAAC;IACb,OAAO,IAAA,qBAAe;;gBAElB,YAAY;mBACZ,IAAI,2CAAoB,CAAC,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAElC,CAAC;AACJ,CAAC"}
+{"version":3,"file":"createServer.js","sourceRoot":"","sources":["../../src/server/createServer.ts"],"names":[],"mappings":"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"}

package/lib/server/pathPolicy.d.ts

@@ -1,6 +1,12 @@
 import { ITtscGraphNode } from "../structures/ITtscGraphNode";
 /** True for dependency declarations outside the authored project graph. */
 export declare function isExternalNode(node: ITtscGraphNode): boolean;
+/**
+ * True for a `.d.ts` declaration file. Every declaration such a file holds is
+ * ambient by construction, so none of them carries a body the graph can walk
+ * into, whether or not the `declare` keyword is written out.
+ */
+export declare function isDeclarationFile(file: string): boolean;
 /** True for tests, examples, fixtures, generated output, and build artifacts. */
 export declare function isSupportPath(file: string): boolean;
 /** True for source files whose declarations are tests or test helpers. */

package/lib/server/pathPolicy.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isExternalNode = isExternalNode;
+exports.isDeclarationFile = isDeclarationFile;
 exports.isSupportPath = isSupportPath;
 exports.isTestPath = isTestPath;
 exports.isPublicApiNoisePath = isPublicApiNoisePath;
@@ -10,6 +11,14 @@ function isExternalNode(node) {
         node.file.startsWith("bundled://") ||
         /(^|\/)node_modules\//.test(node.file));
 }
+/**
+ * True for a `.d.ts` declaration file. Every declaration such a file holds is
+ * ambient by construction, so none of them carries a body the graph can walk
+ * into, whether or not the `declare` keyword is written out.
+ */
+function isDeclarationFile(file) {
+    return /\.d\.[cm]?ts$/.test(file);
+}
 /** True for tests, examples, fixtures, generated output, and build artifacts. */
 function isSupportPath(file) {
     return (file === "" ||
@@ -18,7 +27,7 @@ function isSupportPath(file) {
         /(^|\/)(test|tests|__tests__|spec|sample|samples|fixture|fixtures|__fixtures__|example|examples)\//.test(file) ||
         /\.(test|spec)\.[cm]?tsx?$/.test(file) ||
         /(^|\/)typings\.[cm]?ts$/.test(file) ||
-        /\.d\.[cm]?ts$/.test(file) ||
+        isDeclarationFile(file) ||
         /(^|\/)(dist|build|coverage|generated|__generated__)\//.test(file));
 }
 /** True for source files whose declarations are tests or test helpers. */

package/lib/server/pathPolicy.js.map

@@ -1 +1 @@
-{"version":3,"file":"pathPolicy.js","sourceRoot":"","sources":["../../src/server/pathPolicy.ts"],"names":[],"mappings":";;;;;;AAEA,2EAA2E;AAC3E,wBAA+B,IAAoB;IACjD,OAAO,CACL,IAAI,CAAC,QAAQ;QACb,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC;QAClC,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CACvC,CAAC;AACJ,CAAC;AAED,iFAAiF;AACjF,uBAA8B,IAAY;IACxC,OAAO,CACL,IAAI,KAAK,EAAE;QACX,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC;QAC7B,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC;QACjC,mGAAmG,CAAC,IAAI,CACtG,IAAI,CACL;QACD,2BAA2B,CAAC,IAAI,CAAC,IAAI,CAAC;QACtC,yBAAyB,CAAC,IAAI,CAAC,IAAI,CAAC;QACpC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC;QAC1B,uDAAuD,CAAC,IAAI,CAAC,IAAI,CAAC,CACnE,CAAC;AACJ,CAAC;AAED,0EAA0E;AAC1E,oBAA2B,IAAY;IACrC,OAAO,CACL,qCAAqC,CAAC,IAAI,CAAC,IAAI,CAAC;QAChD,2BAA2B,CAAC,IAAI,CAAC,IAAI,CAAC,CACvC,CAAC;AACJ,CAAC;AAED,yEAAyE;AACzE,8BAAqC,IAAY;IAC/C,OAAO,CACL,aAAa,CAAC,IAAI,CAAC;QACnB,4BAA4B,CAAC,IAAI,CAAC,IAAI,CAAC;QACvC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,CAC9B,CAAC;AACJ,CAAC"}
+{"version":3,"file":"pathPolicy.js","sourceRoot":"","sources":["../../src/server/pathPolicy.ts"],"names":[],"mappings":";;;;;;;AAEA,2EAA2E;AAC3E,wBAA+B,IAAoB;IACjD,OAAO,CACL,IAAI,CAAC,QAAQ;QACb,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC;QAClC,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CACvC,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,2BAAkC,IAAY;IAC5C,OAAO,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACpC,CAAC;AAED,iFAAiF;AACjF,uBAA8B,IAAY;IACxC,OAAO,CACL,IAAI,KAAK,EAAE;QACX,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC;QAC7B,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC;QACjC,mGAAmG,CAAC,IAAI,CACtG,IAAI,CACL;QACD,2BAA2B,CAAC,IAAI,CAAC,IAAI,CAAC;QACtC,yBAAyB,CAAC,IAAI,CAAC,IAAI,CAAC;QACpC,iBAAiB,CAAC,IAAI,CAAC;QACvB,uDAAuD,CAAC,IAAI,CAAC,IAAI,CAAC,CACnE,CAAC;AACJ,CAAC;AAED,0EAA0E;AAC1E,oBAA2B,IAAY;IACrC,OAAO,CACL,qCAAqC,CAAC,IAAI,CAAC,IAAI,CAAC;QAChD,2BAA2B,CAAC,IAAI,CAAC,IAAI,CAAC,CACvC,CAAC;AACJ,CAAC;AAED,yEAAyE;AACzE,8BAAqC,IAAY;IAC/C,OAAO,CACL,aAAa,CAAC,IAAI,CAAC;QACnB,4BAA4B,CAAC,IAAI,CAAC,IAAI,CAAC;QACvC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,CAC9B,CAAC;AACJ,CAAC"}

package/lib/server/resolveHandle.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveGraphHandle = resolveGraphHandle;
+const TtscGraphNodeId_1 = require("../model/TtscGraphNodeId");
 const exportSurface_1 = require("./exportSurface");
 const pathPolicy_1 = require("./pathPolicy");
 /**
@@ -33,15 +34,15 @@ function resolveGraphHandle(graph, handle, candidateLimit = 12) {
     const byId = graph.node(handle);
     if (byId !== undefined)
         return { node: byId };
-    const byName = resolveGraphName(graph, handle, candidateLimit);
+    const byName = resolveGraphName(graph, handle);
     if (byName.node !== undefined || byName.candidates !== undefined)
         return rank(graph, byName, candidateLimit);
-    const byFile = resolveFileQualified(graph, handle, candidateLimit);
+    const byFile = resolveFileQualified(graph, handle);
     if (byFile.node !== undefined || byFile.candidates !== undefined)
         return rank(graph, byFile, candidateLimit);
     const symbol = symbolPartOf(handle) ?? memberPartOf(handle);
     if (symbol !== undefined)
-        return rank(graph, resolveGraphName(graph, symbol, candidateLimit), candidateLimit);
+        return rank(graph, resolveGraphName(graph, symbol), candidateLimit);
     return {};
 }
 /**
@@ -61,27 +62,21 @@ function memberPartOf(handle) {
 }
 /** The symbol an id-shaped handle names: `dir/file.ts#Class.method:kind`. */
 function symbolPartOf(handle) {
-    const hash = handle.lastIndexOf("#");
-    if (hash < 0)
-        return undefined;
-    const symbol = handle.slice(hash + 1);
-    const kind = symbol.lastIndexOf(":");
-    const name = kind < 0 ? symbol : symbol.slice(0, kind);
-    return name.length > 0 ? name : undefined;
+    return (0, TtscGraphNodeId_1.parseTtscGraphNodeId)(handle)?.name;
 }
-function resolveGraphName(graph, name, candidateLimit) {
+function resolveGraphName(graph, name) {
     const exact = graph.symbols(name);
     if (exact.length === 1)
         return { node: exact[0] };
     if (exact.length > 1)
-        return { candidates: exact.slice(0, candidateLimit) };
+        return { candidates: [...exact] };
     if (name.includes(".")) {
         const suffix = `.${name}`;
         const suffixMatches = graph.nodes.filter((node) => node.kind !== "file" && node.qualifiedName?.endsWith(suffix) === true);
         if (suffixMatches.length === 1)
             return { node: suffixMatches[0] };
         if (suffixMatches.length > 1) {
-            return { candidates: suffixMatches.slice(0, candidateLimit) };
+            return { candidates: suffixMatches };
         }
     }
     return {};
@@ -92,7 +87,7 @@ function resolveGraphName(graph, name, candidateLimit) {
  * disambiguates a common name from what the graph just showed it, and it names
  * exactly one node whenever that file declares the symbol.
  */
-function resolveFileQualified(graph, handle, candidateLimit) {
+function resolveFileQualified(graph, handle) {
     const dot = handle.indexOf(".");
     if (dot <= 0)
         return {};
@@ -106,7 +101,7 @@ function resolveFileQualified(graph, handle, candidateLimit) {
     if (matches.length === 1)
         return { node: matches[0] };
     if (matches.length > 1)
-        return { candidates: matches.slice(0, candidateLimit) };
+        return { candidates: matches };
     return {};
 }
 /** `packages/core/src/renderer.ts` -> `renderer`. */
@@ -125,11 +120,20 @@ function fileStem(file) {
 function rank(graph, resolved, candidateLimit) {
     if (resolved.candidates === undefined)
         return resolved;
-    const ranked = [...resolved.candidates]
-        .sort((a, b) => candidateScore(graph, b) - candidateScore(graph, a))
-        .slice(0, candidateLimit);
+    const ranked = resolved.candidates
+        .map((node) => ({ node, score: candidateScore(graph, node) }))
+        .sort((a, b) => {
+        const score = b.score - a.score;
+        return score !== 0 ? score : compareIdentity(a.node.id, b.node.id);
+    })
+        .slice(0, candidateLimit)
+        .map(({ node }) => node);
     return { candidates: ranked };
 }
+/** Compare position-invariant ids without locale-dependent collation. */
+function compareIdentity(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
 function candidateScore(graph, node) {
     let score = Math.min(48, Math.log2(1 + (0, exportSurface_1.exportFanIn)(graph, node.id)) * 20);
     if (node.exported)